workflow

type ChildResolver interface {
	Child(ctx context.Context, ns v1.NamespaceName, name v1.ObjectName) (v1.WorkflowSpec, map[v1.ObjectName]string, error)
}

type ChildWorkflowResolver interface {
	ChildWorkflow(ctx context.Context, ns v1.NamespaceName, name v1.ObjectName) (*v1.Workflow, error)
}

type Config struct {
	DefaultMaxAttempts  int           // per-step, when a step sets no retry (default 1 = no retry)
	DefaultStepTimeout  time.Duration // per-step invocation bound (0 = none)
	PayloadLimit        int64         // max bytes for a run input (at admission and run start) and a step output; 0 = unbounded
	MaxSubworkflowDepth int           // ADR-0099: max sub-workflow nesting (default 8); a deeper chain fails cleanly
	// MaxStepsInFlight bounds the function-step dispatch attempts in flight across all runs; 0 ⇒ no cap (ADR-0146).
	MaxStepsInFlight int
	// DefaultRetryBackoff is the first retry gap of a step whose retry.backoff is unset or 0, doubled per attempt
	// (workflow.defaultRetryBackoff, ADR-0163 Decision 8); 0 ⇒ back to back.
	DefaultRetryBackoff time.Duration
}

type ContractResolver interface {
	Contract(ctx context.Context, image string) (contract v1.WorkflowContract, digest string, err error)
}

type Deps struct {
	Runs     runstate.Store // durable run state (the port; Badger driver in prod, in-memory in tests)
	Dispatch Dispatcher     // the step-invocation seam
	Config   Config
	Clock    clock.Clock   // stamps run timestamps (retention GC input); defaults to the system clock
	Children ChildResolver // ADR-0099: resolves a child workflow's spec for a `workflow:` step (nil ⇒ rejected)
	// Traces is the shared funclog trace sink (ADR-0104): the engine emits the run-root span for INLINE
	// sub-workflow child runs (the reconciler drives only top-level runs). nil ⇒ no child run-root span.
	Traces funclog.TraceSink
	// Notify: a top-level run's key after each record write and on goroutine exit; nil ⇒ none; must not block
	// (ADR-0146: wired to Controller.Enqueue, so the run reconciler mirrors the record).
	Notify func(ns v1.NamespaceName, name v1.ObjectName)
	Logger *slog.Logger
}

type DispatchDeps struct {
	Endpoints activator.Endpoints
	Waker     Waker
	Grant     Granter
	// Protocol, when set, refuses a step function that serves HTTP before any request (ADR-0243 Decision 5).
	Protocol activator.ProtocolFunc
	Client   *http.Client
	Logger   *slog.Logger
}

type DispatchRequest struct {
	Namespace v1.NamespaceName
	Run       v1.ObjectName
	Step      v1.ObjectName
	Target    v1.ObjectName // the function to invoke (materialized name or referenced)
	Attempt   int
	Input     json.RawMessage
	// MaxOutput is the payload limit on the step's output (ADR-0094); 0 ⇒ unbounded. A dispatcher need
	// read no more than one byte past it, since a longer output is rejected anyway.
	MaxOutput int64
	// TraceID / ParentSpanID are the run's W3C trace context (ADR-0102): the dispatcher sets a
	// traceparent header from them so the step-function invocation's span joins the run's trace.
	// Empty TraceID ⇒ no header (additive). ParentSpanID is the step's PRIMARY predecessor (ADR-0105;
	// the run root for a true root step) — the parent edge the step nests under.
	TraceID      string // 32 hex
	ParentSpanID string // 16 hex
	// SpanID is the engine-minted span-id the step function uses as its own (ADR-0105, X-Funcd-Span-Id) so a
	// successor can parent on it. Links are the non-primary fan-in predecessors' span-ids (X-Funcd-Span-Links).
	SpanID string   // 16 hex; "" ⇒ the shim mints its own (direct invoke / additive)
	Links  []string // 16-hex span-ids, same trace
	// Revision is Target's pin from the run record (ADR-0190); nil ⇒ by-name dispatch (a pre-ADR-0190 record).
	Revision *v1.RevisionPin
}

type Dispatcher interface {
	Dispatch(ctx context.Context, req DispatchRequest) (json.RawMessage, error)
}

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

type Granter interface {
	Allow(ns v1.NamespaceName, target v1.ObjectName, pin *v1.RevisionPin) bool
}

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

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

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

type RuntimeResolver interface {
	Runtime(ctx context.Context, image string) (v1.RuntimeName, error)
}

type StartOptions struct {
	Contract   *v1.WorkflowContract     // pinned derived contract; nil ⇒ no run-start input check
	StepImages map[v1.ObjectName]string // step name → resolved digest-pinned image; stamps stepNode.revision (function steps)
	// StepContracts is the ADR-0098 cache's per-step I/O contract, pinned on the record: a when: binds an
	// absent parent-output field to its schema default (ADR-0095). Nil ⇒ no defaults are bound.
	StepContracts map[v1.ObjectName]v1.WorkflowContract
	RunUID        v1.UID                              // the starting WorkflowRun's uid, stamped on the record; empty for an inline child run
	ChildPins     map[v1.ObjectName]runstate.ChildPin // the run's child tree; execute copies it onto the record
	// Pins are the run's step Function revision pins (ADR-0190): execute stores them; a child record gets its subtree's.
	Pins map[v1.ObjectName]v1.RevisionPin
}

type Waker interface {
	Wake(ctx context.Context, fn activator.FunctionRef) (upstream string, err error)
}

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