@tangle-network/agent-runtime 0.161.0 → 0.163.0

package/dist/graph.d.ts

@@ -0,0 +1,467 @@
+import { $l as MakeWorkerAgent, If as DeliverableSpec, an as PromptRegistry, bo as SupervisorAgentDeps, in as PromptHandle, mu as WorkerSpawnContext, os as SupervisorFinalizer } from "./index-CbyKCjR7.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-CCbeY1KO.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`. */
+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.
+ */
+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;
+  }) => Agent<unknown, unknown>;
+}
+/** 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: NodeKind, context?: string): NodeKind;
+/** 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;
+  /** 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`). */
+  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<NodeKind>;
+  /** 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<NodeKind>;
+}
+interface GraphEngine {
+  readonly kinds: Registry<NodeKind>;
+  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;
+}
+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>;
+  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/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.
+ */
+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;
+}
+/** 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>;
+};
+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?: 'bestDelivered' | 'collectDelivered' | SupervisorFinalizer;
+  readonly signal?: AbortSignal;
+  readonly now?: () => number;
+  readonly runId?: string;
+}
+/** 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;
+/**
+ * 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.
+ */
+declare function runEngineGraph(engine: GraphEngine, spec: EngineGraphSpec | CompiledGraph, task: string, options: GraphRunOptions): Promise<GraphRunResult>;
+//#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 };
+//# sourceMappingURL=graph.d.ts.map