graph

type BackoffStrategy int

type Graph struct {
	Nodes map[NodeID]*Node
	Order []NodeID // topological execution order
}

type Node struct {
	ID           NodeID
	Kind         NodeKind
	ActionType   string // "sql", "cmd", "http", etc.
	Body         hcl.Body
	Dependencies []NodeID
	// ComponentKey links component-scoped actions back to their parent.
	// Empty for scenario-level actions.
	ComponentKey string
	// ProviderAlias is the scenario-local provider name picked via the
	// `provider = "<alias>"` reserved action attribute. Empty when
	// the scenario does not specify one; the engine's routing then
	// requires exactly one candidate to be unambiguous.
	ProviderAlias string
	// Timeout bounds the action's execute call. Zero means no
	// engine-imposed deadline (the caller's ctx still applies).
	// Set via `timeout = "30s"` in the action body.
	Timeout time.Duration
	// Retry captures a `retry { ... }` block on the action. nil
	// means no retries — the engine calls the provider exactly
	// once. When non-nil, the engine retries failed attempts with
	// the configured backoff.
	Retry *RetryConfig

	// Teardown holds the body of a `lifecycle { teardown { ... } }`
	// block if the action declares one. The body uses the same
	// schema as the outer action body (provider-validated), so a
	// sql action's teardown declares `query`, an http action's
	// declares `method` and `url`, and so on.
	//
	// nil means the action has no teardown operation. Orchard's
	// `orchard teardown <record>` command walks actions with
	// non-nil Teardown in reverse topological order; actions with
	// no Teardown are skipped.
	Teardown hcl.Body

	// ManagedTeardown is `lifecycle { managed_teardown = ... }`: nil
	// when unset, so the provider decides whether to record an undo (a
	// typed insert deletes its row; a typed update restores rows it
	// owns); false to opt out; true to ask for an undo even where the
	// provider wouldn't record one by default (restoring rows a typed
	// update changed that Orchard didn't create).
	ManagedTeardown *bool

	// SourceRange locates the action's definition in its source
	// file. Non-zero when the body was parsed from HCL text (the
	// common case) and used by the engine to decorate runtime
	// errors with `filename:line` so failures point at a specific
	// scenario line rather than a bare node ID.
	SourceRange hcl.Range

	// Instance is set when the action was expanded by count /
	// for_each; its count.* / each.* namespace is in scope for the
	// action body and teardown. nil for a plain action.
	Instance *parser.Instance
}

type NodeID string

type NodeKind int

type RetryConfig struct {
	MaxAttempts int
	Delay       time.Duration
	Backoff     BackoffStrategy
	MaxDelay    time.Duration // zero = no cap
}