@tangle-network/agent-runtime 0.164.0 → 0.166.0

package/dist/graph.d.ts

@@ -1,6 +1,6 @@
-import { $l as MakeWorkerAgent, If as DeliverableSpec, an as PromptRegistry, bo as SupervisorAgentDeps, in as PromptHandle, mu as WorkerSpawnContext, os as SupervisorFinalizer } from "./index-BP11HXYi.js";
-import { H as SpawnJournal, K as Spend, i as Budget, j as ResultBlobStore, t as Agent } from "./types-C2l1jaos.js";
-import { o as ExecutorConfig } from "./runtime-D44YrQ4t.js";
+import { $l as MakeWorkerAgent, Gt as AgentGraph, If as DeliverableSpec, Qt as RunGraphOptions, Zt as GraphResult, an as PromptRegistry, bo as SupervisorAgentDeps, in as PromptHandle, mu as WorkerSpawnContext, os as SupervisorFinalizer } from "./index-BGQtpQuJ.js";
+import { H as SpawnJournal, K as Spend, V as SpawnEvent, i as Budget, j as ResultBlobStore, t as Agent, z as Scope } from "./types-DjVO-p7R.js";
+import { _t as ToolLoopChat, o as ExecutorConfig } from "./runtime-B0HZbuEv.js";
 import { AgentProfile } from "@tangle-network/agent-interface";
 //#region src/runtime/graph/condition.d.ts
 /** The leaf comparison operators; `exists`/`truthy` are unary, the rest compare against `value`. */
