pods

type AStarIn struct {
	Map         GridMap
	Start, Goal [2]int
}

type AStarOut struct{ Path [][2]int }

type AStarPod struct{}

type AudioBuffer struct {
	SampleRate int
	Channels   int
	Samples    [][]float32 // [ch][n]
}

type CullingIn struct {
	Frustum Frustum
	Bounds  [][6]float32 // AABB: xmin,ymin,zmin,xmax,ymax,zmax
}

type CullingOut struct{ Visible []bool }

type CullingPod struct{}

type ExecContext struct {
	Ctx      context.Context
	UseGPU   bool             // high-level knob; pods may override per-op
	Report   *detector.Report // detector output (limits, features, recs)
	GPU      GPUHooks         // nil unless -tags=gpu and initialized
	TempPool *Pool            // scratch buffers (optional)
	Now      time.Time
}

type Frustum struct{ Planes [6][4]float32 } // ax+by+cz+d >= 0

type GEMMIn struct {
	M, N, K int
	A, B    []float32 // row-major A[M,K], B[K,N]
	Alpha   float32   // C = alpha*A*B + beta*C (beta=0 here for baseline)
}

type GEMMOut struct {
	C []float32 // row-major C[M,N]
}

type GEMMPod struct{}

type GPUHooks interface {
	DispatchScanU32(in []uint32, inclusive bool) ([]uint32, error)
	DispatchReduceF32(in []float32, kind string) (float32, error) // kind: "sum"|"max"|"mean"
	DispatchSoftmaxF32(in []float32) ([]float32, error)
}

type GridMap struct {
	W, H  int
	Solid func(x, y int) bool
	Cost  func(x, y int) float32 // optional; nil -> 1
}

type ImageFrame struct {
	W, H   int
	Pixels []float32 // RGB or RGBA planar/interleaved; keep it simple first
	Stride int
	Format string // "RGB", "RGBA", "YUV420", …
}

type LayerNormIn struct {
	X   []float32
	Eps float32
}

type LayerNormOut struct{ Y []float32 } // per-vector LN; extend with shape later

type LayerNormPod struct{}

type Mesh struct {
	Positions []float32 // xyzxyz…
	Normals   []float32 // optional
	Indices   []uint32
}

type Pod interface {
	Name() string
	Run(ctx *ExecContext, in any) (out any, err error)
}

type Pool struct{}

type RGBToYUVIn struct {
	Frame ImageFrame // Format "RGB"
}

type RGBToYUVOut struct {
	Y, U, V []float32 // planar 4:4:4 for simplicity
}

type RGBToYUVPod struct{}

type ReduceIn struct {
	In   []float32
	Kind string // "sum"|"min"|"max"
}

type ReduceOut struct {
	Value float32
}

type ReducePod struct{}

type Runner func() error

type STFTIn struct {
	Audio   AudioBuffer
	WinSize int
	Hop     int
	Window  string // "hann" (default), …
}

type STFTOut struct {
	Spectrogram [][]complex64 // [frame][bin]
}

type STFTPod struct{}

type ScanIn struct {
	In        []uint32
	Inclusive bool
}

type ScanOut struct {
	Out []uint32
}

type ScanPod struct{}

type SoftmaxIn struct{ Logits []float32 }

type SoftmaxOut struct{ Probs []float32 }

type SoftmaxPod struct{}

type Tensor[T ~float32 | ~float64] struct {
	Data    []T
	Shape   []int // row-major
	Strides []int
}