node

type Base struct {
	ID         string        `json:"id"`
	Name       string        `json:"display_name"`
	RunWhen    spi.RunWhen   `json:"run_when,omitempty"`
	Assertions []assert.Spec `json:"assertions,omitempty"`
	Outputs    []output.Spec `json:"outputs,omitempty"`
}

type Bound struct {
	Base    Base
	Kind    spi.Kind
	Run     func(ctx context.Context, in value.Value, rt Runtime) (Result, error)
	Refs    []string // child flow ids (FlowReferencer), for cycle/existence validation
	Targets []string // route targets (Router), for branch-target validation
}

type Clock interface {
	Sleep(ctx context.Context, d time.Duration) error
	Now() time.Time
}

type FlowReferencer interface {
	ReferencedFlows() []string
}

type HTTPDoer interface {
	Do(req *http.Request) (*http.Response, error)
}

type Result struct {
	// Outputs are the named values the node produces for downstream nodes.
	Outputs value.Map
	// Assert is the value the node's declared assertions/outputs run against
	// when Provided is true. A provider that asserts over its own Outputs leaves
	// it zero — the engine boxes Outputs once, and only when assertions or
	// outputs are actually declared. Set it only to assert over something else
	// (the assert node targets the whole input context).
	Assert value.Value
	// Provided is set by nodes that expose a value for the framework's uniform
	// assertion/output post-step (request, set_variable, assert, loop). Nodes
	// that evaluate their own assertions (poll, sse) or route (branch) or have
	// none (delay, module) leave it false, and the engine skips the post-step.
	Provided bool
	// Assertions is set by self-evaluating nodes (poll, sse) to surface the
	// assertion outcomes they evaluated internally — the engine records these on
	// the node result, since its post-step (which fills them for provider nodes)
	// does not run for self-evaluating nodes.
	Assertions assert.Results
	// Routed is set by routing nodes (branch): the successor ids execution was
	// routed to. The engine skips every other successor (and its subtree). Nil
	// for ordinary nodes — all successors run.
	Routed []string
}

type Router interface {
	RouteTargets() []string
}

type Run[Cfg hasBase] func(ctx context.Context, cfg Cfg, in value.Value, rt Runtime) (Result, error)

type Runtime struct {
	HTTP    HTTPDoer
	Clock   Clock
	Subflow SubflowRunner
	Vars    spi.DynamicResolver
}

type SubflowRunner interface {
	RunSubflow(ctx context.Context, flowID string, in value.Map) (value.Map, error)
	RunInline(ctx context.Context, f flow.Flow, in value.Map) (value.Map, error)
}