@graphrefly/graphrefly 0.27.0 → 0.28.0

package/dist/index-CpgYhnrG.d.ts

@@ -0,0 +1,291 @@
+import { j as CompileSpecOptions, G as GraphSpec, c as GraphSpecCatalog, C as CatalogFnEntry, a as CatalogSourceEntry, b as ConfigFieldSchema, F as FnFactory, d as GraphSpecFeedbackEdge, e as GraphSpecNode, f as GraphSpecTemplate, g as GraphSpecTemplateRef, h as GraphSpecValidation, S as SourceFactory } from './index-DfyOkTvs.js';
+import { G as Graph, o as GraphNodeFactory, m as GraphDiffResult } from './graph-BZGRXwOm.js';
+import { StorageTier } from './extra/storage-core.js';
+
+/**
+ * Surface: create a graph from a {@link GraphSpec} (§9.3-core).
+ *
+ * Thin wrapper over {@link compileSpec} that converts the two failure modes
+ * ({@link validateSpec} structural errors, and catalog-aware validation
+ * errors) into typed {@link SurfaceError} throws. Consumers are MCP/CLI
+ * wrappers, not end-user graph code — those should import `compileSpec`
+ * directly.
+ *
+ * @module
+ */
+
+/** Options for {@link createGraph}. Same shape as {@link CompileSpecOptions}. */
+type CreateGraphOptions = CompileSpecOptions;
+/**
+ * Build a {@link Graph} from a parsed {@link GraphSpec} with surface-layer
+ * error typing.
+ *
+ * @throws {SurfaceError} `invalid-spec` for structural errors;
+ *   `catalog-error` when fn/source names or config don't match the catalog.
+ */
+declare function createGraph(spec: GraphSpec, opts?: CreateGraphOptions): Graph;
+
+/**
+ * Typed errors for the surface layer (§9.3-core).
+ *
+ * The surface layer is consumed by `@graphrefly/mcp-server` and
+ * `@graphrefly/cli`. Both have native error channels (MCP's `isError` flag,
+ * CLI's exit codes), so surface functions throw a {@link SurfaceError}
+ * carrying a structured code + details payload that wrappers can map to
+ * their native shape. No `Result` envelope — keep the callsite idiom
+ * `try/catch` and let each wrapper surface the error its own way.
+ *
+ * @module
+ */
+/** Structured error codes emitted by the surface layer. JSON-safe. */
+type SurfaceErrorCode = "invalid-spec" | "graph-not-found" | "graph-exists" | "snapshot-not-found" | "node-not-found" | "reduce-timeout" | "catalog-error" | "restore-failed" | "snapshot-failed" | "tier-no-list" | "compose-not-configured" | "compose-failed" | "internal-error";
+/** JSON-safe shape surfaces should echo back through the wrapper. */
+interface SurfaceErrorPayload {
+    code: SurfaceErrorCode;
+    message: string;
+    /** Optional structured detail; must be JSON-safe. */
+    details?: Readonly<Record<string, unknown>>;
+}
+/**
+ * Thrown by surface layer functions on failure. `code` is the stable
+ * machine-readable identifier; `details` carries structured context
+ * (e.g. `validateSpec` errors, missing path name). Both fields round-trip
+ * through `toJSON()` for wrappers that serialize errors over the wire.
+ */
+declare class SurfaceError extends Error {
+    readonly code: SurfaceErrorCode;
+    readonly details?: Readonly<Record<string, unknown>>;
+    constructor(code: SurfaceErrorCode, message: string, details?: Readonly<Record<string, unknown>>);
+    /**
+     * JSON-safe payload for wire serialization. Defensively validates
+     * `details` — if it can't be round-tripped through `JSON.stringify`
+     * (cyclic refs, `BigInt`, `Error` instance not pre-toJSON'd), the
+     * payload falls back to `{code, message}` only rather than crashing
+     * the MCP/CLI wrapper when it serializes this error onto the wire.
+     */
+    toJSON(): SurfaceErrorPayload;
+}
+/** Wrap any thrown value as a SurfaceError. Idempotent on existing SurfaceError. */
+declare function asSurfaceError(err: unknown, fallbackCode?: SurfaceErrorCode): SurfaceError;
+
+/**
+ * Surface: one-shot `input → pipeline → output` (§9.3-core).
+ *
+ * `runReduction` compiles a {@link GraphSpec}, pushes an input value to a
+ * named state node, awaits the first post-push DATA emission on a named
+ * output, then disposes the graph. Stateless per call — no graphId, no
+ * registry.
+ *
+ * Named `runReduction` (not `reduce`) to avoid collision with the
+ * reactive {@link reduce} operator in `extra/operators.ts`. The MCP tool
+ * name (`graphrefly_reduce`) and CLI subcommand (`graphrefly reduce`) use
+ * the short form; the library export carries the verb.
+ *
+ * The subscribe-before-push ordering is deliberate. `graph.set` propagates
+ * synchronously for sync derived/operator chains; for async sources
+ * (`fromPromise`, `fromAsyncIter`, LLM adapters) the first post-push DATA
+ * arrives on a later tick. Subscribing before the push catches both, and
+ * skipping the priming push-on-subscribe emission avoids resolving with the
+ * stale pre-push cache (spec §2.2).
+ *
+ * @module
+ */
+
+/** Options for {@link reduce}. */
+interface ReduceOptions {
+    /** Fn/source catalog for {@link createGraph}. */
+    catalog?: GraphSpecCatalog;
+    /** Path of the state node that receives the input. Default `"input"`. */
+    inputPath?: string;
+    /** Path of the node whose first post-push DATA is the result. Default `"output"`. */
+    outputPath?: string;
+    /** Hard deadline in milliseconds. Default `30_000`. */
+    timeoutMs?: number;
+}
+/**
+ * Run a spec as a one-shot reduction: `input → graph → output`.
+ *
+ * Resolves on the first `[DATA, v]` **or** `[RESOLVED]` emitted by
+ * `outputPath` after the input push. The RESOLVED path handles spec
+ * §1.3.3 equals-substitution (output recomputed to a value equal to its
+ * cache, so the graph skips the DATA push) by returning `outputNode.cache`
+ * — the caller always gets the settled value, never hangs on idempotent
+ * inputs.
+ *
+ * @throws {SurfaceError} `invalid-spec` / `catalog-error` (propagated from
+ *   {@link createGraph}), `node-not-found` when `inputPath`/`outputPath`
+ *   can't be resolved, `reduce-timeout` when `timeoutMs` elapses without
+ *   a post-push emission, or the ERROR payload from the graph re-thrown
+ *   as `internal-error`.
+ */
+declare function runReduction(spec: GraphSpec, input: unknown, opts?: ReduceOptions): Promise<unknown>;
+
+/**
+ * Surface: snapshot save/restore/diff/list over {@link StorageTier} (§9.3-core).
+ *
+ * One-shot snapshot management for stateless callers (MCP tools, CLI
+ * commands) layered on the existing multi-tier auto-checkpoint substrate.
+ * A saved snapshot is a `mode: "full"` {@link GraphCheckpointRecord} with
+ * `seq: 0` — byte-identical to the baseline anchor
+ * {@link Graph.attachStorage} writes on its first flush. An
+ * auto-checkpointed graph can therefore be restored through this surface,
+ * and a surface-saved snapshot can be picked up by `attachStorage({
+ * autoRestore: true })`.
+ *
+ * The wire envelope stays at {@link SNAPSHOT_WIRE_VERSION}; no new format.
+ *
+ * @module
+ */
+
+/**
+ * Current envelope version. Re-exported from `graph.ts` so the one-shot
+ * surface path and `Graph.attachStorage` write byte-identical
+ * `format_version` fields — no silent wire drift.
+ */
+declare const SNAPSHOT_WIRE_VERSION = 1;
+/** Shape returned by {@link saveSnapshot}. */
+interface SaveSnapshotResult {
+    snapshotId: string;
+    timestamp_ns: number;
+}
+/** Options for {@link restoreSnapshot}. */
+interface RestoreSnapshotOptions {
+    /** Passthrough to `Graph.fromSnapshot`. First matching pattern wins. */
+    factories?: Record<string, GraphNodeFactory>;
+}
+/**
+ * Write a graph's current state as a one-shot `mode: "full"` record.
+ *
+ * Uses the same {@link GraphCheckpointRecord} envelope as
+ * {@link Graph.attachStorage} so the two persistence paths interoperate.
+ *
+ * @throws {SurfaceError} `snapshot-failed` when the tier's `save` throws.
+ */
+declare function saveSnapshot(graph: Graph, snapshotId: string, tier: StorageTier): Promise<SaveSnapshotResult>;
+/**
+ * Load a snapshot from a tier and materialize it as a new {@link Graph}.
+ *
+ * Uses {@link Graph.fromSnapshot} to reconstruct topology; pass
+ * `factories` when the graph includes non-state nodes that the default
+ * hydrator can't rebuild on its own.
+ *
+ * **Requires a `mode: "full"` record.** Surface-written snapshots from
+ * {@link saveSnapshot} always qualify. Records written by
+ * {@link Graph.attachStorage} with `compactEvery > 1` may be
+ * `mode: "diff"` between compacts — those throw `restore-failed` until
+ * the tier's next compact flush (or until Phase 8.7 WAL replay lands).
+ * If you need interop during development, either call
+ * {@link saveSnapshot} explicitly (always full) or configure
+ * `attachStorage({compactEvery: 1})`.
+ *
+ * @throws {SurfaceError} `snapshot-not-found` on miss; `restore-failed`
+ *   when the payload shape doesn't match, when the record is
+ *   `mode: "diff"`, or when `Graph.fromSnapshot` rejects.
+ */
+declare function restoreSnapshot(snapshotId: string, tier: StorageTier, opts?: RestoreSnapshotOptions): Promise<Graph>;
+/**
+ * Load two snapshots and compute a {@link GraphDiffResult} via static
+ * {@link Graph.diff}. Returns the audit shape (structural + value diff,
+ * no payload); use {@link diffForWAL} directly for WAL-oriented diffs.
+ *
+ * @throws {SurfaceError} `snapshot-not-found` on either miss.
+ */
+declare function diffSnapshots(snapshotIdA: string, snapshotIdB: string, tier: StorageTier): Promise<GraphDiffResult>;
+/**
+ * Enumerate snapshot ids on a tier.
+ *
+ * Only keys written by {@link saveSnapshot} are returned. Surface-written
+ * records are stored under the `"snapshot:"` key prefix and decoded back to
+ * the caller-visible id before being returned — other keys on the same tier
+ * (notably `attachStorage` baseline/WAL keys written under `graph.name`) are
+ * filtered out automatically. This lets a single tier back both the surface
+ * and `attachStorage` without leaking graph names through `listSnapshots`.
+ *
+ * @param tier — the storage tier to enumerate.
+ * @param opts.includeUnprefixed — when `true`, also return keys that are
+ *   NOT under the namespacing prefix. Off by default; set this when reading
+ *   pre-namespacing snapshot sets.
+ *
+ *   **Caveat:** when a tier is shared with {@link Graph.attachStorage}, its
+ *   auto-checkpoint baseline + WAL keys (written under `graph.name`) are
+ *   unprefixed. Calling with `includeUnprefixed: true` returns those keys
+ *   alongside surface snapshots — and subsequent `restoreSnapshot` /
+ *   `deleteSnapshot` will operate on them via the fallback-lookup path,
+ *   potentially overwriting or deleting live auto-checkpoint state. Use
+ *   `includeUnprefixed` only against tiers you know are NOT shared with
+ *   `attachStorage`, or follow up with a predicate filter to separate
+ *   ids you own from ones owned by other subsystems.
+ *
+ * @throws {SurfaceError} `tier-no-list` when the tier does not implement
+ *   the optional `list()` method. Check `typeof tier.list === "function"`
+ *   before calling if you want to branch on capability.
+ */
+declare function listSnapshots(tier: StorageTier, opts?: {
+    includeUnprefixed?: boolean;
+}): Promise<readonly string[]>;
+/**
+ * Delete a snapshot from a tier.
+ *
+ * Silent on miss (clear semantics). `tier.clear` is optional — throws
+ * `snapshot-failed` when the tier is append-only.
+ *
+ * @throws {SurfaceError} `snapshot-failed` when `clear` is unsupported
+ *   or throws.
+ */
+declare function deleteSnapshot(snapshotId: string, tier: StorageTier): Promise<void>;
+
+/**
+ * Surface layer (§9.3-core) — shared, JSON-safe operations consumed by
+ * `@graphrefly/mcp-server` and `@graphrefly/cli`.
+ *
+ * The surface is a thin projection of existing Graph APIs (`describe`,
+ * `observe`, `explain`, `snapshot`, `restore`, static `diff`), plus two
+ * genuinely new operations:
+ *
+ * 1. {@link createGraph} — `compileSpec` wrapped with typed surface errors.
+ * 2. {@link reduce} — one-shot `input → pipeline → output`.
+ *
+ * Snapshot persistence reuses the {@link StorageTier} substrate introduced
+ * for `Graph.attachStorage`, so one-shot snapshots and auto-checkpoints
+ * share the {@link GraphCheckpointRecord} envelope. No new wire format.
+ *
+ * Errors throw as {@link SurfaceError} — wrappers map to their native
+ * error channel (MCP `isError`, CLI exit code). No `Result<T, E>` wrapper.
+ *
+ * @module
+ */
+
+declare const index_CatalogFnEntry: typeof CatalogFnEntry;
+declare const index_CatalogSourceEntry: typeof CatalogSourceEntry;
+declare const index_ConfigFieldSchema: typeof ConfigFieldSchema;
+type index_CreateGraphOptions = CreateGraphOptions;
+declare const index_FnFactory: typeof FnFactory;
+declare const index_GraphSpec: typeof GraphSpec;
+declare const index_GraphSpecCatalog: typeof GraphSpecCatalog;
+declare const index_GraphSpecFeedbackEdge: typeof GraphSpecFeedbackEdge;
+declare const index_GraphSpecNode: typeof GraphSpecNode;
+declare const index_GraphSpecTemplate: typeof GraphSpecTemplate;
+declare const index_GraphSpecTemplateRef: typeof GraphSpecTemplateRef;
+declare const index_GraphSpecValidation: typeof GraphSpecValidation;
+type index_ReduceOptions = ReduceOptions;
+type index_RestoreSnapshotOptions = RestoreSnapshotOptions;
+declare const index_SNAPSHOT_WIRE_VERSION: typeof SNAPSHOT_WIRE_VERSION;
+type index_SaveSnapshotResult = SaveSnapshotResult;
+declare const index_SourceFactory: typeof SourceFactory;
+type index_SurfaceError = SurfaceError;
+declare const index_SurfaceError: typeof SurfaceError;
+type index_SurfaceErrorCode = SurfaceErrorCode;
+type index_SurfaceErrorPayload = SurfaceErrorPayload;
+declare const index_asSurfaceError: typeof asSurfaceError;
+declare const index_createGraph: typeof createGraph;
+declare const index_deleteSnapshot: typeof deleteSnapshot;
+declare const index_diffSnapshots: typeof diffSnapshots;
+declare const index_listSnapshots: typeof listSnapshots;
+declare const index_restoreSnapshot: typeof restoreSnapshot;
+declare const index_runReduction: typeof runReduction;
+declare const index_saveSnapshot: typeof saveSnapshot;
+declare namespace index {
+  export { index_CatalogFnEntry as CatalogFnEntry, index_CatalogSourceEntry as CatalogSourceEntry, index_ConfigFieldSchema as ConfigFieldSchema, type index_CreateGraphOptions as CreateGraphOptions, index_FnFactory as FnFactory, index_GraphSpec as GraphSpec, index_GraphSpecCatalog as GraphSpecCatalog, index_GraphSpecFeedbackEdge as GraphSpecFeedbackEdge, index_GraphSpecNode as GraphSpecNode, index_GraphSpecTemplate as GraphSpecTemplate, index_GraphSpecTemplateRef as GraphSpecTemplateRef, index_GraphSpecValidation as GraphSpecValidation, type index_ReduceOptions as ReduceOptions, type index_RestoreSnapshotOptions as RestoreSnapshotOptions, index_SNAPSHOT_WIRE_VERSION as SNAPSHOT_WIRE_VERSION, type index_SaveSnapshotResult as SaveSnapshotResult, index_SourceFactory as SourceFactory, index_SurfaceError as SurfaceError, type index_SurfaceErrorCode as SurfaceErrorCode, type index_SurfaceErrorPayload as SurfaceErrorPayload, index_asSurfaceError as asSurfaceError, index_createGraph as createGraph, index_deleteSnapshot as deleteSnapshot, index_diffSnapshots as diffSnapshots, index_listSnapshots as listSnapshots, index_restoreSnapshot as restoreSnapshot, index_runReduction as runReduction, index_saveSnapshot as saveSnapshot };
+}
+
+export { type CreateGraphOptions as C, type ReduceOptions as R, SNAPSHOT_WIRE_VERSION as S, type RestoreSnapshotOptions as a, type SaveSnapshotResult as b, SurfaceError as c, type SurfaceErrorCode as d, type SurfaceErrorPayload as e, asSurfaceError as f, createGraph as g, deleteSnapshot as h, diffSnapshots as i, runReduction as j, index as k, listSnapshots as l, restoreSnapshot as r, saveSnapshot as s };