@@ -225,6 +225,10 @@ interface EngineGraphNode {
   readonly deliverable?: DeliverableSpec<unknown>;
   /** Force-mark a terminal. Absent, a node with no outbound gating edge is terminal. */
   readonly terminal?: 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. */
+  readonly entry?: boolean;
   /** Profile fields merged over the engine-authored `{ name: id }` for this node's spawns. */
   readonly profile?: Readonly<Partial<AgentProfile>>;
   /** Per-instance reservation for this node's spawns; falls back to the run's `perNode`. */
@@ -246,7 +250,7 @@ interface EngineGraphEdge {
   readonly guard?: Condition;
   /** `data` edges only: ONE pure reshape of the admitted payload. */
   readonly projection?: Projection;
-  /** Refuses the traversal past this many firings (ledgered `unpropagated`). */
+  /** Refuses the traversal past this many firings (ledgered `unpropagated`); `0` closes the edge from the start. */
   readonly maxTraversals?: number;
   /** `delegates`/`analyzes`: the versioned directive appended to the target's task. */
   readonly directive?: PromptHandle;
@@ -294,6 +298,10 @@ interface CompiledEdge {
   readonly fromPort: string;
   readonly toPort: string;
 }
+/** `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. */
+declare function isEngineFired(edge: CompiledEdge): boolean;
 interface CompiledNode {
   readonly id: string;
   readonly kind: NodeKind;
@@ -307,6 +315,8 @@ interface CompiledNode {
   readonly deliverable?: DeliverableSpec<unknown>;
   readonly inbound: ReadonlyArray<CompiledEdge>;
   readonly outbound: ReadonlyArray<CompiledEdge>;
+  /** Spawned by a supervisor through a `delegates` edge, never entered by the scheduler. */
+  readonly modelFired: boolean;
   readonly spec: EngineGraphSpec['nodes'][number];
 }
 interface CompiledGraph {
@@ -330,6 +340,137 @@ declare function schemaAccepts(source: JsonSchema, target: JsonSchema, depth?: n
  */
 declare function compileGraph(engine: GraphEngine, spec: EngineGraphSpec, context?: string): CompiledGraph;
 //#endregion
+//#region src/runtime/graph/scheduler-types.d.ts
+/** Result vocabulary shared by the scheduler and the fold (agent-runtime#973, #974, #976). */
+type GraphRunReason = 'all-children-down' | 'budget-exhausted' | 'aborted' | 'driver-failed' | 'cycle-budget-exceeded' | 'unreachable-terminal';
+/** One node settlement as the graph result reports it. */
+interface GraphNodeSettle {
+  readonly node: string;
+  readonly visit: number;
+  readonly status: 'done' | 'down';
+  /** The node's completion check verdict; `undefined` when the node declares no check. */
+  readonly valid?: boolean;
+  readonly out?: unknown;
+  readonly outRef?: string;
+  readonly reason?: string;
+}
+/** One ledgered edge firing (or refusal) — the run's observable data flow. */
+interface GraphEdgeTraversal {
+  readonly edge: string;
+  readonly kind: 'delegates' | 'analyzes' | 'data';
+  readonly from: string;
+  readonly to: string;
+  readonly traversal: number;
+  readonly outcome: 'delivered' | 'empty' | 'unpropagated';
+  readonly directive?: string;
+  readonly port?: string;
+  readonly reason?: string;
+}
+type GraphRunResult = {
+  readonly kind: 'winner';
+  readonly out: unknown;
+  readonly terminals: ReadonlyArray<GraphNodeSettle>;
+  readonly settles: ReadonlyArray<GraphNodeSettle>;
+  readonly ledger: ReadonlyArray<GraphEdgeTraversal>;
+} | {
+  readonly kind: 'no-winner';
+  readonly reason: GraphRunReason;
+  readonly error?: {
+    readonly name: string;
+    readonly message: string;
+  };
+  readonly terminals: ReadonlyArray<GraphNodeSettle>;
+  readonly settles: ReadonlyArray<GraphNodeSettle>;
+  readonly ledger: ReadonlyArray<GraphEdgeTraversal>;
+  /** Nodes provably stuck when the run ended: every upstream settled, no release possible. */
+  readonly unreachable: ReadonlyArray<string>;
+} | {
+  /** 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). */
+  readonly kind: 'suspended';
+  readonly tokens: ReadonlyArray<string>;
+  readonly terminals: ReadonlyArray<GraphNodeSettle>;
+  readonly settles: ReadonlyArray<GraphNodeSettle>;
+  readonly ledger: ReadonlyArray<GraphEdgeTraversal>;
+};
+//#endregion
+//#region src/runtime/graph/fold.d.ts
+type FoldEdgeState = 'pending' | 'satisfied' | 'dead' | 'failed';
+interface FoldEdge {
+  state: FoldEdgeState;
+  /** 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). */
+  consumedOnce: boolean;
+  /** Delivered consumptions — what the per-edge cap counts. */
+  traversals: 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. */
+  judgedSourceSettles: number;
+  /** The admitted source payload this state reflects (the source settle's outRef). */
+  payloadRef?: string;
+  capped: boolean;
+}
+type FoldInstanceStatus = 'released' | 'live' | 'done' | 'down' | 'suspended';
+interface FoldInstance {
+  readonly node: string;
+  readonly instance: string;
+  readonly visit: number;
+  inputRef?: string;
+  status: FoldInstanceStatus;
+  settle?: GraphNodeSettle;
+}
+interface FoldSuspension {
+  readonly token: string;
+  readonly node: string;
+  readonly instance: string;
+  readonly onExpire: 'wait' | 'fail' | 'default';
+  readonly expiresAtMs?: number;
+  readonly defaultRef?: string;
+  status: 'pending' | 'woken' | 'expired';
+}
+interface FoldNode {
+  visits: number;
+  blocked: boolean;
+  settles: GraphNodeSettle[];
+}
+interface GraphFoldState {
+  readonly nodes: Map<string, FoldNode>;
+  readonly edges: Map<string, FoldEdge>;
+  /** Every node instance the journal knows, keyed by `<node>#<visit>`. */
+  readonly instances: Map<string, FoldInstance>;
+  /** Kernel node id → engine instance label, from `spawned`. */
+  readonly spawnedIds: Map<string, string>;
+  readonly suspensions: Map<string, FoldSuspension>;
+  readonly exhaustedEdges: Set<string>;
+}
+/** The reducer's zero: every node unvisited, every edge pending, nothing suspended. */
+declare function emptyFoldState(compiled: CompiledGraph): GraphFoldState;
+/**
+ * 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.
+ */
+declare function applyGraphFoldEvent(state: GraphFoldState, ev: SpawnEvent, compiled: CompiledGraph): void;
+/** Fold a loaded journal (append order) into scheduler state. */
+declare function foldGraphJournal(events: ReadonlyArray<SpawnEvent>, compiled: CompiledGraph): GraphFoldState;
+//#endregion
+//#region src/runtime/graph/join.d.ts
+interface GatingEdge {
+  readonly edge: CompiledEdge;
+  readonly folded: FoldEdge | undefined;
+}
+interface JoinDecision {
+  /** Whether the node releases now. */
+  readonly release: boolean;
+  /** The edges whose outcomes produced this release — the ones a traversal cap judges. */
+  readonly consuming: ReadonlyArray<GatingEdge>;
+  /** Whether the node can never release again on this wave (recorded like skipped-by-guard). */
+  readonly blocked: boolean;
+}
+/** Decide whether a node's gating edges release it, and which of them the release consumes. */
+declare function decideJoin(rule: JoinRule, gating: ReadonlyArray<GatingEdge>): JoinDecision;
+//#endregion
 //#region src/runtime/graph/kinds.d.ts
 interface AgentKindConfig {
   /** Where this node's profile runs. Omit to inherit the engine's default backend. */
@@ -393,50 +534,165 @@ declare function subgraphKind(): NodeKind<{
   readonly graph: unknown;
 }>;
 //#endregion
-//#region src/runtime/graph/scheduler.d.ts
-type GraphRunReason = 'all-children-down' | 'budget-exhausted' | 'aborted' | 'driver-failed' | 'cycle-budget-exceeded' | 'unreachable-terminal';
-/** One node settlement as the graph result reports it. */
-interface GraphNodeSettle {
-  readonly node: string;
-  readonly visit: number;
-  readonly status: 'done' | 'down';
-  /** The node's completion check verdict; `undefined` when the node declares no check. */
-  readonly valid?: boolean;
-  readonly out?: unknown;
-  readonly outRef?: string;
-  readonly reason?: string;
+//#region src/runtime/graph/ledger.d.ts
+interface EdgeLedger {
+  readonly entries: ReadonlyArray<GraphEdgeTraversal>;
+  record(edge: CompiledEdge, traversal: number, outcome: GraphEdgeTraversal['outcome'], reason?: string): Promise<void>;
 }
-/** One ledgered edge firing (or refusal) — the run's observable data flow. */
-interface GraphEdgeTraversal {
-  readonly edge: string;
-  readonly kind: 'delegates' | 'analyzes' | 'data';
-  readonly from: string;
-  readonly to: string;
-  readonly traversal: number;
-  readonly outcome: 'delivered' | 'empty' | 'unpropagated';
-  readonly directive?: string;
-  readonly port?: string;
-  readonly reason?: string;
+/** Open a ledger for one run; its ordinals continue past whatever a prior process recorded. */
+declare function createEdgeLedger(args: {
+  readonly journal: SpawnJournal;
+  readonly runId: string;
+  readonly now: () => number;
+  readonly startSeq: number;
+}): EdgeLedger;
+//#endregion
+//#region src/runtime/graph/preset-run-graph.d.ts
+/** The preset's root kind: one node whose body is the graph's supervise run. */
+declare const RUN_GRAPH_KIND = "run-graph.supervisor";
+/** The graph supervise run, injected rather than imported: the preset describes the graph, and
+ *  `runGraph` supplies the body, so this module never imports its caller at runtime. */
+type RunGraphBody = (graph: AgentGraph, options: RunGraphOptions, brain?: ToolLoopChat) => Promise<GraphResult>;
+/** Where the run body's raw failure is kept. A node's output crosses the edge-admission boundary
+ *  (JSON round-trip), which would reduce an `Error` to a plain object and a typed
+ *  `GraphEdgeCapError` to an untyped one. The error therefore travels beside the output, by
+ *  reference, and the preset rethrows the ORIGINAL object. */
+interface RunGraphCapture {
+  error?: unknown;
 }
-type GraphRunResult = {
-  readonly kind: 'winner';
-  readonly out: unknown;
-  readonly terminals: ReadonlyArray<GraphNodeSettle>;
-  readonly settles: ReadonlyArray<GraphNodeSettle>;
+/** What the root node carries: the authored graph, the caller's options, and the run body. */
+interface RunGraphNodeConfig {
+  readonly graph: AgentGraph;
+  readonly options: RunGraphOptions;
+  readonly run: RunGraphBody;
+  readonly capture: RunGraphCapture;
+  readonly brain?: ToolLoopChat;
+}
+/** The run's outcome as the root node's output: never a throw, so a typed failure (an exhausted
+ *  delegates cap) reaches the caller as the exact error object rather than a settle reason. */
+type RunGraphNodeOut = {
+  readonly ok: true;
+  readonly result: GraphResult;
+} |
+/** The message only; the raw error rides in {@link RunGraphCapture}. */
+{
+  readonly ok: false;
+  readonly error: string;
+};
+/**
+ * The node kind behind the preset. Its executor runs the graph and reports the run's own measured
+ * spend, so the engine pool debits what the graph actually used, never a second copy of it.
+ */
+declare function runGraphKind(): NodeKind<RunGraphNodeConfig>;
+/** An engine with the preset kind registered beside the core `agent` kind the workers use. */
+declare function runGraphEngine(): GraphEngine;
+/**
+ * Compile an `AgentGraph` into the engine graph that represents it: the supervisor root, one
+ * pinned `agent` node per worker, and every authored edge. Pure — nothing runs, so a caller can
+ * inspect, diff, or extend the result before handing it to the engine.
+ */
+declare function graphFromRunGraph(graph: AgentGraph, options: RunGraphOptions, run: RunGraphBody, capture?: RunGraphCapture, brain?: ToolLoopChat): EngineGraphSpec;
+/**
+ * Run an `AgentGraph` through the engine: compile it with {@link graphFromRunGraph}, schedule it,
+ * and answer the caller in `runGraph`'s own vocabulary. A typed failure the graph threw — an
+ * exhausted delegates cap — is rethrown as the exact error object it was, never flattened into a
+ * settle reason.
+ */
+declare function runGraphThroughEngine(graph: AgentGraph, options: RunGraphOptions, run: RunGraphBody, brain?: ToolLoopChat): Promise<GraphResult>;
+//#endregion
+//#region src/runtime/graph/result.d.ts
+type FinalizerChoice = 'bestDelivered' | 'collectDelivered' | SupervisorFinalizer;
+/** Every node settlement with its output rehydrated and its completion check applied. */
+declare function materializeSettles(compiled: CompiledGraph, state: GraphFoldState, blobs: ResultBlobStore, outCache: ReadonlyMap<string, unknown>): Promise<GraphNodeSettle[]>;
+/** Turn a finished run into its result: rehydrate, reduce the terminals, classify a no-winner. */
+declare function assembleGraphResult(args: {
+  readonly compiled: CompiledGraph;
+  readonly state: GraphFoldState;
+  readonly blobs: ResultBlobStore;
+  readonly scope: Scope<unknown>;
+  readonly outCache: ReadonlyMap<string, unknown>;
   readonly ledger: ReadonlyArray<GraphEdgeTraversal>;
-} | {
-  readonly kind: 'no-winner';
-  readonly reason: GraphRunReason;
-  readonly error?: {
-    readonly name: string;
-    readonly message: string;
+  readonly finalizer?: FinalizerChoice;
+  readonly failure?: {
+    readonly reason: GraphRunReason;
+    readonly error?: {
+      name: string;
+      message: string;
+    };
   };
-  readonly terminals: ReadonlyArray<GraphNodeSettle>;
-  readonly settles: ReadonlyArray<GraphNodeSettle>;
-  readonly ledger: ReadonlyArray<GraphEdgeTraversal>;
-  /** Nodes provably stuck when the run ended: every upstream settled, no release possible. */
-  readonly unreachable: ReadonlyArray<string>;
-};
+  readonly aborted: boolean;
+}): Promise<GraphRunResult>;
+//#endregion
+//#region src/runtime/graph/run-context.d.ts
+/** Engine-appended `woken` ordinals start here — far above any kernel cursor counter, so the two
+ *  counters can advance independently without ever colliding. */
+declare const ENGINE_WOKEN_SEQ_BASE = 10000000;
+interface GraphRunContext {
+  readonly runId: string;
+  readonly journal: SpawnJournal;
+  readonly blobs: ResultBlobStore;
+  readonly scope: Scope<unknown>;
+  readonly abort: AbortController;
+  readonly state: GraphFoldState;
+  readonly resuming: boolean;
+  /** Journal events present before this process started; empty on a fresh run. */
+  readonly prior: ReadonlyArray<SpawnEvent>;
+  /** Next engine fold-event ordinal, and next engine `woken` ordinal. */
+  readonly engineSeq: number;
+  readonly engineWokenSeq: number;
+  /** Ledger ordinals already used by a prior process. */
+  readonly ledgerSeq: number;
+}
+/** Begin or resume a run's journaled tree, pool, scope and folded state. */
+declare function openGraphRun(args: {
+  readonly compiled: CompiledGraph;
+  readonly runId: string;
+  readonly budget: Budget;
+  readonly journal?: SpawnJournal;
+  readonly blobs?: ResultBlobStore;
+  readonly now: () => number;
+  readonly resume?: boolean;
+  readonly signal?: AbortSignal;
+  readonly onAbort: (listener: () => void) => void;
+}): Promise<GraphRunContext>;
+//#endregion
+//#region src/runtime/graph/admit.d.ts
+/**
+ * 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.
+ */
+declare function admitPayload(value: unknown): unknown;
+//#endregion
+//#region src/runtime/graph/suspension.d.ts
+declare const SUSPEND_MARK = "__graphSuspension";
+/** What a kind's executor returns to park its node until a host wakes it. */
+interface SuspensionRequest {
+  readonly [SUSPEND_MARK]: true;
+  readonly onExpire: 'wait' | 'fail' | 'default';
+  /** Milliseconds from the suspension's journaling instant; absent with `onExpire: 'wait'`. */
+  readonly expiresInMs?: number;
+  readonly default?: unknown;
+}
+/** Build a suspension request. `wait` never expires; `fail` settles the node down at its deadline;
+ *  `default` resolves with the given payload. */
+declare function suspended(options?: {
+  readonly onExpire?: 'wait' | 'fail' | 'default';
+  readonly expiresInMs?: number;
+  readonly default?: unknown;
+}): SuspensionRequest;
+/** Whether a node's output is a park request rather than its result. */
+declare function isSuspensionRequest(value: unknown): value is SuspensionRequest;
+/** Content-addressed over the run identity, so a restart recomputes it and needs no token table. */
+declare function mintSuspensionToken(runId: string, instance: string): string;
+/** The journal id one suspension's `waiting`/`woken` pair shares. */
+declare function suspensionNodeId(token: string): string;
+/** The token inside a suspension node id, or `undefined` for any other id. */
+declare function tokenFromSuspensionNodeId(id: string): string | undefined;
+//#endregion
+//#region src/runtime/graph/scheduler.d.ts
 interface GraphRunOptions {
   /** The run's conserved pool. */
   readonly budget: Budget;
@@ -448,20 +704,30 @@ interface GraphRunOptions {
   /** Resolves `delegates`/`analyzes` directives; required when any edge carries one. */
   readonly prompts?: PromptRegistry;
   /** How terminal settles reduce to `out`. Default `bestDelivered`. */
-  readonly finalizer?: 'bestDelivered' | 'collectDelivered' | SupervisorFinalizer;
+  readonly finalizer?: FinalizerChoice;
   readonly signal?: AbortSignal;
   readonly now?: () => number;
   readonly runId?: string;
+  /** Continue an existing journaled run. An existing tree without this refuses, like the kernel. */
+  readonly resume?: 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). */
+  readonly waitForWakes?: boolean;
 }
-/** Admission for every value crossing an edge (#971): JSON round-trip, `undefined` stripped, a
- *  non-representable value becomes a RECORD of that fact — a degraded record beats a vanished
- *  edge. */
-declare function admitPayload(value: unknown): unknown;
+/** A live run: await `done`; deliver host wakes through `resume`/`expire` (#976). */
+interface GraphRunHandle {
+  readonly done: Promise<GraphRunResult>;
+  resume(token: string, payload: unknown): Promise<void>;
+  expire(token: string): Promise<void>;
+}
+/** Run a graph to its result: `createGraphRun` awaited — the one-call form for a run that needs no
+ *  live host wakes. */
+declare function runEngineGraph(engine: GraphEngine, spec: EngineGraphSpec | CompiledGraph, task: string, options: GraphRunOptions): Promise<GraphRunResult>;
 /**
- * Run a graph: host every node instance on one kernel `Scope`, resolve joins over guarded edges,
- * enforce the traversal and visit caps, and reduce the terminal settlements through the finalizer.
+ * 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).
  */
-declare function runEngineGraph(engine: GraphEngine, spec: EngineGraphSpec | CompiledGraph, task: string, options: GraphRunOptions): Promise<GraphRunResult>;
+declare function createGraphRun(engine: GraphEngine, spec: EngineGraphSpec | CompiledGraph, task: string, options: GraphRunOptions): GraphRunHandle;
 //#endregion
-export { type AgentKindConfig, type BudgetMode, CONDITION_OPS, type CompiledEdge, type CompiledGraph, type CompiledNode, type Condition, type ConditionLeaf, type ConditionOp, DEFAULT_MAX_NODE_VISITS, type EffectContext, type EffectName, type EngineGraphEdge, type EngineGraphNode, type EngineGraphSpec, type GraphEdgeKind, type GraphEdgeTraversal, type GraphEngine, type GraphEngineOptions, type GraphNodeSettle, type GraphRunOptions, type GraphRunReason, type GraphRunResult, JOIN_RULES, type JoinRule, type JsonSchema, MAX_MAX_NODE_VISITS, type NodeFlags, type NodeKind, type OnCrash, type PortSpec, type Projection, type Registered, type Registry, type RegistryHandle, type ScriptBody, type ScriptKindConfig, type SupervisorKindConfig, admitPayload, agentKind, applyProjection, compileGraph, createGraphEngine, createRegistry, evaluateCondition, formatRegistryHandle, kindHandle, narrowEffects, parseRegistryHandle, runEngineGraph, schemaAccepts, scriptKind, subgraphKind, supervisorKind, validateCondition, validateNodeKind, validateProjection };
+export { type AgentKindConfig, type BudgetMode, CONDITION_OPS, type CompiledEdge, type CompiledGraph, type CompiledNode, type Condition, type ConditionLeaf, type ConditionOp, DEFAULT_MAX_NODE_VISITS, ENGINE_WOKEN_SEQ_BASE, type EdgeLedger, type EffectContext, type EffectName, type EngineGraphEdge, type EngineGraphNode, type EngineGraphSpec, type FinalizerChoice, type FoldEdge, type FoldEdgeState, type FoldInstance, type FoldInstanceStatus, type FoldNode, type FoldSuspension, type GatingEdge, type GraphEdgeKind, type GraphEdgeTraversal, type GraphEngine, type GraphEngineOptions, type GraphFoldState, type GraphNodeSettle, type GraphRunContext, type GraphRunHandle, type GraphRunOptions, type GraphRunReason, type GraphRunResult, JOIN_RULES, type JoinDecision, type JoinRule, type JsonSchema, MAX_MAX_NODE_VISITS, type NodeFlags, type NodeKind, type OnCrash, type PortSpec, type Projection, RUN_GRAPH_KIND, type Registered, type Registry, type RegistryHandle, type RunGraphBody, type RunGraphCapture, type RunGraphNodeConfig, type RunGraphNodeOut, type ScriptBody, type ScriptKindConfig, type SupervisorKindConfig, type SuspensionRequest, admitPayload, agentKind, applyGraphFoldEvent, applyProjection, assembleGraphResult, compileGraph, createEdgeLedger, createGraphEngine, createGraphRun, createRegistry, decideJoin, emptyFoldState, evaluateCondition, foldGraphJournal, formatRegistryHandle, graphFromRunGraph, isEngineFired, isSuspensionRequest, kindHandle, materializeSettles, mintSuspensionToken, narrowEffects, openGraphRun, parseRegistryHandle, runEngineGraph, runGraphEngine, runGraphKind, runGraphThroughEngine, schemaAccepts, scriptKind, subgraphKind, supervisorKind, suspended, suspensionNodeId, tokenFromSuspensionNodeId, validateCondition, validateNodeKind, validateProjection };
 //# sourceMappingURL=graph.d.ts.map