workflow

type AdaptConfig struct {
	Name          string
	Description   string
	Revision      string
	Configuration any

	// Budget is permanently allocated from the parent when the child starts.
	Budget       run.Budget
	Capabilities run.CapabilitySet
}

type BindingRole string

type BindingTopology struct {
	Role         BindingRole       `json:"role"`
	ID           string            `json:"id,omitempty"`
	ProgramRef   run.ProgramRef    `json:"program_ref"`
	InputSchema  jsonschema.Schema `json:"input_schema"`
	OutputSchema jsonschema.Schema `json:"output_schema"`
	// Budget is the non-renewable allocation for each child start.
	Budget       run.Budget        `json:"budget"`
	Capabilities run.CapabilitySet `json:"capabilities"`
}

type CallConfig struct {
	ID    string
	Child run.ChildBinding
}

type Config struct {
	Name          string
	Description   string
	Stages        []Stage
	Revision      string
	Configuration any
}

type ForkBranch struct {
	ID    string
	Child run.ChildBinding
}

type ForkConfig[I, B, O any] struct {
	// ID is unique within the Workflow and remains stable across restoration.
	ID string

	// Branches is a non-empty list in stable declaration order. Every branch
	// accepts I and produces B.
	Branches []ForkBranch

	// WindowSize is the positive number of branches started and settled as one
	// execution window before the next window begins.
	WindowSize uint32

	Reduce ForkReducer[I, B, O]
}

type ForkReducer[I, B, O any] func(ctx context.Context, input I, branchOutputs []B) (O, error)

type LoopConfig[T any] struct {
	// ID is unique within the Workflow and remains stable across restoration.
	ID string

	Body run.ChildBinding

	// MaxIterations bounds body child Processes. Its zero value is unlimited;
	// a finite zero is rejected because a Loop runs its body at least once.
	MaxIterations run.Quota

	Predicate LoopPredicate[T]
}

type LoopPredicate[T any] func(ctx context.Context, value T) (bool, error)

type LoopResult[T any] struct {
	// Value is the output of the last completed body iteration.
	Value      T      `json:"value"`
	Iterations uint64 `json:"iterations"`
	Satisfied  bool   `json:"satisfied"`
}

type MapConfig[I, O any] struct {
	// ID is unique within the Workflow and remains stable across restoration.
	ID string

	Child run.ChildBinding

	// WindowSize is the positive number of items started and settled as one
	// execution window before the next window begins. Only that window is
	// decoded into I values; snapshot recovery still validates the full input.
	WindowSize uint32

	// MaxItems is the positive maximum accepted input length.
	MaxItems uint32
}

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

type StageKind string

type StageTopology struct {
	ID           string            `json:"id"`
	Kind         StageKind         `json:"kind"`
	InputSchema  jsonschema.Schema `json:"input_schema"`
	OutputSchema jsonschema.Schema `json:"output_schema"`
	// Bindings are exact child bindings in stable declaration order.
	Bindings []BindingTopology `json:"bindings,omitempty"`
	// WindowSize is the fixed Fork or Map execution-window size.
	WindowSize uint32 `json:"window_size,omitzero"`
	// MaxItems is the maximum accepted Map input length.
	MaxItems uint32 `json:"max_items,omitzero"`
	// MaxIterations is present only for a Loop, including an unlimited Loop.
	MaxIterations *run.Quota `json:"max_iterations,omitzero"`
}

type SwitchCase struct {
	ID    string
	Child run.ChildBinding
}

type SwitchConfig[I any] struct {
	// ID is unique within the Workflow and remains stable across restoration.
	ID string

	Select SwitchSelector[I]

	// Cases is a non-empty list in stable declaration order.
	Cases []SwitchCase
}

type SwitchSelector[I any] func(ctx context.Context, input I) (caseID string, err error)

type Topology struct {
	Descriptor run.Descriptor `json:"descriptor"`
	// Stages are projected in execution order.
	Stages []StageTopology `json:"stages"`
}

type TransformFunc[I, O any] func(ctx context.Context, input I) (O, error)