compute

type Artifact struct {
	Alg    string
	Digest string
	Engine string
	Wasm   []byte
}

type Constructor func(EngineConfig) (Engine, error)

type Engine interface {
	Load(ctx context.Context, art Artifact) (Instance, error)
	Name() string
}

type EngineConfig struct {
	// MaxMemoryMB caps guest memory. Engines that bound memory at
	// construction (e.g. wazero's runtime memory-limit) read it here; 0
	// means "engine default".
	MaxMemoryMB int
}

type Instance interface {
	// Invoke runs the compute: JSON bytes in, JSON bytes out, under lim.
	Invoke(ctx context.Context, input []byte, lim Limits) ([]byte, error)
	Close(ctx context.Context) error
}

type Limits struct {
	MaxMemoryMB int
	MaxWall     time.Duration
	// Now is the wall-clock the guest should observe (e.g. JS Date.now()).
	// The processor sets it to the real clock at the moment the op executes,
	// passed via WithNow. Zero = frozen epoch (engine default; bare unit
	// tests). Tests may inject a fixed time here for reproducibility.
	Now time.Time
	// Stderr receives the guest's diagnostic output (console.* / writes to fd
	// 2). nil discards it. The processor wires this to the chassis logger so
	// console.log is visible.
	Stderr io.Writer
	// MetricsSink, if set, is called once per invocation with the runtime
	// measurements (wall time, memory, exit status). The processor wires it to
	// the trace + logger. nil = no metrics.
	MetricsSink func(Metrics)
}

type Manager struct {
	// contains filtered or unexported fields
}

type Metrics struct {
	WallMS      int64
	MemoryBytes uint32
	Status      string // "ok" | "trapped" | "wall-limit"
}

type Ref struct {
	Alg    string // digest algorithm, e.g. "sha256"
	Digest string // hex content digest
}

type Resolver interface {
	Resolve(ctx context.Context, ref Ref) (Artifact, error)
}

type Runner interface {
	Run(ctx context.Context, ref Ref, input []byte) ([]byte, error)
}