@tangle-network/agent-runtime 0.197.1 → 0.198.2

package/dist/graph.d.ts

@@ -1,753 +0,0 @@
-import { Fn as PromptHandle, In as PromptRegistry, Sd as WorkerSpawnContext, Sn as AgentGraph, Ys as SupervisorFinalizer, ad as MakeWorkerAgent, kn as RunGraphOptions, ls as SupervisorAgentDeps, qp as DeliverableSpec } from "./index-CYOJsxSg.js";
-import { B as Scope, H as SpawnEvent, M as ResultBlobStore, U as SpawnJournal, i as Budget, q as Spend, t as Agent } from "./types-DFLZMaeh.js";
-import { c as ExecutorConfig } from "./runtime-0xNaV6TJ.js";
-import { AgentProfile } from "@tangle-network/agent-interface";
-//#region src/runtime/authored-code.d.ts
-interface AuthoredCodeOptions {
-  /** 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. */
-  readonly allowedImports?: ReadonlyArray<string>;
-  /** Names the refusal, e.g. `code mode (node-1)`. Defaults to `authored code`. */
-  readonly context?: string;
-}
-/** Refuse the obvious escapes in authored source. See the module doc for what this is NOT. */
-declare function assertAuthoredCode(code: string, options?: AuthoredCodeOptions): void;
-//#endregion
-//#region src/runtime/graph/condition.d.ts
-/** The leaf comparison operators; `exists`/`truthy` are unary, the rest compare against `value`. */
-declare const CONDITION_OPS: readonly ["eq", "neq", "gt", "gte", "lt", "lte", "in", "contains", "exists", "truthy"];
-type ConditionOp = (typeof CONDITION_OPS)[number];
-interface ConditionLeaf {
-  /** Dotted path with `[N]` indexing into the guard context, e.g. `out.findings[0].severity`. */
-  readonly path: string;
-  readonly op: ConditionOp;
-  readonly value?: unknown;
-}
-type Condition = ConditionLeaf | {
-  readonly all: ReadonlyArray<Condition>;
-} | {
-  readonly any: ReadonlyArray<Condition>;
-} | {
-  readonly not: Condition;
-};
-/** Validate shape, bounds, and per-leaf path/operator rules; returns the input for chaining. */
-declare function validateCondition(raw: unknown, context: string): Condition;
-/** Walk a validated condition over a context to a boolean. Never throws on data shape. */
-declare function evaluateCondition(condition: Condition, context: unknown): boolean;
-//#endregion
-//#region src/runtime/graph/registry.d.ts
-/**
- * `Registry<T>` — the ONE name→thing shape for the graph engine.
- *
- * The kernel grew fourteen of these (agent-runtime#978) that differ in three properties:
- * whether names can be listed, what a miss does, and whether the table is global. This one
- * fixes all three — enumerable, a miss is refused BY NAME listing what is registered, and every
- * registry is per-instance — and it is lifted from `AgentEnvironmentProviderRegistry`, the
- * richest and best-tested of the fourteen, not invented.
- *
- * Entries are addressed by a versioned handle, `<id>/v<n>`, the same way the prompt registry
- * addresses directives. A graph names a kind by handle; a host registers exact versions; a
- * missing version is refused, never served by a newer one.
- */
-/** A versioned name: what a graph writes and what a host registers. */
-interface RegistryHandle {
-  readonly id: string;
-  readonly version: number;
-}
-/** `<id>/v<n>` — the only spelling a handle has on the wire, in a journal, or in an error. */
-declare function formatRegistryHandle(handle: RegistryHandle): string;
-/** Parse the wire spelling back. Refuses anything that is not exactly `<id>/v<n>`. */
-declare function parseRegistryHandle(text: string, context: string): RegistryHandle;
-/** Anything a registry holds carries its own handle, so the table cannot drift from the entry. */
-interface Registered extends RegistryHandle {}
-interface Registry<T extends Registered> {
-  /** 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. */
-  register(entry: T, options?: {
-    readonly replace?: boolean;
-  }): void;
-  has(handle: RegistryHandle): boolean;
-  get(handle: RegistryHandle): T | undefined;
-  /** The entry, or a refusal that names the handle AND lists every registered handle — a miss
-   *  must be diagnosable from its message alone. */
-  require(handle: RegistryHandle, context?: string): T;
-  /** Every registered handle, sorted, as wire spellings. The thing the fourteen predecessors
-   *  mostly could not do and four callers needed. */
-  names(): string[];
-  /** Every entry, in `names()` order. */
-  entries(): 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.
- */
-declare function createRegistry<T extends Registered>(label: string, seed?: Iterable<T>): Registry<T>;
-//#endregion
-//#region src/runtime/graph/kind.d.ts
-/** A JSON Schema document as the kernel already spells it: an opaque record, validated by the
- *  consumer's own validator, published verbatim. */
-type JsonSchema = Readonly<Record<string, unknown>>;
-/**
- * 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`.
- */
-interface PortSpec {
-  readonly name: string;
-  readonly schema: JsonSchema;
-  readonly description?: string;
-}
-/**
- * What a kind declares it needs from the host. The engine never imports a host capability; it
- * knows only that a kind SAID it needs something under this name and the host PROVIDED something
- * under it. The context a kind receives is narrowed to exactly its declaration — an undeclared
- * effect is `undefined`, never a service locator.
- */
-/** 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. */
-interface GraphHost {
-  runNested(graph: unknown, task: string, options: {
-    readonly budget: unknown;
-    readonly perNode?: unknown;
-    readonly runId: string;
-    readonly signal?: AbortSignal;
-  }): Promise<{
-    readonly kind: string;
-    readonly out?: unknown;
-  }>;
-}
-type EffectName = string;
-type EffectContext<Effects extends ReadonlyArray<EffectName>> = Readonly<{ [K in Effects[number]]: unknown; }>;
-/**
- * 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).
- */
-type OnCrash = 'restart' | 'resume';
-/**
- * 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`).
- */
-type BudgetMode = 'metered' | 'exempt';
-/** 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. */
-interface NodeKind<Config = unknown, Effects extends ReadonlyArray<EffectName> = ReadonlyArray<EffectName>> extends Registered {
-  /** Kind id, e.g. `agent`, `integration.invoke`. With `version`, forms the handle `<id>/v<n>`. */
-  readonly id: string;
-  readonly version: number;
-  readonly description: string;
-  /** Validate and narrow one node's config. Throw `ValidationError` to refuse; the compiler
-   *  surfaces the message with the node id prefixed. */
-  readonly validateConfig: (raw: unknown, context: string) => Config;
-  /** The portable form of `validateConfig`'s accepted shape, for manifests and hosts. */
-  readonly configSchema: JsonSchema;
-  /** Declared input ports; a `data` edge may bind only these. Empty for a source node. */
-  readonly inputs: ReadonlyArray<PortSpec>;
-  /** Declared output ports beside the implicit `out` and `trace`. */
-  readonly outputs: ReadonlyArray<PortSpec>;
-  /** Host capabilities this kind reaches for, by name. The context is narrowed to exactly these. */
-  readonly effects: Effects;
-  readonly onCrash: OnCrash;
-  readonly budget: BudgetMode;
-  /**
-   * 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`).
-   */
-  readonly run: (args: {
-    readonly config: Config;
-    readonly profile: AgentProfile;
-    readonly inputs: Readonly<Record<string, unknown>>;
-    readonly effects: EffectContext<Effects>;
-    readonly spawn?: WorkerSpawnContext;
-    /** 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. */
-    readonly host?: GraphHost;
-  }) => Agent<unknown, unknown>;
-}
-/**
- * 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.
- */
-type AnyNodeKind = NodeKind<any, ReadonlyArray<EffectName>>;
-/** Per-node flags a graph author sets; they are node properties, not kinds (agent-runtime#970). */
-interface NodeFlags {
-  /** 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. */
-  readonly oracle?: 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. */
-  readonly pure?: boolean;
-}
-/** Validate a kind declaration at registration — so a malformed kind is refused by name once,
- *  not at the first node that uses it. */
-declare function validateNodeKind(kind: AnyNodeKind, context?: string): AnyNodeKind;
-/** The handle a graph writes to name this kind. */
-declare function kindHandle(kind: Pick<NodeKind, 'id' | 'version'>): RegistryHandle;
-/**
- * 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.
- */
-declare function narrowEffects<Effects extends ReadonlyArray<EffectName>>(declared: Effects, provided: Readonly<Record<string, unknown>>, context: string): EffectContext<Effects>;
-//#endregion
-//#region src/runtime/graph/projection.d.ts
-type Projection = {
-  readonly path: string;
-} | {
-  readonly pick: ReadonlyArray<string>;
-} | {
-  readonly map: string;
-} | {
-  readonly filter: Condition;
-} | {
-  readonly first: true;
-} | {
-  readonly last: true;
-} | {
-  readonly count: true;
-};
-/** Validate a projection: exactly one known operator, its argument well-formed. */
-declare function validateProjection(raw: unknown, context: string): Projection;
-/**
- * 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.
- */
-declare function applyProjection(value: unknown, projection: Projection, context: string): unknown;
-//#endregion
-//#region src/runtime/graph/definition.d.ts
-/** Which gating-edge outcomes release a node (adopted from ADC, agent-runtime#968). */
-declare const JOIN_RULES: readonly ["all", "any", "any_failed", "all_done"];
-type JoinRule = (typeof JOIN_RULES)[number];
-/** ADC-compatible visit backstop: nothing may be ENTERED more than this many times. */
-declare const DEFAULT_MAX_NODE_VISITS = 25;
-/** The hard ceiling an author's `maxVisits`/`maxNodeVisits` override may reach. */
-declare const MAX_MAX_NODE_VISITS = 100;
-type GraphEdgeKind = 'delegates' | 'analyzes' | 'data';
-interface EngineGraphNode {
-  readonly id: string;
-  /** `<id>/v<n>` into the engine's kind registry. */
-  readonly kind: string;
-  /** This node's config, validated by its kind's `validateConfig` at compile. */
-  readonly config?: unknown;
-  /** Per-node flags — properties of the node, never of its kind (agent-runtime#970). */
-  readonly flags?: NodeFlags;
-  /** 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. */
-  readonly ports?: {
-    readonly inputs?: ReadonlyArray<PortSpec>;
-    readonly outputs?: ReadonlyArray<PortSpec>;
-  };
-  /** Which inbound gating-edge outcomes release this node. Default `all`. */
-  readonly join?: JoinRule;
-  /** Entered more than this many times fails the run `cycle-budget-exceeded`. */
-  readonly maxVisits?: number;
-  /** This node's completion check; a terminal without one (or a kind/graph default) refuses. */
-  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`. */
-  readonly budget?: Budget;
-}
-interface EngineGraphEdge {
-  /** Stable id for the ledger; defaults to `<from>-><to>#<ordinal>`. */
-  readonly id?: string;
-  readonly kind: GraphEdgeKind;
-  readonly from: {
-    readonly node: string;
-    readonly port?: string;
-  };
-  readonly to: {
-    readonly node: string;
-    readonly port?: string;
-  };
-  /** Evaluated over the source's settle context; absent = satisfied by completion. */
-  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`); `0` closes the edge from the start. */
-  readonly maxTraversals?: number;
-  /** `delegates`/`analyzes`: the versioned directive appended to the target's task. */
-  readonly directive?: PromptHandle;
-}
-interface EngineGraphSpec {
-  readonly nodes: ReadonlyArray<EngineGraphNode>;
-  readonly edges: ReadonlyArray<EngineGraphEdge>;
-  /** Root node for the graph-level completion check. Defaults to the single entry node. */
-  readonly root?: string;
-  /** Becomes the ROOT node's completion check when the root declares none (#973). */
-  readonly deliverable?: DeliverableSpec<unknown>;
-  readonly maxNodeVisits?: number;
-}
-//#endregion
-//#region src/runtime/graph/engine.d.ts
-interface GraphEngineOptions {
-  /** Kinds to register beside the core set. A host adds its own here; nothing is global. */
-  readonly kinds?: ReadonlyArray<AnyNodeKind>;
-  /** The host's effect table, by name. A kind receives only the effects it declared. */
-  readonly effects?: Readonly<Record<EffectName, unknown>>;
-  /** The core set. Injected so a test can substitute, and so the engine never imports a
-   *  backend-specific factory at module load. */
-  readonly coreKinds: ReadonlyArray<AnyNodeKind>;
-}
-interface GraphEngine {
-  readonly kinds: Registry<AnyNodeKind>;
-  readonly effects: Readonly<Record<EffectName, unknown>>;
-  /** 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. */
-  requiredEffects(): string[];
-  /** The declared effects no host value covers. Empty means every registered kind is runnable. */
-  missingEffects(): string[];
-}
-/**
- * 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.
- */
-declare function createGraphEngine(options: GraphEngineOptions): GraphEngine;
-//#endregion
-//#region src/runtime/graph/compile.d.ts
-interface CompiledEdge {
-  readonly id: string;
-  readonly spec: EngineGraphEdge;
-  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;
-  readonly config: unknown;
-  readonly join: JoinRule;
-  readonly maxVisits: number;
-  readonly oracle: boolean;
-  readonly pure: boolean;
-  readonly terminal: boolean;
-  /** The check this node must pass to count DELIVERED; resolved per #973. */
-  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 {
-  readonly nodes: ReadonlyMap<string, CompiledNode>;
-  readonly edges: ReadonlyArray<CompiledEdge>;
-  readonly entries: ReadonlyArray<string>;
-  readonly terminals: ReadonlyArray<string>;
-  readonly root: string;
-  readonly maxNodeVisits: number;
-}
-/**
- * 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.
- */
-declare function schemaAccepts(source: JsonSchema, target: JsonSchema, depth?: number): boolean;
-/**
- * Lower an authored graph against an engine's kind registry into the schedulable form, refusing
- * every structural defect before any spend.
- */
-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;
-  /** 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. */
-  readonly seq: 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;
-  /**
-   * Whether this instance's release consumed its wave — the `join-state` the
-   * scheduler journals AFTER the envelope pin. A restart that finds a
-   * released instance without it completes the half-journaled release rather
-   * than leaving the gating edges satisfied, which would release the node a
-   * second time and execute it twice.
-   */
-  waveConsumed?: boolean;
-}
-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 {
-  /** Next settle ordinal; the fold is the only writer, so replay reproduces the same order. */
-  settleSeq: {
-    value: number;
-  };
-  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. */
-  readonly backend?: ExecutorConfig;
-  /** This node's completion check. Omit to inherit the graph's terminal check. */
-  readonly deliverable?: DeliverableSpec<unknown>;
-}
-/**
- * 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.
- */
-declare function agentKind(defaults: {
-  readonly backend?: ExecutorConfig;
-  readonly deliverable?: DeliverableSpec<unknown>;
-}): NodeKind<AgentKindConfig>;
-interface SupervisorKindConfig {
-  /** Per-child budget reserved from the pool on each spawn this supervisor makes. */
-  readonly perWorker: SupervisorAgentDeps['perWorker'];
-  readonly maxLiveWorkers?: number;
-}
-/**
- * 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`.
- */
-declare function supervisorKind(deps: {
-  readonly blobs: SupervisorAgentDeps['blobs'];
-  readonly makeWorkerAgent: MakeWorkerAgent;
-  readonly router?: SupervisorAgentDeps['router'];
-  readonly driveHarness?: SupervisorAgentDeps['driveHarness'];
-}): NodeKind<SupervisorKindConfig>;
-/** The caller code a `script` node runs. Receives the resolved inputs; returns the output. */
-type ScriptBody = (inputs: Readonly<Record<string, unknown>>, signal: AbortSignal) => Promise<unknown> | unknown;
-interface ScriptKindConfig {
-  readonly body: ScriptBody;
-  /**
-   * `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.
-   */
-  readonly pure?: boolean;
-  /** 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. */
-  readonly spent?: Spend;
-}
-/**
- * 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.
- */
-declare function scriptKind(): NodeKind<ScriptKindConfig>;
-/**
- * A node carrying its own graph: the constraint on what a supervisor may spawn at depth>1. Its
- * executor is a nested engine run; that needs the scheduler (#980), so until then this kind is
- * registered and REFUSES at run time by name rather than being absent — a graph that names it
- * compiles, and the refusal says exactly what is missing.
- */
-/** Config for a nesting node: the inner graph, and the pool the inner run is given. */
-interface SubgraphKindConfig {
-  readonly graph: unknown;
-  /** The inner run's conserved pool. Its spend is the inner pool's, never re-charged here. */
-  readonly budget?: unknown;
-  readonly perNode?: unknown;
-}
-/** A node carrying its own graph: it runs as a full engine run on the host's kinds and effects. */
-declare function subgraphKind(): NodeKind<SubgraphKindConfig>;
-//#endregion
-//#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>;
-}
-/** 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 kind id the root node carries: a supervisor holding the whole `AgentGraph`. */
-declare const RUN_GRAPH_ROOT_KIND = "supervisor/v1";
-/**
- * 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.
- */
-declare function graphFromRunGraph(graph: AgentGraph, options: RunGraphOptions): EngineGraphSpec;
-//#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 finalizer?: FinalizerChoice;
-  readonly failure?: {
-    readonly reason: GraphRunReason;
-    readonly error?: {
-      name: string;
-      message: 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;
-  /** Default per-instance reservation for nodes that declare no `budget` of their own.
-   *  Required when any such node exists — the engine invents no split. */
-  readonly perNode?: Budget;
-  readonly journal?: SpawnJournal;
-  readonly blobs?: ResultBlobStore;
-  /** Resolves `delegates`/`analyzes` directives; required when any edge carries one. */
-  readonly prompts?: PromptRegistry;
-  /** How terminal settles reduce to `out`. Default `bestDelivered`. */
-  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;
-}
-/** 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>;
-/**
- * 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 createGraphRun(engine: GraphEngine, spec: EngineGraphSpec | CompiledGraph, task: string, options: GraphRunOptions): GraphRunHandle;
-//#endregion
-export { type AgentKindConfig, type AnyNodeKind, type AuthoredCodeOptions, 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 GraphHost, 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_ROOT_KIND, type Registered, type Registry, type RegistryHandle, type ScriptBody, type ScriptKindConfig, type SubgraphKindConfig, type SupervisorKindConfig, type SuspensionRequest, admitPayload, agentKind, applyGraphFoldEvent, applyProjection, assembleGraphResult, assertAuthoredCode, compileGraph, createEdgeLedger, createGraphEngine, createGraphRun, createRegistry, decideJoin, emptyFoldState, evaluateCondition, foldGraphJournal, formatRegistryHandle, graphFromRunGraph, isEngineFired, isSuspensionRequest, kindHandle, materializeSettles, mintSuspensionToken, narrowEffects, openGraphRun, parseRegistryHandle, runEngineGraph, schemaAccepts, scriptKind, subgraphKind, supervisorKind, suspended, suspensionNodeId, tokenFromSuspensionNodeId, validateCondition, validateNodeKind, validateProjection };
-//# sourceMappingURL=graph.d.ts.map