graph.md

[**@tangle-network/agent-runtime**](../README.md)

***

[@tangle-network/agent-runtime](../README.md) / runtime/graph

# runtime/graph

## Interfaces

### AuthoredCodeOptions

`@tangle-network/agent-runtime/graph` — the runtime-native multi-agent graph engine.

Design record: agent-runtime#966 (the map) and its closed tickets. Build sequence: #979 (this
contract + registry + the four core kinds), #980 (scheduler over typed ports), #981 (journal
fold and kill-anywhere replay), #982 (the `runGraph` preset).

#### Properties

##### allowedImports?

> `readonly` `optional` **allowedImports?**: readonly `string`[]

Import specifiers an authored module may name. Empty (the default) bans every import. A
 specifier admits ANY import form of that module (named, namespace, default) — the lint
 gates WHICH module, not the syntax used to reach it.

##### context?

> `readonly` `optional` **context?**: `string`

Names the refusal, e.g. `code mode (node-1)`. Defaults to `authored code`.

***

### CompiledEdge

#### Properties

##### id

> `readonly` **id**: `string`

##### spec

> `readonly` **spec**: [`EngineGraphEdge`](#enginegraphedge)

##### fromPort

> `readonly` **fromPort**: `string`

##### toPort

> `readonly` **toPort**: `string`

***

### CompiledNode

#### Properties

##### id

> `readonly` **id**: `string`

##### kind

> `readonly` **kind**: [`NodeKind`](#nodekind)

##### config

> `readonly` **config**: `unknown`

##### join

> `readonly` **join**: `"all"` \| `"any"` \| `"any_failed"` \| `"all_done"`

##### maxVisits

> `readonly` **maxVisits**: `number`

##### oracle

> `readonly` **oracle**: `boolean`

##### pure

> `readonly` **pure**: `boolean`

##### terminal

> `readonly` **terminal**: `boolean`

##### deliverable?

> `readonly` `optional` **deliverable?**: [`DeliverableSpec`](../runtime.md#deliverablespec)\<`unknown`\>

The check this node must pass to count DELIVERED; resolved per #973.

##### inbound

> `readonly` **inbound**: readonly [`CompiledEdge`](#compilededge)[]

##### outbound

> `readonly` **outbound**: readonly [`CompiledEdge`](#compilededge)[]

##### modelFired

> `readonly` **modelFired**: `boolean`

Spawned by a supervisor through a `delegates` edge, never entered by the scheduler.

##### spec

> `readonly` **spec**: [`EngineGraphNode`](#enginegraphnode)

***

### CompiledGraph

#### Properties

##### nodes

> `readonly` **nodes**: `ReadonlyMap`\<`string`, [`CompiledNode`](#compilednode)\>

##### edges

> `readonly` **edges**: readonly [`CompiledEdge`](#compilededge)[]

##### entries

> `readonly` **entries**: readonly `string`[]

##### terminals

> `readonly` **terminals**: readonly `string`[]

##### root

> `readonly` **root**: `string`

##### maxNodeVisits

> `readonly` **maxNodeVisits**: `number`

***

### ConditionLeaf

#### Properties

##### path

> `readonly` **path**: `string`

Dotted path with `[N]` indexing into the guard context, e.g. `out.findings[0].severity`.

##### op

> `readonly` **op**: `"in"` \| `"eq"` \| `"neq"` \| `"gt"` \| `"gte"` \| `"lt"` \| `"lte"` \| `"contains"` \| `"exists"` \| `"truthy"`

##### value?

> `readonly` `optional` **value?**: `unknown`

***

### EngineGraphNode

#### Properties

##### id

> `readonly` **id**: `string`

##### kind

> `readonly` **kind**: `string`

`<id>/v<n>` into the engine's kind registry.

##### config?

> `readonly` `optional` **config?**: `unknown`

This node's config, validated by its kind's `validateConfig` at compile.

##### flags?

> `readonly` `optional` **flags?**: [`NodeFlags`](#nodeflags)

Per-node flags — properties of the node, never of its kind (agent-runtime#970).

##### ports?

> `readonly` `optional` **ports?**: `object`

Node-level port declarations, merged OVER the kind's. A kind whose surface depends on its
 config (a script) declares ports here; a typed kind's declared ports stay authoritative.

###### inputs?

> `readonly` `optional` **inputs?**: readonly [`PortSpec`](#portspec)[]

###### outputs?

> `readonly` `optional` **outputs?**: readonly [`PortSpec`](#portspec)[]

##### join?

> `readonly` `optional` **join?**: `"all"` \| `"any"` \| `"any_failed"` \| `"all_done"`

Which inbound gating-edge outcomes release this node. Default `all`.

##### maxVisits?

> `readonly` `optional` **maxVisits?**: `number`

Entered more than this many times fails the run `cycle-budget-exceeded`.

##### deliverable?

> `readonly` `optional` **deliverable?**: [`DeliverableSpec`](../runtime.md#deliverablespec)\<`unknown`\>

This node's completion check; a terminal without one (or a kind/graph default) refuses.

##### terminal?

> `readonly` `optional` **terminal?**: `boolean`

Force-mark a terminal. Absent, a node with no outbound gating edge is terminal.

##### entry?

> `readonly` `optional` **entry?**: `boolean`

Force a node out of (or into) the run's entry set. Absent, a node with no inbound edge is an
 entry, and the declared root always is. A node another node SPAWNS — the `runGraph` preset's
 workers and analysts — sets `false`: the scheduler must never enter it on its own.

##### profile?

> `readonly` `optional` **profile?**: `Readonly`\<`Partial`\<`AgentProfile`\>\>

Profile fields merged over the engine-authored `{ name: id }` for this node's spawns.

##### budget?

> `readonly` `optional` **budget?**: [`Budget`](../index.md#budget-4)

Per-instance reservation for this node's spawns; falls back to the run's `perNode`.

***

### EngineGraphEdge

#### Properties

##### id?

> `readonly` `optional` **id?**: `string`

Stable id for the ledger; defaults to `<from>-><to>#<ordinal>`.

##### kind

> `readonly` **kind**: [`GraphEdgeKind`](#graphedgekind)

##### from

> `readonly` **from**: `object`

###### node

> `readonly` **node**: `string`

###### port?

> `readonly` `optional` **port?**: `string`

##### to

> `readonly` **to**: `object`

###### node

> `readonly` **node**: `string`

###### port?

> `readonly` `optional` **port?**: `string`

##### guard?

> `readonly` `optional` **guard?**: [`Condition`](#condition)

Evaluated over the source's settle context; absent = satisfied by completion.

##### projection?

> `readonly` `optional` **projection?**: [`Projection`](#projection-1)

`data` edges only: ONE pure reshape of the admitted payload.

##### maxTraversals?

> `readonly` `optional` **maxTraversals?**: `number`

Refuses the traversal past this many firings (ledgered `unpropagated`); `0` closes the edge from the start.

##### directive?

> `readonly` `optional` **directive?**: [`PromptHandle`](../runtime.md#prompthandle)

`delegates`/`analyzes`: the versioned directive appended to the target's task.

***

### EngineGraphSpec

#### Properties

##### nodes

> `readonly` **nodes**: readonly [`EngineGraphNode`](#enginegraphnode)[]

##### edges

> `readonly` **edges**: readonly [`EngineGraphEdge`](#enginegraphedge)[]

##### root?

> `readonly` `optional` **root?**: `string`

Root node for the graph-level completion check. Defaults to the single entry node.

##### deliverable?

> `readonly` `optional` **deliverable?**: [`DeliverableSpec`](../runtime.md#deliverablespec)\<`unknown`\>

Becomes the ROOT node's completion check when the root declares none (#973).

##### maxNodeVisits?

> `readonly` `optional` **maxNodeVisits?**: `number`

***

### GraphEngineOptions

#### Properties

##### kinds?

> `readonly` `optional` **kinds?**: readonly [`AnyNodeKind`](#anynodekind)[]

Kinds to register beside the core set. A host adds its own here; nothing is global.

##### effects?

> `readonly` `optional` **effects?**: `Readonly`\<`Record`\<`string`, `unknown`\>\>

The host's effect table, by name. A kind receives only the effects it declared.

##### coreKinds

> `readonly` **coreKinds**: readonly [`AnyNodeKind`](#anynodekind)[]

The core set. Injected so a test can substitute, and so the engine never imports a
 backend-specific factory at module load.

***

### GraphEngine

#### Properties

##### kinds

> `readonly` **kinds**: [`Registry`](#registry)\<[`AnyNodeKind`](#anynodekind)\>

##### effects

> `readonly` **effects**: `Readonly`\<`Record`\<[`EffectName`](#effectname), `unknown`\>\>

#### Methods

##### requiredEffects()

> **requiredEffects**(): `string`[]

Every effect name any registered kind declares — what a host must provide for this engine's
 whole kind set to be runnable. Listed, never discovered mid-run.

###### Returns

`string`[]

##### missingEffects()

> **missingEffects**(): `string`[]

The declared effects no host value covers. Empty means every registered kind is runnable.

###### Returns

`string`[]

***

### FoldEdge

#### Properties

##### state

> **state**: [`FoldEdgeState`](#foldedgestate)

##### consumedOnce

> **consumedOnce**: `boolean`

Set by a `join-state` whose wave this edge was pending inside; cleared when the in-flight
 completion it refers to settles (absorbed, never re-released).

##### traversals

> **traversals**: `number`

Delivered consumptions — what the per-edge cap counts.

##### judgedSourceSettles

> **judgedSourceSettles**: `number`

How many of the source's settles this edge has accounted for — by a journaled verdict or by
 an absorption. The idempotence key: a kill between a settle and its verdicts re-judges ONLY
 the unaccounted edges on restart, never a judged or absorbed one twice.

##### payloadRef?

> `optional` **payloadRef?**: `string`

The admitted source payload this state reflects (the source settle's outRef).

##### capped

> **capped**: `boolean`

***

### FoldInstance

#### Properties

##### node

> `readonly` **node**: `string`

##### instance

> `readonly` **instance**: `string`

##### visit

> `readonly` **visit**: `number`

##### inputRef?

> `optional` **inputRef?**: `string`

##### status

> **status**: [`FoldInstanceStatus`](#foldinstancestatus)

##### settle?

> `optional` **settle?**: [`GraphNodeSettle`](#graphnodesettle)

***

### FoldSuspension

#### Properties

##### token

> `readonly` **token**: `string`

##### node

> `readonly` **node**: `string`

##### instance

> `readonly` **instance**: `string`

##### onExpire

> `readonly` **onExpire**: `"default"` \| `"fail"` \| `"wait"`

##### expiresAtMs?

> `readonly` `optional` **expiresAtMs?**: `number`

##### defaultRef?

> `readonly` `optional` **defaultRef?**: `string`

##### status

> **status**: `"pending"` \| `"expired"` \| `"woken"`

***

### FoldNode

#### Properties

##### visits

> **visits**: `number`

##### blocked

> **blocked**: `boolean`

##### settles

> **settles**: [`GraphNodeSettle`](#graphnodesettle)[]

***

### GraphFoldState

#### Properties

##### settleSeq

> **settleSeq**: `object`

Next settle ordinal; the fold is the only writer, so replay reproduces the same order.

###### value

> **value**: `number`

##### nodes

> `readonly` **nodes**: `Map`\<`string`, [`FoldNode`](#foldnode)\>

##### edges

> `readonly` **edges**: `Map`\<`string`, [`FoldEdge`](#foldedge)\>

##### instances

> `readonly` **instances**: `Map`\<`string`, [`FoldInstance`](#foldinstance)\>

Every node instance the journal knows, keyed by `<node>#<visit>`.

##### spawnedIds

> `readonly` **spawnedIds**: `Map`\<`string`, `string`\>

Kernel node id → engine instance label, from `spawned`.

##### suspensions

> `readonly` **suspensions**: `Map`\<`string`, [`FoldSuspension`](#foldsuspension)\>

##### exhaustedEdges

> `readonly` **exhaustedEdges**: `Set`\<`string`\>

***

### GatingEdge

#### Properties

##### edge

> `readonly` **edge**: [`CompiledEdge`](#compilededge)

##### folded

> `readonly` **folded**: [`FoldEdge`](#foldedge) \| `undefined`

***

### JoinDecision

#### Properties

##### release

> `readonly` **release**: `boolean`

Whether the node releases now.

##### consuming

> `readonly` **consuming**: readonly [`GatingEdge`](#gatingedge)[]

The edges whose outcomes produced this release — the ones a traversal cap judges.

##### blocked

> `readonly` **blocked**: `boolean`

Whether the node can never release again on this wave (recorded like skipped-by-guard).

***

### PortSpec

One declared port on a node. Ports are how a `data` edge binds one node's output to another's
input with a type the compiler can check structurally before any spend. A node has two implicit
output ports beside its declared ones: `out` (its result) and `trace` (its `WorkerTraceEvidence`
by `traceRef`); only an `analyzes` edge may bind `trace`.

#### Properties

##### name

> `readonly` **name**: `string`

##### schema

> `readonly` **schema**: [`JsonSchema`](#jsonschema)

##### description?

> `readonly` `optional` **description?**: `string`

***

### GraphHost

What a nesting kind needs from its host: run one graph, on the host's own kinds and effects.
 Declared here (not imported from the scheduler) so the contract module stays dependency-free.

#### Methods

##### runNested()

> **runNested**(`graph`, `task`, `options`): `Promise`\<\{ `kind`: `string`; `out?`: `unknown`; \}\>

###### Parameters

###### graph

`unknown`

###### task

`string`

###### options

###### budget

`unknown`

###### perNode?

`unknown`

###### runId

`string`

###### signal?

`AbortSignal`

###### Returns

`Promise`\<\{ `kind`: `string`; `out?`: `unknown`; \}\>

***

### NodeKind

The validated declaration every kind provides. `Config` is the per-node config shape;
 `Effects` is the tuple of host capabilities it declares, so the context `run` receives is typed
 to exactly that tuple.

#### Extends

- [`Registered`](#registered)

#### Type Parameters

##### Config

`Config` = `unknown`

##### Effects

`Effects` *extends* `ReadonlyArray`\<[`EffectName`](#effectname)\> = `ReadonlyArray`\<[`EffectName`](#effectname)\>

#### Properties

##### id

> `readonly` **id**: `string`

Kind id, e.g. `agent`, `integration.invoke`. With `version`, forms the handle `<id>/v<n>`.

###### Overrides

[`Registered`](#registered).[`id`](#id-6)

##### version

> `readonly` **version**: `number`

###### Overrides

[`Registered`](#registered).[`version`](#version-2)

##### description

> `readonly` **description**: `string`

##### validateConfig

> `readonly` **validateConfig**: (`raw`, `context`) => `Config`

Validate and narrow one node's config. Throw `ValidationError` to refuse; the compiler
 surfaces the message with the node id prefixed.

###### Parameters

###### raw

`unknown`

###### context

`string`

###### Returns

`Config`

##### configSchema

> `readonly` **configSchema**: [`JsonSchema`](#jsonschema)

The portable form of `validateConfig`'s accepted shape, for manifests and hosts.

##### inputs

> `readonly` **inputs**: readonly [`PortSpec`](#portspec)[]

Declared input ports; a `data` edge may bind only these. Empty for a source node.

##### outputs

> `readonly` **outputs**: readonly [`PortSpec`](#portspec)[]

Declared output ports beside the implicit `out` and `trace`.

##### effects

> `readonly` **effects**: `Effects`

Host capabilities this kind reaches for, by name. The context is narrowed to exactly these.

##### onCrash

> `readonly` **onCrash**: [`OnCrash`](#oncrash)

##### budget

> `readonly` **budget**: [`BudgetMode`](#budgetmode)

##### run

> `readonly` **run**: (`args`) => [`Agent`](../runtime.md#agent-2)\<`unknown`, `unknown`\>

Build the agent for one node instance. The kernel spawns it under `Scope.spawn`, so it is
authorized, classified, journaled, pooled and gated like any child — the kind owns only what
the agent DOES. `profile` is the node's pinned profile (an `agent`/`supervisor` kind runs it;
a `script` kind may ignore it); `inputs` are the resolved, content-addressed port values;
`effects` is the narrowed host context; `spawn` is the kernel's per-spawn context when the
kind needs it (a supervisor kind threads it into `nodeContext`).

###### Parameters

###### args

###### config

`Config`

###### profile

`AgentProfile`

###### inputs

`Readonly`\<`Record`\<`string`, `unknown`\>\>

###### effects

[`EffectContext`](#effectcontext)\<`Effects`\>

###### spawn?

[`WorkerSpawnContext`](../runtime.md#workerspawncontext)

###### host?

[`GraphHost`](#graphhost)

The engine hosting this node, for a kind that runs a graph of its own (`subgraph`). The
 scheduler supplies it; a kind that does not nest ignores it.

###### Returns

[`Agent`](../runtime.md#agent-2)\<`unknown`, `unknown`\>

***

### NodeFlags

Per-node flags a graph author sets; they are node properties, not kinds (agent-runtime#970).

#### Properties

##### oracle?

> `readonly` `optional` **oracle?**: `boolean`

An oracle — a judge, grader, auditor, trace analyst — may be bound only by an `analyzes`
 edge. The compiler refuses a `delegates` or `data` edge INTO an oracle: an edge to a grader
 leaks the rubric.

##### pure?

> `readonly` `optional` **pure?**: `boolean`

`script` only: pure over `(config, inputs)` ⇒ budget exempt, output restorable on replay,
 runs in-process. A pure script that settles with a different `outRef` for the same inputs
 has lied, and the first replay mismatch is an engine error.

***

### AgentKindConfig

#### Properties

##### backend?

> `readonly` `optional` **backend?**: [`ExecutorConfig`](../runtime.md#executorconfig)

Where this node's profile runs. Omit to inherit the engine's default backend.

##### deliverable?

> `readonly` `optional` **deliverable?**: [`DeliverableSpec`](../runtime.md#deliverablespec)\<`unknown`\>

This node's completion check. Omit to inherit the graph's terminal check.

***

### SupervisorKindConfig

#### Properties

##### perWorker

> `readonly` **perWorker**: [`Budget`](../index.md#budget-4)

Per-child budget reserved from the pool on each spawn this supervisor makes.

##### maxLiveWorkers?

> `readonly` `optional` **maxLiveWorkers?**: `number`

***

### ScriptKindConfig

#### Properties

##### body

> `readonly` **body**: [`ScriptBody`](#scriptbody)

##### pure?

> `readonly` `optional` **pure?**: `boolean`

`pure: true` is the promise that the output is a function of `(config, inputs)` alone: the
node is then budget-exempt, its output restorable on replay by content address, and it runs
in-process. A pure script that settles with a different `outRef` for the same inputs has
lied, and the first replay mismatch is an engine error.

##### spent?

> `readonly` `optional` **spent?**: [`Spend`](../index.md#spend)

For a metered script: what it spent. Omit on a pure script. A metered script that reports
 nothing is metered as NOTHING-KNOWN, never as free.

***

### SubgraphKindConfig

Config for a nesting node: the inner graph, and the pool the inner run is given.

#### Properties

##### graph

> `readonly` **graph**: `unknown`

##### budget?

> `readonly` `optional` **budget?**: `unknown`

The inner run's conserved pool. Its spend is the inner pool's, never re-charged here.

##### perNode?

> `readonly` `optional` **perNode?**: `unknown`

***

### EdgeLedger

#### Properties

##### entries

> `readonly` **entries**: readonly [`GraphEdgeTraversal`](#graphedgetraversal)[]

#### Methods

##### record()

> **record**(`edge`, `traversal`, `outcome`, `reason?`): `Promise`\<`void`\>

###### Parameters

###### edge

[`CompiledEdge`](#compilededge)

###### traversal

`number`

###### outcome

`"delivered"` \| `"empty"` \| `"unpropagated"`

###### reason?

`string`

###### Returns

`Promise`\<`void`\>

***

### RegistryHandle

A versioned name: what a graph writes and what a host registers.

#### Extended by

- [`Registered`](#registered)

#### Properties

##### id

> `readonly` **id**: `string`

##### version

> `readonly` **version**: `number`

***

### Registered

Anything a registry holds carries its own handle, so the table cannot drift from the entry.

#### Extends

- [`RegistryHandle`](#registryhandle)

#### Extended by

- [`NodeKind`](#nodekind)

#### Properties

##### id

> `readonly` **id**: `string`

###### Inherited from

[`RegistryHandle`](#registryhandle).[`id`](#id-5)

##### version

> `readonly` **version**: `number`

###### Inherited from

[`RegistryHandle`](#registryhandle).[`version`](#version-1)

***

### Registry

#### Type Parameters

##### T

`T` *extends* [`Registered`](#registered)

#### Methods

##### register()

> **register**(`entry`, `options?`): `void`

Add one entry. A second entry under the same handle is refused unless `replace` is set —
 silently shadowing a registered kind is how a key no caller could produce once survived.

###### Parameters

###### entry

`T`

###### options?

###### replace?

`boolean`

###### Returns

`void`

##### has()

> **has**(`handle`): `boolean`

###### Parameters

###### handle

[`RegistryHandle`](#registryhandle)

###### Returns

`boolean`

##### get()

> **get**(`handle`): `T` \| `undefined`

###### Parameters

###### handle

[`RegistryHandle`](#registryhandle)

###### Returns

`T` \| `undefined`

##### require()

> **require**(`handle`, `context?`): `T`

The entry, or a refusal that names the handle AND lists every registered handle — a miss
 must be diagnosable from its message alone.

###### Parameters

###### handle

[`RegistryHandle`](#registryhandle)

###### context?

`string`

###### Returns

`T`

##### names()

> **names**(): `string`[]

Every registered handle, sorted, as wire spellings. The thing the fourteen predecessors
 mostly could not do and four callers needed.

###### Returns

`string`[]

##### entries()

> **entries**(): `T`[]

Every entry, in `names()` order.

###### Returns

`T`[]

***

### GraphRunContext

#### Properties

##### runId

> `readonly` **runId**: `string`

##### journal

> `readonly` **journal**: [`SpawnJournal`](../runtime.md#spawnjournal)

##### blobs

> `readonly` **blobs**: [`ResultBlobStore`](../runtime.md#resultblobstore)

##### scope

> `readonly` **scope**: [`Scope`](../index.md#scope)\<`unknown`\>

##### abort

> `readonly` **abort**: `AbortController`

##### state

> `readonly` **state**: [`GraphFoldState`](#graphfoldstate)

##### resuming

> `readonly` **resuming**: `boolean`

##### prior

> `readonly` **prior**: readonly [`SpawnEvent`](../runtime.md#spawnevent)[]

Journal events present before this process started; empty on a fresh run.

##### engineSeq

> `readonly` **engineSeq**: `number`

Next engine fold-event ordinal, and next engine `woken` ordinal.

##### engineWokenSeq

> `readonly` **engineWokenSeq**: `number`

##### ledgerSeq

> `readonly` **ledgerSeq**: `number`

Ledger ordinals already used by a prior process.

***

### GraphNodeSettle

One node settlement as the graph result reports it.

#### Properties

##### node

> `readonly` **node**: `string`

##### visit

> `readonly` **visit**: `number`

##### seq

> `readonly` **seq**: `number`

Run-wide settle ordinal. `GraphRunResult.settles` is sorted by it, so the array reads in the
 order the run actually settled — not grouped by node, which is what a reader assumes and
 what the first consumer of this API tripped on.

##### status

> `readonly` **status**: `"done"` \| `"down"`

##### valid?

> `readonly` `optional` **valid?**: `boolean`

The node's completion check verdict; `undefined` when the node declares no check.

##### out?

> `readonly` `optional` **out?**: `unknown`

##### outRef?

> `readonly` `optional` **outRef?**: `string`

##### reason?

> `readonly` `optional` **reason?**: `string`

***

### GraphEdgeTraversal

One ledgered edge firing (or refusal) — the run's observable data flow.

#### Properties

##### edge

> `readonly` **edge**: `string`

##### kind

> `readonly` **kind**: `"data"` \| `"delegates"` \| `"analyzes"`

##### from

> `readonly` **from**: `string`

##### to

> `readonly` **to**: `string`

##### traversal

> `readonly` **traversal**: `number`

##### outcome

> `readonly` **outcome**: `"delivered"` \| `"empty"` \| `"unpropagated"`

##### directive?

> `readonly` `optional` **directive?**: `string`

##### port?

> `readonly` `optional` **port?**: `string`

##### reason?

> `readonly` `optional` **reason?**: `string`

***

### GraphRunOptions

#### Properties

##### budget

> `readonly` **budget**: [`Budget`](../index.md#budget-4)

The run's conserved pool.

##### perNode?

> `readonly` `optional` **perNode?**: [`Budget`](../index.md#budget-4)

Default per-instance reservation for nodes that declare no `budget` of their own.
 Required when any such node exists — the engine invents no split.

##### journal?

> `readonly` `optional` **journal?**: [`SpawnJournal`](../runtime.md#spawnjournal)

##### blobs?

> `readonly` `optional` **blobs?**: [`ResultBlobStore`](../runtime.md#resultblobstore)

##### prompts?

> `readonly` `optional` **prompts?**: [`PromptRegistry`](../runtime.md#promptregistry)

Resolves `delegates`/`analyzes` directives; required when any edge carries one.

##### finalizer?

> `readonly` `optional` **finalizer?**: [`FinalizerChoice`](#finalizerchoice)

How terminal settles reduce to `out`. Default `bestDelivered`.

##### signal?

> `readonly` `optional` **signal?**: `AbortSignal`

##### now?

> `readonly` `optional` **now?**: () => `number`

###### Returns

`number`

##### runId?

> `readonly` `optional` **runId?**: `string`

##### resume?

> `readonly` `optional` **resume?**: `boolean`

Continue an existing journaled run. An existing tree without this refuses, like the kernel.

##### waitForWakes?

> `readonly` `optional` **waitForWakes?**: `boolean`

Hold a fully-suspended run open for live `resume()` calls instead of returning
 `{ kind: 'suspended' }`. Offline callers leave this off and restart later (#976).

***

### GraphRunHandle

A live run: await `done`; deliver host wakes through `resume`/`expire` (#976).

#### Properties

##### done

> `readonly` **done**: `Promise`\<[`GraphRunResult`](#graphrunresult)\>

#### Methods

##### resume()

> **resume**(`token`, `payload`): `Promise`\<`void`\>

###### Parameters

###### token

`string`

###### payload

`unknown`

###### Returns

`Promise`\<`void`\>

##### expire()

> **expire**(`token`): `Promise`\<`void`\>

###### Parameters

###### token

`string`

###### Returns

`Promise`\<`void`\>

***

### SuspensionRequest

What a kind's executor returns to park its node until a host wakes it.

#### Properties

##### \_\_graphSuspension

> `readonly` **\_\_graphSuspension**: `true`

##### onExpire

> `readonly` **onExpire**: `"default"` \| `"fail"` \| `"wait"`

##### expiresInMs?

> `readonly` `optional` **expiresInMs?**: `number`

Milliseconds from the suspension's journaling instant; absent with `onExpire: 'wait'`.

##### default?

> `readonly` `optional` **default?**: `unknown`

## Type Aliases

### ConditionOp

> **ConditionOp** = *typeof* [`CONDITION_OPS`](#condition_ops)\[`number`\]

***

### Condition

> **Condition** = [`ConditionLeaf`](#conditionleaf) \| \{ `all`: `ReadonlyArray`\<[`Condition`](#condition)\>; \} \| \{ `any`: `ReadonlyArray`\<[`Condition`](#condition)\>; \} \| \{ `not`: [`Condition`](#condition); \}

***

### JoinRule

> **JoinRule** = *typeof* [`JOIN_RULES`](#join_rules)\[`number`\]

***

### GraphEdgeKind

> **GraphEdgeKind** = `"delegates"` \| `"analyzes"` \| `"data"`

***

### FoldEdgeState

> **FoldEdgeState** = `"pending"` \| `"satisfied"` \| `"dead"` \| `"failed"`

***

### FoldInstanceStatus

> **FoldInstanceStatus** = `"released"` \| `"live"` \| `"done"` \| `"down"` \| `"suspended"`

***

### JsonSchema

> **JsonSchema** = `Readonly`\<`Record`\<`string`, `unknown`\>\>

A JSON Schema document as the kernel already spells it: an opaque record, validated by the
 consumer's own validator, published verbatim.

***

### EffectName

> **EffectName** = `string`

***

### EffectContext

> **EffectContext**\<`Effects`\> = `Readonly`\<`{ [K in Effects[number]]: unknown }`\>

#### Type Parameters

##### Effects

`Effects` *extends* `ReadonlyArray`\<[`EffectName`](#effectname)\>

***

### OnCrash

> **OnCrash** = `"restart"` \| `"resume"`

What happens to a node that was IN FLIGHT when the process died. A settled node is never a
per-kind choice — it restores from its content-addressed `outRef` on replay. `'restart'` re-runs
from the journaled `inputRef`; `'resume'` is legal only for a kind whose executor can re-attach
to the live process (the bridge backend's session re-attachment is the existing instance).

***

### BudgetMode

> **BudgetMode** = `"metered"` \| `"exempt"`

Whether a kind's spend enters the conserved pool. `'metered'`: the executor reports `Spend` and
settling without one is an ENGINE ERROR — never "free". `'exempt'`: the whole reservation is
refunded on settle, keeping the node out of Σk by construction (the kernel's `budgetExempt`).

***

### AnyNodeKind

> **AnyNodeKind** = [`NodeKind`](#nodekind)\<`any`, `ReadonlyArray`\<[`EffectName`](#effectname)\>\>

A kind of ANY config shape — what a registry holds and what every engine signature accepts.

`NodeKind<Config>` puts `Config` in a parameter position (`run({ config })`), so it is
contravariant: an array of differently-configured kinds is not assignable to
`ReadonlyArray<NodeKind<unknown>>`, and every caller composing a heterogeneous kind set would
need a cast. That cost belongs here, once, not at each consumer: a registry is heterogeneous by
definition, and each kind validates its own config at its own boundary through
`validateConfig`, which is where the type is actually enforced.

***

### ScriptBody

> **ScriptBody** = (`inputs`, `signal`) => `Promise`\<`unknown`\> \| `unknown`

The caller code a `script` node runs. Receives the resolved inputs; returns the output.

#### Parameters

##### inputs

`Readonly`\<`Record`\<`string`, `unknown`\>\>

##### signal

`AbortSignal`

#### Returns

`Promise`\<`unknown`\> \| `unknown`

***

### Projection

> **Projection** = \{ `path`: `string`; \} \| \{ `pick`: `ReadonlyArray`\<`string`\>; \} \| \{ `map`: `string`; \} \| \{ `filter`: [`Condition`](#condition); \} \| \{ `first`: `true`; \} \| \{ `last`: `true`; \} \| \{ `count`: `true`; \}

***

### FinalizerChoice

> **FinalizerChoice** = `"bestDelivered"` \| `"collectDelivered"` \| [`SupervisorFinalizer`](../index.md#supervisorfinalizer)

***

### GraphRunReason

> **GraphRunReason** = `"all-children-down"` \| `"budget-exhausted"` \| `"aborted"` \| `"driver-failed"` \| `"cycle-budget-exceeded"` \| `"unreachable-terminal"`

Result vocabulary shared by the scheduler and the fold (agent-runtime#973, #974, #976).

***

### GraphRunResult

> **GraphRunResult** = \{ `kind`: `"winner"`; `out`: `unknown`; `terminals`: `ReadonlyArray`\<[`GraphNodeSettle`](#graphnodesettle)\>; `settles`: `ReadonlyArray`\<[`GraphNodeSettle`](#graphnodesettle)\>; `ledger`: `ReadonlyArray`\<[`GraphEdgeTraversal`](#graphedgetraversal)\>; \} \| \{ `kind`: `"no-winner"`; `reason`: [`GraphRunReason`](#graphrunreason); `error?`: \{ `name`: `string`; `message`: `string`; \}; `terminals`: `ReadonlyArray`\<[`GraphNodeSettle`](#graphnodesettle)\>; `settles`: `ReadonlyArray`\<[`GraphNodeSettle`](#graphnodesettle)\>; `ledger`: `ReadonlyArray`\<[`GraphEdgeTraversal`](#graphedgetraversal)\>; `unreachable`: `ReadonlyArray`\<`string`\>; \} \| \{ `kind`: `"suspended"`; `tokens`: `ReadonlyArray`\<`string`\>; `terminals`: `ReadonlyArray`\<[`GraphNodeSettle`](#graphnodesettle)\>; `settles`: `ReadonlyArray`\<[`GraphNodeSettle`](#graphnodesettle)\>; `ledger`: `ReadonlyArray`\<[`GraphEdgeTraversal`](#graphedgetraversal)\>; \}

#### Union Members

##### Type Literal

\{ `kind`: `"winner"`; `out`: `unknown`; `terminals`: `ReadonlyArray`\<[`GraphNodeSettle`](#graphnodesettle)\>; `settles`: `ReadonlyArray`\<[`GraphNodeSettle`](#graphnodesettle)\>; `ledger`: `ReadonlyArray`\<[`GraphEdgeTraversal`](#graphedgetraversal)\>; \}

***

##### Type Literal

\{ `kind`: `"no-winner"`; `reason`: [`GraphRunReason`](#graphrunreason); `error?`: \{ `name`: `string`; `message`: `string`; \}; `terminals`: `ReadonlyArray`\<[`GraphNodeSettle`](#graphnodesettle)\>; `settles`: `ReadonlyArray`\<[`GraphNodeSettle`](#graphnodesettle)\>; `ledger`: `ReadonlyArray`\<[`GraphEdgeTraversal`](#graphedgetraversal)\>; `unreachable`: `ReadonlyArray`\<`string`\>; \}

###### kind

> `readonly` **kind**: `"no-winner"`

###### reason

> `readonly` **reason**: [`GraphRunReason`](#graphrunreason)

###### error?

> `readonly` `optional` **error?**: `object`

###### error.name

> `readonly` **name**: `string`

###### error.message

> `readonly` **message**: `string`

###### terminals

> `readonly` **terminals**: `ReadonlyArray`\<[`GraphNodeSettle`](#graphnodesettle)\>

###### settles

> `readonly` **settles**: `ReadonlyArray`\<[`GraphNodeSettle`](#graphnodesettle)\>

###### ledger

> `readonly` **ledger**: `ReadonlyArray`\<[`GraphEdgeTraversal`](#graphedgetraversal)\>

###### unreachable

> `readonly` **unreachable**: `ReadonlyArray`\<`string`\>

Nodes provably stuck when the run ended: every upstream settled, no release possible.

***

##### Type Literal

\{ `kind`: `"suspended"`; `tokens`: `ReadonlyArray`\<`string`\>; `terminals`: `ReadonlyArray`\<[`GraphNodeSettle`](#graphnodesettle)\>; `settles`: `ReadonlyArray`\<[`GraphNodeSettle`](#graphnodesettle)\>; `ledger`: `ReadonlyArray`\<[`GraphEdgeTraversal`](#graphedgetraversal)\>; \}

###### kind

> `readonly` **kind**: `"suspended"`

Every live branch parked on a host wake: a legitimate terminal state for an offline run.
 Restart over the same journal and `resume(token, payload)` to continue (#976).

###### tokens

> `readonly` **tokens**: `ReadonlyArray`\<`string`\>

###### terminals

> `readonly` **terminals**: `ReadonlyArray`\<[`GraphNodeSettle`](#graphnodesettle)\>

###### settles

> `readonly` **settles**: `ReadonlyArray`\<[`GraphNodeSettle`](#graphnodesettle)\>

###### ledger

> `readonly` **ledger**: `ReadonlyArray`\<[`GraphEdgeTraversal`](#graphedgetraversal)\>

## Variables

### CONDITION\_OPS

> `const` **CONDITION\_OPS**: readonly \[`"eq"`, `"neq"`, `"gt"`, `"gte"`, `"lt"`, `"lte"`, `"in"`, `"contains"`, `"exists"`, `"truthy"`\]

The leaf comparison operators; `exists`/`truthy` are unary, the rest compare against `value`.

***

### JOIN\_RULES

> `const` **JOIN\_RULES**: readonly \[`"all"`, `"any"`, `"any_failed"`, `"all_done"`\]

Which gating-edge outcomes release a node (adopted from ADC, agent-runtime#968).

***

### DEFAULT\_MAX\_NODE\_VISITS

> `const` **DEFAULT\_MAX\_NODE\_VISITS**: `25` = `25`

ADC-compatible visit backstop: nothing may be ENTERED more than this many times.

***

### MAX\_MAX\_NODE\_VISITS

> `const` **MAX\_MAX\_NODE\_VISITS**: `100` = `100`

The hard ceiling an author's `maxVisits`/`maxNodeVisits` override may reach.

***

### RUN\_GRAPH\_ROOT\_KIND

> `const` **RUN\_GRAPH\_ROOT\_KIND**: `"supervisor/v1"` = `'supervisor/v1'`

The kind id the root node carries: a supervisor holding the whole `AgentGraph`.

***

### ENGINE\_WOKEN\_SEQ\_BASE

> `const` **ENGINE\_WOKEN\_SEQ\_BASE**: `10000000` = `10_000_000`

Engine-appended `woken` ordinals start here — far above any kernel cursor counter, so the two
 counters can advance independently without ever colliding.

## Functions

### assertAuthoredCode()

> **assertAuthoredCode**(`code`, `options?`): `void`

Refuse the obvious escapes in authored source. See the module doc for what this is NOT.

#### Parameters

##### code

`string`

##### options?

[`AuthoredCodeOptions`](#authoredcodeoptions) = `{}`

#### Returns

`void`

***

### admitPayload()

> **admitPayload**(`value`): `unknown`

Edge payload admission (agent-runtime#971): every value crossing an edge is JSON round-tripped,
`undefined` stripped to absence, and a non-representable value (a cycle, a BigInt, a function)
becomes a RECORD of that fact. This is the kernel's existing findings-guard rule, and it is what
makes `inputRef` stable and `onCrash: 'restart'` well defined — a degraded record beats a
vanished edge.

#### Parameters

##### value

`unknown`

#### Returns

`unknown`

***

### isEngineFired()

> **isEngineFired**(`edge`): `boolean`

`delegates` is the one MODEL-fired edge kind (agent-runtime#971): its payload is a directive and
 its target is spawned by the source supervisor through the coordination protocol, not released
 by the scheduler. `data` and `analyzes` are engine-fired.

#### Parameters

##### edge

[`CompiledEdge`](#compilededge)

#### Returns

`boolean`

***

### schemaAccepts()

> **schemaAccepts**(`source`, `target`, `depth?`): `boolean`

Bounded structural acceptance: does a value of `source`'s shape fit `target`? Schemas with no
`type` accept anything; object targets require their `required` properties to be present and
accepted when the source declares properties. Depth-bounded — this is a compile-time tripwire,
not a full JSON Schema validator.

#### Parameters

##### source

[`JsonSchema`](#jsonschema)

##### target

[`JsonSchema`](#jsonschema)

##### depth?

`number` = `0`

#### Returns

`boolean`

***

### compileGraph()

> **compileGraph**(`engine`, `spec`, `context?`): [`CompiledGraph`](#compiledgraph)

Lower an authored graph against an engine's kind registry into the schedulable form, refusing
every structural defect before any spend.

#### Parameters

##### engine

[`GraphEngine`](#graphengine)

##### spec

[`EngineGraphSpec`](#enginegraphspec)

##### context?

`string` = `'compileGraph'`

#### Returns

[`CompiledGraph`](#compiledgraph)

***

### validateCondition()

> **validateCondition**(`raw`, `context`): [`Condition`](#condition)

Validate shape, bounds, and per-leaf path/operator rules; returns the input for chaining.

#### Parameters

##### raw

`unknown`

##### context

`string`

#### Returns

[`Condition`](#condition)

***

### evaluateCondition()

> **evaluateCondition**(`condition`, `context`): `boolean`

Walk a validated condition over a context to a boolean. Never throws on data shape.

#### Parameters

##### condition

[`Condition`](#condition)

##### context

`unknown`

#### Returns

`boolean`

***

### createGraphEngine()

> **createGraphEngine**(`options`): [`GraphEngine`](#graphengine)

Build one engine: a kind registry seeded with the core kinds plus the host's, and the host's
effect values. Every kind is validated by name at construction, so a malformed host kind fails
here, never at its first node.

#### Parameters

##### options

[`GraphEngineOptions`](#graphengineoptions)

#### Returns

[`GraphEngine`](#graphengine)

***

### emptyFoldState()

> **emptyFoldState**(`compiled`): [`GraphFoldState`](#graphfoldstate)

The reducer's zero: every node unvisited, every edge pending, nothing suspended.

#### Parameters

##### compiled

[`CompiledGraph`](#compiledgraph)

#### Returns

[`GraphFoldState`](#graphfoldstate)

***

### applyGraphFoldEvent()

> **applyGraphFoldEvent**(`state`, `ev`, `compiled`): `void`

Apply ONE journal event. The live scheduler calls this right after each append; the restart path
calls it over the loaded journal. Unknown kernel events are ignored — the engine folds only what
it understands, exactly as the kernel's replay skips the engine's events.

#### Parameters

##### state

[`GraphFoldState`](#graphfoldstate)

##### ev

[`SpawnEvent`](../runtime.md#spawnevent)

##### compiled

[`CompiledGraph`](#compiledgraph)

#### Returns

`void`

***

### foldGraphJournal()

> **foldGraphJournal**(`events`, `compiled`): [`GraphFoldState`](#graphfoldstate)

Fold a loaded journal (append order) into scheduler state.

#### Parameters

##### events

readonly [`SpawnEvent`](../runtime.md#spawnevent)[]

##### compiled

[`CompiledGraph`](#compiledgraph)

#### Returns

[`GraphFoldState`](#graphfoldstate)

***

### decideJoin()

> **decideJoin**(`rule`, `gating`): [`JoinDecision`](#joindecision)

Decide whether a node's gating edges release it, and which of them the release consumes.

#### Parameters

##### rule

`"all"` \| `"any"` \| `"any_failed"` \| `"all_done"`

##### gating

readonly [`GatingEdge`](#gatingedge)[]

#### Returns

[`JoinDecision`](#joindecision)

***

### validateNodeKind()

> **validateNodeKind**(`kind`, `context?`): [`AnyNodeKind`](#anynodekind)

Validate a kind declaration at registration — so a malformed kind is refused by name once,
 not at the first node that uses it.

#### Parameters

##### kind

[`AnyNodeKind`](#anynodekind)

##### context?

`string` = `'registerNodeKind'`

#### Returns

[`AnyNodeKind`](#anynodekind)

***

### kindHandle()

> **kindHandle**(`kind`): [`RegistryHandle`](#registryhandle)

The handle a graph writes to name this kind.

#### Parameters

##### kind

`Pick`\<[`NodeKind`](#nodekind), `"id"` \| `"version"`\>

#### Returns

[`RegistryHandle`](#registryhandle)

***

### narrowEffects()

> **narrowEffects**\<`Effects`\>(`declared`, `provided`, `context`): [`EffectContext`](#effectcontext)\<`Effects`\>

Narrow a host's effect table to exactly what one kind declared. Anything the kind did not
declare is absent — `undefined` on read — so a kind cannot reach past its declaration, and the
engine can list a graph's required effects before spending a token.

#### Type Parameters

##### Effects

`Effects` *extends* readonly `string`[]

#### Parameters

##### declared

`Effects`

##### provided

`Readonly`\<`Record`\<`string`, `unknown`\>\>

##### context

`string`

#### Returns

[`EffectContext`](#effectcontext)\<`Effects`\>

***

### agentKind()

> **agentKind**(`defaults`): [`NodeKind`](#nodekind)\<[`AgentKindConfig`](#agentkindconfig)\>

One profile, one run: the kernel's leaf, exactly as `supervise()` derives it from `backend`.
The model cannot decide this — it is what gets run.

#### Parameters

##### defaults

###### backend?

[`ExecutorConfig`](../runtime.md#executorconfig)

###### deliverable?

[`DeliverableSpec`](../runtime.md#deliverablespec)\<`unknown`\>

#### Returns

[`NodeKind`](#nodekind)\<[`AgentKindConfig`](#agentkindconfig)\>

***

### supervisorKind()

> **supervisorKind**(`deps`): [`NodeKind`](#nodekind)\<[`SupervisorKindConfig`](#supervisorkindconfig)\>

The thing that DECIDES: a nested `supervisorAgent` with the coordination verbs. Its children
are its own tree — the graph sees one node in, one `Settled` out. A `subgraph` constrains what
it may spawn; without one it is free-form under `profileSecurity` and `allowedModels`.

#### Parameters

##### deps

###### blobs

[`ResultBlobStore`](../runtime.md#resultblobstore)

###### makeWorkerAgent

[`MakeWorkerAgent`](../runtime.md#makeworkeragent)

###### router?

[`RouterTransportConfig`](../runtime.md#routertransportconfig)

###### driveHarness?

[`DriveHarness`](../runtime.md#driveharness-2)

#### Returns

[`NodeKind`](#nodekind)\<[`SupervisorKindConfig`](#supervisorkindconfig)\>

***

### scriptKind()

> **scriptKind**(): [`NodeKind`](#nodekind)\<[`ScriptKindConfig`](#scriptkindconfig)\>

Caller code as a node. The one kind with no kernel primitive behind it: the kernel has no
"data→data with no execution" concept (agent-runtime#970 fact-finding), so this is new. It is
still a leaf `Agent` carrying an `Executor`, so the journal, the gate and the pool treat it like
any other node.

#### Returns

[`NodeKind`](#nodekind)\<[`ScriptKindConfig`](#scriptkindconfig)\>

***

### subgraphKind()

> **subgraphKind**(): [`NodeKind`](#nodekind)\<[`SubgraphKindConfig`](#subgraphkindconfig)\>

A node carrying its own graph: it runs as a full engine run on the host's kinds and effects.

#### Returns

[`NodeKind`](#nodekind)\<[`SubgraphKindConfig`](#subgraphkindconfig)\>

***

### createEdgeLedger()

> **createEdgeLedger**(`args`): [`EdgeLedger`](#edgeledger)

Open a ledger for one run; its ordinals continue past whatever a prior process recorded.

#### Parameters

##### args

###### journal

[`SpawnJournal`](../runtime.md#spawnjournal)

###### runId

`string`

###### now

() => `number`

###### startSeq

`number`

#### Returns

[`EdgeLedger`](#edgeledger)

***

### graphFromRunGraph()

> **graphFromRunGraph**(`graph`, `options`): [`EngineGraphSpec`](#enginegraphspec)

Compile an `AgentGraph` into the engine graph that describes it. Pure: nothing runs, nothing is
registered, no executor is built. A `delegates` edge is MODEL-fired (#971) — its target is
spawned by the supervisor through the coordination protocol — so every worker node is marked
`entry: false`, which is exactly what the engine's scheduler would honour if this graph were
handed to it.

#### Parameters

##### graph

[`AgentGraph`](../runtime.md#agentgraph)

##### options

[`RunGraphOptions`](../runtime.md#rungraphoptions)

#### Returns

[`EngineGraphSpec`](#enginegraphspec)

***

### validateProjection()

> **validateProjection**(`raw`, `context`): [`Projection`](#projection-1)

Validate a projection: exactly one known operator, its argument well-formed.

#### Parameters

##### raw

`unknown`

##### context

`string`

#### Returns

[`Projection`](#projection-1)

***

### applyProjection()

> **applyProjection**(`value`, `projection`, `context`): `unknown`

Apply a validated projection to an admitted payload. Collection operators over a non-array
refuse by name — a shape the author did not expect is a graph defect, not an empty result.

#### Parameters

##### value

`unknown`

##### projection

[`Projection`](#projection-1)

##### context

`string`

#### Returns

`unknown`

***

### formatRegistryHandle()

> **formatRegistryHandle**(`handle`): `string`

`<id>/v<n>` — the only spelling a handle has on the wire, in a journal, or in an error.

#### Parameters

##### handle

[`RegistryHandle`](#registryhandle)

#### Returns

`string`

***

### parseRegistryHandle()

> **parseRegistryHandle**(`text`, `context`): [`RegistryHandle`](#registryhandle)

Parse the wire spelling back. Refuses anything that is not exactly `<id>/v<n>`.

#### Parameters

##### text

`string`

##### context

`string`

#### Returns

[`RegistryHandle`](#registryhandle)

***

### createRegistry()

> **createRegistry**\<`T`\>(`label`, `seed?`): [`Registry`](#registry)\<`T`\>

Create a registry. Per-instance by construction: two engines in one process may hold
different kind sets, a test is hermetic, and a run can print its own table. There is
deliberately no module-level singleton — `builtinShapes` was the one mutable global in the
kernel and it had zero tests.

#### Type Parameters

##### T

`T` *extends* [`Registered`](#registered)

#### Parameters

##### label

`string`

##### seed?

`Iterable`\<`T`\> = `[]`

#### Returns

[`Registry`](#registry)\<`T`\>

***

### materializeSettles()

> **materializeSettles**(`compiled`, `state`, `blobs`, `outCache`): `Promise`\<[`GraphNodeSettle`](#graphnodesettle)[]\>

Every node settlement with its output rehydrated and its completion check applied.

#### Parameters

##### compiled

[`CompiledGraph`](#compiledgraph)

##### state

[`GraphFoldState`](#graphfoldstate)

##### blobs

[`ResultBlobStore`](../runtime.md#resultblobstore)

##### outCache

`ReadonlyMap`\<`string`, `unknown`\>

#### Returns

`Promise`\<[`GraphNodeSettle`](#graphnodesettle)[]\>

***

### assembleGraphResult()

> **assembleGraphResult**(`args`): `Promise`\<[`GraphRunResult`](#graphrunresult)\>

Turn a finished run into its result: rehydrate, reduce the terminals, classify a no-winner.

#### Parameters

##### args

###### compiled

[`CompiledGraph`](#compiledgraph)

###### state

[`GraphFoldState`](#graphfoldstate)

###### blobs

[`ResultBlobStore`](../runtime.md#resultblobstore)

###### scope

[`Scope`](../index.md#scope)\<`unknown`\>

###### outCache

`ReadonlyMap`\<`string`, `unknown`\>

###### ledger

readonly [`GraphEdgeTraversal`](#graphedgetraversal)[]

###### finalizer?

[`FinalizerChoice`](#finalizerchoice)

###### failure?

\{ `reason`: [`GraphRunReason`](#graphrunreason); `error?`: \{ `name`: `string`; `message`: `string`; \}; \}

###### failure.reason

[`GraphRunReason`](#graphrunreason)

###### failure.error?

\{ `name`: `string`; `message`: `string`; \}

###### failure.error.name

`string`

###### failure.error.message

`string`

###### aborted

`boolean`

#### Returns

`Promise`\<[`GraphRunResult`](#graphrunresult)\>

***

### openGraphRun()

> **openGraphRun**(`args`): `Promise`\<[`GraphRunContext`](#graphruncontext)\>

Begin or resume a run's journaled tree, pool, scope and folded state.

#### Parameters

##### args

###### compiled

[`CompiledGraph`](#compiledgraph)

###### runId

`string`

###### budget

[`Budget`](../index.md#budget-4)

###### journal?

[`SpawnJournal`](../runtime.md#spawnjournal)

###### blobs?

[`ResultBlobStore`](../runtime.md#resultblobstore)

###### now

() => `number`

###### resume?

`boolean`

###### signal?

`AbortSignal`

###### onAbort

(`listener`) => `void`

#### Returns

`Promise`\<[`GraphRunContext`](#graphruncontext)\>

***

### runEngineGraph()

> **runEngineGraph**(`engine`, `spec`, `task`, `options`): `Promise`\<[`GraphRunResult`](#graphrunresult)\>

Run a graph to its result: `createGraphRun` awaited — the one-call form for a run that needs no
 live host wakes.

#### Parameters

##### engine

[`GraphEngine`](#graphengine)

##### spec

[`CompiledGraph`](#compiledgraph) \| [`EngineGraphSpec`](#enginegraphspec)

##### task

`string`

##### options

[`GraphRunOptions`](#graphrunoptions)

#### Returns

`Promise`\<[`GraphRunResult`](#graphrunresult)\>

***

### createGraphRun()

> **createGraphRun**(`engine`, `spec`, `task`, `options`): [`GraphRunHandle`](#graphrunhandle)

Start (or resume) a graph run and return its handle: await `done` for the result; deliver host
wakes through `resume`/`expire` while it runs (#976).

#### Parameters

##### engine

[`GraphEngine`](#graphengine)

##### spec

[`CompiledGraph`](#compiledgraph) \| [`EngineGraphSpec`](#enginegraphspec)

##### task

`string`

##### options

[`GraphRunOptions`](#graphrunoptions)

#### Returns

[`GraphRunHandle`](#graphrunhandle)

***

### suspended()

> **suspended**(`options?`): [`SuspensionRequest`](#suspensionrequest)

Build a suspension request. `wait` never expires; `fail` settles the node down at its deadline;
 `default` resolves with the given payload.

#### Parameters

##### options?

###### onExpire?

`"default"` \| `"fail"` \| `"wait"`

###### expiresInMs?

`number`

###### default?

`unknown`

#### Returns

[`SuspensionRequest`](#suspensionrequest)

***

### isSuspensionRequest()

> **isSuspensionRequest**(`value`): `value is SuspensionRequest`

Whether a node's output is a park request rather than its result.

#### Parameters

##### value

`unknown`

#### Returns

`value is SuspensionRequest`

***

### mintSuspensionToken()

> **mintSuspensionToken**(`runId`, `instance`): `string`

Content-addressed over the run identity, so a restart recomputes it and needs no token table.

#### Parameters

##### runId

`string`

##### instance

`string`

#### Returns

`string`

***

### suspensionNodeId()

> **suspensionNodeId**(`token`): `string`

The journal id one suspension's `waiting`/`woken` pair shares.

#### Parameters

##### token

`string`

#### Returns

`string`

***

### tokenFromSuspensionNodeId()

> **tokenFromSuspensionNodeId**(`id`): `string` \| `undefined`

The token inside a suspension node id, or `undefined` for any other id.

#### Parameters

##### id

`string`

#### Returns

`string` \| `undefined`