package/dist/{index-DO_6JN9Z.d.cts → index-Cyojz0AE.d.cts}

@@ -1,4 +1,4 @@
-import { N as Node } from './node-BmerH3kS.cjs';
+import { a as Node } from './node-Cc1TniY8.cjs';
 
 /**
  * A Nanostores-compatible atom.

package/dist/{demo-shell-BDkOptd6.d.ts → index-CzobVSMr.d.ts}

@@ -1,5 +1,5 @@
-import { a as Graph } from './graph-CCwGKLCm.js';
-import { M as MeasurementAdapter } from './reactive-layout-u5Ulnqag.js';
+import { G as Graph } from './graph-BZGRXwOm.js';
+import { M as MeasurementAdapter } from './reactive-layout-D8u4wuUR.js';
 
 /**
  * Three-pane demo shell (roadmap §7.2).
@@ -86,17 +86,17 @@ type DemoShellHandle = {
  */
 declare function demoShell(opts?: DemoShellOptions): DemoShellHandle;
 
-type demoShell$1_DemoShellHandle = DemoShellHandle;
-type demoShell$1_DemoShellOptions = DemoShellOptions;
-type demoShell$1_FullscreenPane = FullscreenPane;
-type demoShell$1_GraphLabelSize = GraphLabelSize;
-type demoShell$1_HighlightCallbacks = HighlightCallbacks;
-type demoShell$1_HoverPaneType = HoverPaneType;
-type demoShell$1_HoverTarget = HoverTarget;
-type demoShell$1_NodeRegistry = NodeRegistry;
-declare const demoShell$1_demoShell: typeof demoShell;
-declare namespace demoShell$1 {
-  export { type demoShell$1_DemoShellHandle as DemoShellHandle, type demoShell$1_DemoShellOptions as DemoShellOptions, type demoShell$1_FullscreenPane as FullscreenPane, type demoShell$1_GraphLabelSize as GraphLabelSize, type demoShell$1_HighlightCallbacks as HighlightCallbacks, type demoShell$1_HoverPaneType as HoverPaneType, type demoShell$1_HoverTarget as HoverTarget, type demoShell$1_NodeRegistry as NodeRegistry, demoShell$1_demoShell as demoShell };
+type index_DemoShellHandle = DemoShellHandle;
+type index_DemoShellOptions = DemoShellOptions;
+type index_FullscreenPane = FullscreenPane;
+type index_GraphLabelSize = GraphLabelSize;
+type index_HighlightCallbacks = HighlightCallbacks;
+type index_HoverPaneType = HoverPaneType;
+type index_HoverTarget = HoverTarget;
+type index_NodeRegistry = NodeRegistry;
+declare const index_demoShell: typeof demoShell;
+declare namespace index {
+  export { type index_DemoShellHandle as DemoShellHandle, type index_DemoShellOptions as DemoShellOptions, type index_FullscreenPane as FullscreenPane, type index_GraphLabelSize as GraphLabelSize, type index_HighlightCallbacks as HighlightCallbacks, type index_HoverPaneType as HoverPaneType, type index_HoverTarget as HoverTarget, type index_NodeRegistry as NodeRegistry, index_demoShell as demoShell };
 }
 
-export { type DemoShellHandle as D, type FullscreenPane as F, type GraphLabelSize as G, type HighlightCallbacks as H, type NodeRegistry as N, type DemoShellOptions as a, type HoverPaneType as b, type HoverTarget as c, demoShell$1 as d, demoShell as e };
+export { type DemoShellHandle as D, type FullscreenPane as F, type GraphLabelSize as G, type HighlightCallbacks as H, type NodeRegistry as N, type DemoShellOptions as a, type HoverPaneType as b, type HoverTarget as c, demoShell as d, index as i };

package/dist/index-Czq6ynh8.d.ts

@@ -0,0 +1,143 @@
+import { a as Node, N as NodeOptions, c as NodeActions } from './node-Cc1TniY8.js';
+import { D as DerivedFn } from './sugar-Dtyrq2_q.js';
+import { G as Graph, a as GraphOptions } from './graph-BZGRXwOm.js';
+
+/**
+ * Orchestration patterns (roadmap §4.1).
+ *
+ * Domain-layer helpers that build workflow shapes on top of core + extra primitives.
+ * Exported under the `patterns.orchestration` namespace to avoid collisions with
+ * Phase 2 operator names (for example `gate`, `forEach`).
+ */
+
+type StepRef = string | Node<unknown>;
+type OrchestrationMeta = {
+    orchestration?: true;
+    orchestration_type?: string;
+};
+type OrchestrationStepOptions = Omit<NodeOptions<unknown>, "describeKind" | "name" | "meta"> & {
+    deps?: ReadonlyArray<StepRef>;
+    meta?: Record<string, unknown> & OrchestrationMeta;
+};
+type BranchResult<T> = {
+    branch: "then" | "else";
+    value: T;
+};
+type SensorControls<T> = {
+    node: Node<T>;
+    push(value: T): void;
+    error(err: unknown): void;
+    complete(): void;
+};
+type LoopOptions = Omit<OrchestrationStepOptions, "deps"> & {
+    iterations?: number | StepRef;
+};
+type SubPipelineBuilder = (sub: Graph) => void;
+/**
+ * Creates an orchestration graph container.
+ */
+declare function pipeline(name: string, opts?: GraphOptions): Graph;
+/**
+ * Registers a workflow task node.
+ */
+declare function task<T>(graph: Graph, name: string, run: DerivedFn<T>, opts?: OrchestrationStepOptions): Node<T>;
+/**
+ * Emits tagged branch outcomes (`then` / `else`) for each source value.
+ */
+declare function branch<T>(graph: Graph, name: string, source: StepRef, predicate: (value: T) => boolean, opts?: Omit<OrchestrationStepOptions, "deps">): Node<BranchResult<T>>;
+type ApprovalOptions = Omit<OrchestrationStepOptions, "deps"> & {
+    isApproved?: (value: unknown) => boolean;
+};
+/**
+ * Human/LLM approval gate over a source value.
+ */
+declare function approval<T>(graph: Graph, name: string, source: StepRef, approver: StepRef, opts?: ApprovalOptions): Node<T>;
+interface GateOptions {
+    /** Maximum queue size. Oldest values are FIFO-dropped when exceeded. Default: Infinity. */
+    maxPending?: number;
+    /** Start in open mode (auto-approve). Default: false. */
+    startOpen?: boolean;
+    meta?: Record<string, unknown>;
+}
+/** Control surface returned by {@link gate}. */
+interface GateController<T> {
+    /** The output node registered in the graph (subscribe to receive approved values). */
+    node: Node<T>;
+    /** Reactive queue of values waiting for approval. */
+    pending: Node<T[]>;
+    /** Derived count of pending items. */
+    count: Node<number>;
+    /** Whether the gate is currently open (auto-approving). */
+    isOpen: Node<boolean>;
+    /** Approve and forward the next `count` pending values (default: 1). */
+    approve(count?: number): void;
+    /** Reject (discard) the next `count` pending values (default: 1). */
+    reject(count?: number): void;
+    /**
+     * Transform and forward `count` pending values (default: 1).
+     * `fn` receives `(value, index, pending)` — Array.map-style.
+     */
+    modify(fn: (value: T, index: number, pending: readonly T[]) => T, count?: number): void;
+    /** Flush all pending values and auto-approve future values. */
+    open(): void;
+    /** Re-enable manual gating (stop auto-approving). */
+    close(): void;
+}
+/**
+ * Human-in-the-loop gate: queues incoming values from `source` and lets an external
+ * controller {@link GateController.approve approve}, {@link GateController.reject reject},
+ * or {@link GateController.modify modify} them before forwarding downstream.
+ *
+ * Observable surfaces (`pending`, `count`, `isOpen`) are reactive nodes registered in
+ * the graph. The gate output node is also registered.
+ */
+declare function gate<T>(graph: Graph, name: string, source: StepRef, opts?: GateOptions): GateController<T>;
+/**
+ * Registers a join step that emits a tuple of latest dependency values.
+ */
+declare function join<T extends readonly unknown[]>(graph: Graph, name: string, deps: {
+    [K in keyof T]: StepRef;
+}, opts?: Omit<OrchestrationStepOptions, "deps">): Node<T>;
+/**
+ * Registers a loop step that applies `iterate` to each source value N times.
+ */
+declare function loop<T>(graph: Graph, name: string, source: StepRef, iterate: (value: T, iteration: number, actions: NodeActions) => T, opts?: LoopOptions): Node<T>;
+/**
+ * Mounts and returns a child workflow graph.
+ */
+declare function subPipeline(graph: Graph, name: string, childOrBuild?: Graph | SubPipelineBuilder, opts?: GraphOptions): Graph;
+/**
+ * Registers a producer-style sensor source and returns imperative controls.
+ */
+declare function sensor<T>(graph: Graph, name: string, initial?: T, opts?: Omit<NodeOptions<unknown>, "name" | "describeKind" | "meta"> & {
+    meta?: Record<string, unknown>;
+}): SensorControls<T>;
+/**
+ * Registers an error-recovery step for a source.
+ */
+declare function onFailure<T>(graph: Graph, name: string, source: StepRef, recover: (err: unknown, actions: NodeActions) => T, opts?: Omit<OrchestrationStepOptions, "deps">): Node<T>;
+
+type index_ApprovalOptions = ApprovalOptions;
+type index_BranchResult<T> = BranchResult<T>;
+type index_GateController<T> = GateController<T>;
+type index_GateOptions = GateOptions;
+type index_LoopOptions = LoopOptions;
+type index_OrchestrationStepOptions = OrchestrationStepOptions;
+type index_SensorControls<T> = SensorControls<T>;
+type index_StepRef = StepRef;
+type index_SubPipelineBuilder = SubPipelineBuilder;
+declare const index_approval: typeof approval;
+declare const index_branch: typeof branch;
+declare const index_gate: typeof gate;
+declare const index_join: typeof join;
+declare const index_loop: typeof loop;
+declare const index_onFailure: typeof onFailure;
+declare const index_pipeline: typeof pipeline;
+declare const index_sensor: typeof sensor;
+declare const index_subPipeline: typeof subPipeline;
+declare const index_task: typeof task;
+declare namespace index {
+  export { type index_ApprovalOptions as ApprovalOptions, type index_BranchResult as BranchResult, type index_GateController as GateController, type index_GateOptions as GateOptions, type index_LoopOptions as LoopOptions, type index_OrchestrationStepOptions as OrchestrationStepOptions, type index_SensorControls as SensorControls, type index_StepRef as StepRef, type index_SubPipelineBuilder as SubPipelineBuilder, index_approval as approval, index_branch as branch, index_gate as gate, index_join as join, index_loop as loop, index_onFailure as onFailure, index_pipeline as pipeline, index_sensor as sensor, index_subPipeline as subPipeline, index_task as task };
+}
+
+export { type ApprovalOptions as A, type BranchResult as B, type GateController as G, type LoopOptions as L, type OrchestrationStepOptions as O, type SensorControls as S, type GateOptions as a, type StepRef as b, type SubPipelineBuilder as c, approval as d, branch as e, subPipeline as f, gate as g, index as i, join as j, loop as l, onFailure as o, pipeline as p, sensor as s, task as t };

package/dist/{index-BaSM3aYt.d.ts → index-D-YB-Vl3.d.ts}

@@ -1,6 +1,6 @@
-import { s as Messages, A as Actor, C as COMPLETE, b as COMPLETE_MSG, c as COMPLETE_ONLY_BATCH, D as DATA, d as DEFAULT_ACTOR, e as DIRTY, f as DIRTY_MSG, g as DIRTY_ONLY_BATCH, h as DepRecord, E as ERROR, F as FnCtx, G as GlobalInspectorEvent, i as GlobalInspectorHook, j as GraphReFlyConfig, k as GuardAction, l as GuardDenied, m as GuardDeniedDetails, H as HashFn, I as INVALIDATE, n as INVALIDATE_MSG, o as INVALIDATE_ONLY_BATCH, M as Message, p as MessageContext, q as MessageTypeRegistration, r as MessageTypeRegistrationInput, N as Node, t as NodeActions, u as NodeCtx, v as NodeDescribeKind, w as NodeFn, x as NodeFnCleanup, y as NodeGuard, z as NodeImpl, B as NodeInspectorHook, J as NodeInspectorHookEvent, a as NodeOptions, K as NodeSink, L as NodeStatus, O as NodeTransportOptions, Q as NodeVersionInfo, R as OnMessageHandler, S as OnSubscribeHandler, T as PAUSE, U as PolicyAllow, V as PolicyDeny, P as PolicyRuleData, W as RESOLVED, X as RESOLVED_MSG, Y as RESOLVED_ONLY_BATCH, Z as RESUME, _ as START, $ as START_MSG, a0 as SubscribeContext, a1 as TEARDOWN, a2 as TEARDOWN_MSG, a3 as TEARDOWN_ONLY_BATCH, a4 as V0, a5 as V1, a6 as VersioningLevel, a7 as VersioningOptions, a8 as accessHintForGuard, a9 as advanceVersion, aa as configure, ab as createVersioning, ac as defaultConfig, ad as defaultHash, ae as isV1, af as node, ag as normalizeActor, ah as policy, ai as policyFromRules, aj as registerBuiltins } from './node-BmerH3kS.js';
-import { D as DescribeDetail, a as DescribeField, b as DescribeNodeOutput, r as resolveDescribeFields } from './meta-CbznRPYJ.js';
-import { A as AutoTrackOptions, D as DerivedFn, a as DynamicFn, E as EffectFn, P as PipeOperator, b as ProducerFn, T as TrackFn, c as autoTrackNode, d as derived, e as dynamicNode, f as effect, p as pipe, g as producer, s as state } from './sugar-CCOxXK1e.js';
+import { b as Messages, A as Actor, C as COMPLETE, f as COMPLETE_MSG, g as COMPLETE_ONLY_BATCH, D as DATA, h as DEFAULT_ACTOR, i as DIRTY, j as DIRTY_MSG, k as DIRTY_ONLY_BATCH, l as DepRecord, E as ERROR, F as FnCtx, m as GlobalInspectorEvent, n as GlobalInspectorHook, o as GraphReFlyConfig, G as GuardAction, p as GuardDenied, q as GuardDeniedDetails, H as HashFn, I as INVALIDATE, r as INVALIDATE_MSG, s as INVALIDATE_ONLY_BATCH, M as Message, t as MessageContext, u as MessageTypeRegistration, v as MessageTypeRegistrationInput, a as Node, c as NodeActions, w as NodeCtx, e as NodeDescribeKind, x as NodeFn, d as NodeFnCleanup, y as NodeGuard, z as NodeImpl, B as NodeInspectorHook, J as NodeInspectorHookEvent, N as NodeOptions, K as NodeSink, L as NodeStatus, O as NodeTransportOptions, Q as NodeVersionInfo, R as OnMessageHandler, S as OnSubscribeHandler, T as PAUSE, U as PolicyAllow, W as PolicyDeny, P as PolicyRuleData, X as RESOLVED, Y as RESOLVED_MSG, Z as RESOLVED_ONLY_BATCH, _ as RESUME, $ as START, a0 as START_MSG, a1 as SubscribeContext, a2 as TEARDOWN, a3 as TEARDOWN_MSG, a4 as TEARDOWN_ONLY_BATCH, a5 as V0, a6 as V1, V as VersioningLevel, a7 as VersioningOptions, a8 as accessHintForGuard, a9 as advanceVersion, aa as configure, ab as createVersioning, ac as defaultConfig, ad as defaultHash, ae as isV1, af as node, ag as normalizeActor, ah as policy, ai as policyFromRules, aj as registerBuiltins } from './node-Cc1TniY8.js';
+import { D as DescribeDetail, a as DescribeField, b as DescribeNodeOutput, r as resolveDescribeFields } from './meta-CwesDrMD.js';
+import { A as AutoTrackOptions, D as DerivedFn, a as DynamicFn, E as EffectFn, P as PipeOperator, b as ProducerFn, T as TrackFn, c as autoTrackNode, d as derived, e as dynamicNode, f as effect, p as pipe, g as producer, s as state } from './sugar-Dtyrq2_q.js';
 
 /**
  * Batch deferral for tier-3+ messages, plus per-node emit coalescing inside