footprintjs 9.4.0 → 9.5.0

package/dist/esm/lib/capture/envelope.js

@@ -0,0 +1,187 @@
+/**
+ * capture/envelope.ts — RFC-001 Block 1: capture envelopes + payload summarizer.
+ *
+ * Pattern:  Point-in-time capture. An observer event is snapshotted into a
+ *           self-contained, immutable envelope at the moment it happens, so
+ *           DELIVERY can be deferred (RFC-001 "one beat behind") without the
+ *           payload drifting under later engine mutations.
+ * Role:     The capture tier of the deferred-observer pipeline
+ *           (`src/lib/observer-queue/`). Pure module — ZERO engine imports
+ *           (only `capture/` internals); the engine wiring is RFC-001
+ *           Blocks 6–10.
+ *
+ * Capture policies (RFC-001 §5):
+ *   - `'summary'` — bounded, reference-free summarization via
+ *     {@link summarizePayload}. Built on the SAME classification path as the
+ *     retention markers in `summarize.ts` (#14 / #13c-A), extended with
+ *     bounded structural descent. Structured-clone-safe by construction.
+ *   - `'clone'`   — `structuredClone` at capture time (the capture-tier
+ *     spelling of retention `'full'` — see the mapping notes in
+ *     `policies.ts`). If the payload is not clonable (functions, symbols,
+ *     live handles), capture DEGRADES to `'summary'` and reports through the
+ *     `warn` hook — a capture must never throw into the producer.
+ *   - `'ref'`     — pass-through of the live reference. The CALLER asserts
+ *     immutability for the delivery window (safe e.g. for committed-state
+ *     reads, proven immutable-after-swap in #13/#13b). Exempt from the
+ *     clone-safety guarantee — see the dev-warn seam below.
+ *
+ * Dev-warn seam (resolves the isDevMode-would-be-an-engine-import problem):
+ *   This module must not import `scope/detectCircular` (engine territory).
+ *   Instead, `capture()` accepts {@link CaptureHooks} with an optional
+ *   `warn` callback and invokes it on every `'ref'` capture and every
+ *   `'clone'` degradation. The WIRING layer (Block 6) binds `warn` to an
+ *   `isDevMode()`-gated, deduplicated console warner; the pure module stays
+ *   engine-free and silent by default (no hooks ⇒ no warning, zero cost).
+ *
+ * Summarizer bounds (documented contract, exported as constants):
+ *   - depth   ≤ {@link PAYLOAD_SUMMARY_MAX_DEPTH}   (3) — deeper structure
+ *     collapses to a classified leaf with `depthClipped: true`.
+ *   - breadth ≤ {@link PAYLOAD_SUMMARY_MAX_ENTRIES} (16) per object/array —
+ *     the remainder is dropped and flagged `truncated: true` (the honest
+ *     `size` still reports the real count).
+ *   - total   ≤ {@link PAYLOAD_SUMMARY_MAX_NODES}   (128) summary nodes per
+ *     payload — a global budget so wide×deep payloads stay O(1)-bounded.
+ *   - string previews ≤ `SUMMARY_PREVIEW_LENGTH` (80) chars.
+ *   Cycles are detected (ancestor set) and flagged `circular: true`;
+ *   throwing getters yield a `'unreadable'` leaf; symbol-keyed properties
+ *   are ignored (same as JSON / `Object.keys`); `Map`/`Set` are leaves with
+ *   their REAL entry count (no descent — matches `summarize.ts`).
+ */
+import { summarizeWriteValue } from './summarize.js';
+/** Max nesting depth a payload summary descends before clipping. */
+export const PAYLOAD_SUMMARY_MAX_DEPTH = 3;
+/** Max entries summarized per object/array level before truncating. */
+export const PAYLOAD_SUMMARY_MAX_ENTRIES = 16;
+/** Global per-payload budget of summary nodes (wide×deep hard bound). */
+export const PAYLOAD_SUMMARY_MAX_NODES = 128;
+/**
+ * Classify one value through the ONE classification path shared with the
+ * retention markers. GATE NOTE: Block 1 may not modify `summarize.ts`, so
+ * the module-private `classifyValue` is reached through its exported facade
+ * and the brand field is dropped by explicit copy — Block 6 may export
+ * `classifyValue` directly and inline this hop.
+ */
+function classifyLeaf(value) {
+    const marker = summarizeWriteValue(value);
+    const leaf = { type: marker.type };
+    if (marker.size !== undefined)
+        leaf.size = marker.size;
+    if (marker.preview !== undefined)
+        leaf.preview = marker.preview;
+    return leaf;
+}
+/** Read one child property, converting throwing getters into a leaf. */
+function summarizeChild(parent, key, depth, budget, ancestors) {
+    let child;
+    try {
+        child = parent[key];
+    }
+    catch {
+        return { type: 'unreadable', preview: '[getter threw during capture]' };
+    }
+    return summarizeNode(child, depth, budget, ancestors);
+}
+function summarizeNode(value, depth, budget, ancestors) {
+    budget.nodesLeft -= 1;
+    const leaf = classifyLeaf(value);
+    // Only plain containers descend. Map/Set stay leaves (real entry count
+    // already on `size` — matches summarize.ts); everything else is a leaf.
+    const container = (leaf.type === 'object' || leaf.type === 'array') && typeof value === 'object' && value !== null;
+    if (!container || value instanceof Map || value instanceof Set)
+        return leaf;
+    const obj = value;
+    if (ancestors.has(obj))
+        return { ...leaf, circular: true };
+    if (depth >= PAYLOAD_SUMMARY_MAX_DEPTH)
+        return { ...leaf, depthClipped: true };
+    if (budget.nodesLeft <= 0)
+        return { ...leaf, truncated: true };
+    ancestors.add(obj);
+    try {
+        if (Array.isArray(value)) {
+            const limit = Math.min(value.length, PAYLOAD_SUMMARY_MAX_ENTRIES);
+            const items = [];
+            let clipped = value.length > limit;
+            for (let i = 0; i < limit; i++) {
+                if (budget.nodesLeft <= 0) {
+                    clipped = true;
+                    break;
+                }
+                items.push(summarizeChild(value, i, depth + 1, budget, ancestors));
+            }
+            return clipped ? { ...leaf, items, truncated: true } : { ...leaf, items };
+        }
+        const keys = Object.keys(obj);
+        const limit = Math.min(keys.length, PAYLOAD_SUMMARY_MAX_ENTRIES);
+        // Built via entries + fromEntries so hostile keys ('__proto__', ...)
+        // become own data properties — never prototype writes.
+        const entries = [];
+        let clipped = keys.length > limit;
+        for (let i = 0; i < limit; i++) {
+            if (budget.nodesLeft <= 0) {
+                clipped = true;
+                break;
+            }
+            entries.push([keys[i], summarizeChild(obj, keys[i], depth + 1, budget, ancestors)]);
+        }
+        const fields = Object.fromEntries(entries);
+        return clipped ? { ...leaf, fields, truncated: true } : { ...leaf, fields };
+    }
+    finally {
+        ancestors.delete(obj);
+    }
+}
+/**
+ * Produce a bounded, reference-free, structured-clone-safe summary of an
+ * arbitrary payload. Never throws; never holds a reference into the source
+ * value (every node is a fresh object whose fields are primitives). Bounds
+ * are documented in the module header.
+ */
+export function summarizePayload(payload) {
+    const budget = { nodesLeft: PAYLOAD_SUMMARY_MAX_NODES };
+    const root = summarizeNode(payload, 0, budget, new Set());
+    return { __payloadSummary: true, ...root };
+}
+/** Materialize the payload per policy — see the module header contract. */
+function capturePayload(request, policy, hooks) {
+    if (policy === 'ref') {
+        hooks?.warn?.(`[footprintjs capture] 'ref' capture for ${request.channel}.${request.method} passes a LIVE reference ` +
+            'through deferred delivery — the caller asserts the payload is immutable until delivered.');
+        return request.payload;
+    }
+    if (policy === 'clone') {
+        try {
+            return structuredClone(request.payload);
+        }
+        catch {
+            hooks?.warn?.(`[footprintjs capture] 'clone' capture for ${request.channel}.${request.method} failed ` +
+                "(structuredClone threw — unclonable payload); degraded to 'summary'.");
+            return summarizePayload(request.payload);
+        }
+    }
+    return summarizePayload(request.payload);
+}
+/**
+ * Capture one observer event into an immutable {@link CaptureEnvelope}.
+ *
+ * Guarantees:
+ *   - Never throws into the producer (`'clone'` degradation, summarizer
+ *     never-throws contract).
+ *   - The returned envelope is shallow-frozen — `seq`/`channel`/... cannot
+ *     be reassigned. Under `'summary'`/`'clone'` the payload holds no live
+ *     reference into the source; under `'ref'` it intentionally does.
+ *   - Default policy is `'summary'` (cheapest safe tier).
+ */
+export function capture(request, policy = 'summary', hooks) {
+    const capturedAt = hooks?.now !== undefined ? hooks.now() : Date.now();
+    return Object.freeze({
+        seq: request.seq,
+        channel: request.channel,
+        method: request.method,
+        runtimeStageId: request.runtimeStageId,
+        runId: request.runId,
+        payload: capturePayload(request, policy, hooks),
+        capturedAt,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"envelope.js","sourceRoot":"","sources":["../../../../src/lib/capture/envelope.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * capture/envelope.ts — RFC-001 Block 1: capture envelopes + payload summarizer.\n *\n * Pattern:  Point-in-time capture. An observer event is snapshotted into a\n *           self-contained, immutable envelope at the moment it happens, so\n *           DELIVERY can be deferred (RFC-001 \"one beat behind\") without the\n *           payload drifting under later engine mutations.\n * Role:     The capture tier of the deferred-observer pipeline\n *           (`src/lib/observer-queue/`). Pure module — ZERO engine imports\n *           (only `capture/` internals); the engine wiring is RFC-001\n *           Blocks 6–10.\n *\n * Capture policies (RFC-001 §5):\n *   - `'summary'` — bounded, reference-free summarization via\n *     {@link summarizePayload}. Built on the SAME classification path as the\n *     retention markers in `summarize.ts` (#14 / #13c-A), extended with\n *     bounded structural descent. Structured-clone-safe by construction.\n *   - `'clone'`   — `structuredClone` at capture time (the capture-tier\n *     spelling of retention `'full'` — see the mapping notes in\n *     `policies.ts`). If the payload is not clonable (functions, symbols,\n *     live handles), capture DEGRADES to `'summary'` and reports through the\n *     `warn` hook — a capture must never throw into the producer.\n *   - `'ref'`     — pass-through of the live reference. The CALLER asserts\n *     immutability for the delivery window (safe e.g. for committed-state\n *     reads, proven immutable-after-swap in #13/#13b). Exempt from the\n *     clone-safety guarantee — see the dev-warn seam below.\n *\n * Dev-warn seam (resolves the isDevMode-would-be-an-engine-import problem):\n *   This module must not import `scope/detectCircular` (engine territory).\n *   Instead, `capture()` accepts {@link CaptureHooks} with an optional\n *   `warn` callback and invokes it on every `'ref'` capture and every\n *   `'clone'` degradation. The WIRING layer (Block 6) binds `warn` to an\n *   `isDevMode()`-gated, deduplicated console warner; the pure module stays\n *   engine-free and silent by default (no hooks ⇒ no warning, zero cost).\n *\n * Summarizer bounds (documented contract, exported as constants):\n *   - depth   ≤ {@link PAYLOAD_SUMMARY_MAX_DEPTH}   (3) — deeper structure\n *     collapses to a classified leaf with `depthClipped: true`.\n *   - breadth ≤ {@link PAYLOAD_SUMMARY_MAX_ENTRIES} (16) per object/array —\n *     the remainder is dropped and flagged `truncated: true` (the honest\n *     `size` still reports the real count).\n *   - total   ≤ {@link PAYLOAD_SUMMARY_MAX_NODES}   (128) summary nodes per\n *     payload — a global budget so wide×deep payloads stay O(1)-bounded.\n *   - string previews ≤ `SUMMARY_PREVIEW_LENGTH` (80) chars.\n *   Cycles are detected (ancestor set) and flagged `circular: true`;\n *   throwing getters yield a `'unreadable'` leaf; symbol-keyed properties\n *   are ignored (same as JSON / `Object.keys`); `Map`/`Set` are leaves with\n *   their REAL entry count (no descent — matches `summarize.ts`).\n */\n\nimport { type SummaryValueType, summarizeWriteValue } from './summarize.js';\n\n/** Which observer channel produced a captured event (RFC-001 §5). */\nexport type CaptureChannel = 'scope' | 'flow' | 'emit';\n\n/**\n * How an event payload is materialized into the envelope (RFC-001 §5).\n * See the module header for the full per-policy contract.\n */\nexport type CapturePolicy = 'summary' | 'clone' | 'ref';\n\n/**\n * A captured observer event — self-contained and immutable (shallow-frozen\n * at creation). `seq` is the arrival stamp assigned at capture under the\n * single JS thread: it totally orders events ACROSS all three channels, is\n * monotonic, and is gap-detectable (a dropped event leaves a visible hole\n * in the delivered `seq` sequence — honest loss accounting).\n */\nexport interface CaptureEnvelope {\n  /** Arrival stamp — total order across channels; gaps reveal drops. */\n  readonly seq: number;\n  /** Producing observer channel. */\n  readonly channel: CaptureChannel;\n  /** Producing hook name — `'onWrite'`, `'onStageExecuted'`, `'onEmit'`, ... */\n  readonly method: string;\n  /** The execution step that produced the event (`stageId#executionIndex`). */\n  readonly runtimeStageId: string;\n  /** The run that produced the event (Convention 4 per-run scoping). */\n  readonly runId: string;\n  /**\n   * Per {@link CapturePolicy} — NEVER a live engine reference under\n   * `'summary'` / `'clone'`; under `'ref'` the caller asserted immutability.\n   */\n  readonly payload: unknown;\n  /** Capture wall-clock (ms epoch by default; injectable via hooks.now). */\n  readonly capturedAt: number;\n}\n\n/** The raw event description handed to {@link capture}. */\nexport interface CaptureRequest {\n  /** Arrival stamp — assigned by the merged queue's counter (Block 3). */\n  readonly seq: number;\n  readonly channel: CaptureChannel;\n  readonly method: string;\n  readonly runtimeStageId: string;\n  readonly runId: string;\n  /** The LIVE payload — `capture()` materializes it per policy. */\n  readonly payload: unknown;\n}\n\n/**\n * Engine-free seams injected by the wiring layer (Block 6). The pure module\n * never imports dev-mode or clock infrastructure.\n */\nexport interface CaptureHooks {\n  /**\n   * Diagnostic sink — invoked on every `'ref'` capture (caller-asserted\n   * immutability) and every `'clone'` → `'summary'` degradation. Block 6\n   * binds this to an `isDevMode()`-gated, deduplicated warner.\n   */\n  readonly warn?: (message: string) => void;\n  /** Clock for `capturedAt` — defaults to `Date.now`. Injectable for tests. */\n  readonly now?: () => number;\n}\n\n/** Max nesting depth a payload summary descends before clipping. */\nexport const PAYLOAD_SUMMARY_MAX_DEPTH = 3;\n\n/** Max entries summarized per object/array level before truncating. */\nexport const PAYLOAD_SUMMARY_MAX_ENTRIES = 16;\n\n/** Global per-payload budget of summary nodes (wide×deep hard bound). */\nexport const PAYLOAD_SUMMARY_MAX_NODES = 128;\n\n/**\n * Leaf classification for a summary node — the `summarize.ts` family plus\n * `'unreadable'` for properties whose getter threw during capture.\n */\nexport type PayloadSummaryType = SummaryValueType | 'unreadable';\n\n/**\n * One node of a payload summary tree. Every field is a primitive, a plain\n * object, or a plain array — structured-clone-safe by construction.\n */\nexport interface PayloadSummaryNode {\n  /** Classification — same rules as the retention markers (one code path). */\n  readonly type: PayloadSummaryType;\n  /** Honest size proxy: string length, array length, or key/entry count. */\n  readonly size?: number;\n  /** First `SUMMARY_PREVIEW_LENGTH` chars — primitives/strings only. */\n  readonly preview?: string;\n  /** Summarized own enumerable string-keyed properties (objects). */\n  readonly fields?: Readonly<Record<string, PayloadSummaryNode>>;\n  /** Summarized leading items (arrays). */\n  readonly items?: readonly PayloadSummaryNode[];\n  /** Entries were omitted here (breadth cap or node budget). */\n  readonly truncated?: boolean;\n  /** This value is an ancestor of itself — descent stopped. */\n  readonly circular?: true;\n  /** {@link PAYLOAD_SUMMARY_MAX_DEPTH} reached — children not descended. */\n  readonly depthClipped?: true;\n}\n\n/**\n * Root of a payload summary — branded so consumers (and tests) can detect\n * that a payload was summarized rather than cloned. Sibling of the\n * `__readSummary` / `__writeSummary` retention markers.\n */\nexport interface PayloadSummary extends PayloadSummaryNode {\n  /** Discriminant — `'summary'`-policy envelope payloads carry this. */\n  readonly __payloadSummary: true;\n}\n\n/** Mutable construction shape for {@link PayloadSummaryNode}. */\ninterface SummaryNodeDraft {\n  type: PayloadSummaryType;\n  size?: number;\n  preview?: string;\n  fields?: Record<string, PayloadSummaryNode>;\n  items?: PayloadSummaryNode[];\n  truncated?: boolean;\n  circular?: true;\n  depthClipped?: true;\n}\n\n/** Shared mutable node budget for one {@link summarizePayload} call. */\ninterface SummarizeBudget {\n  nodesLeft: number;\n}\n\n/**\n * Classify one value through the ONE classification path shared with the\n * retention markers. GATE NOTE: Block 1 may not modify `summarize.ts`, so\n * the module-private `classifyValue` is reached through its exported facade\n * and the brand field is dropped by explicit copy — Block 6 may export\n * `classifyValue` directly and inline this hop.\n */\nfunction classifyLeaf(value: unknown): SummaryNodeDraft {\n  const marker = summarizeWriteValue(value);\n  const leaf: SummaryNodeDraft = { type: marker.type };\n  if (marker.size !== undefined) leaf.size = marker.size;\n  if (marker.preview !== undefined) leaf.preview = marker.preview;\n  return leaf;\n}\n\n/** Read one child property, converting throwing getters into a leaf. */\nfunction summarizeChild(\n  parent: object,\n  key: string | number,\n  depth: number,\n  budget: SummarizeBudget,\n  ancestors: Set<object>,\n): PayloadSummaryNode {\n  let child: unknown;\n  try {\n    child = (parent as Record<string | number, unknown>)[key];\n  } catch {\n    return { type: 'unreadable', preview: '[getter threw during capture]' };\n  }\n  return summarizeNode(child, depth, budget, ancestors);\n}\n\nfunction summarizeNode(\n  value: unknown,\n  depth: number,\n  budget: SummarizeBudget,\n  ancestors: Set<object>,\n): PayloadSummaryNode {\n  budget.nodesLeft -= 1;\n  const leaf = classifyLeaf(value);\n\n  // Only plain containers descend. Map/Set stay leaves (real entry count\n  // already on `size` — matches summarize.ts); everything else is a leaf.\n  const container = (leaf.type === 'object' || leaf.type === 'array') && typeof value === 'object' && value !== null;\n  if (!container || value instanceof Map || value instanceof Set) return leaf;\n\n  const obj = value as object;\n  if (ancestors.has(obj)) return { ...leaf, circular: true };\n  if (depth >= PAYLOAD_SUMMARY_MAX_DEPTH) return { ...leaf, depthClipped: true };\n  if (budget.nodesLeft <= 0) return { ...leaf, truncated: true };\n\n  ancestors.add(obj);\n  try {\n    if (Array.isArray(value)) {\n      const limit = Math.min(value.length, PAYLOAD_SUMMARY_MAX_ENTRIES);\n      const items: PayloadSummaryNode[] = [];\n      let clipped = value.length > limit;\n      for (let i = 0; i < limit; i++) {\n        if (budget.nodesLeft <= 0) {\n          clipped = true;\n          break;\n        }\n        items.push(summarizeChild(value, i, depth + 1, budget, ancestors));\n      }\n      return clipped ? { ...leaf, items, truncated: true } : { ...leaf, items };\n    }\n\n    const keys = Object.keys(obj);\n    const limit = Math.min(keys.length, PAYLOAD_SUMMARY_MAX_ENTRIES);\n    // Built via entries + fromEntries so hostile keys ('__proto__', ...)\n    // become own data properties — never prototype writes.\n    const entries: Array<[string, PayloadSummaryNode]> = [];\n    let clipped = keys.length > limit;\n    for (let i = 0; i < limit; i++) {\n      if (budget.nodesLeft <= 0) {\n        clipped = true;\n        break;\n      }\n      entries.push([keys[i], summarizeChild(obj, keys[i], depth + 1, budget, ancestors)]);\n    }\n    const fields = Object.fromEntries(entries);\n    return clipped ? { ...leaf, fields, truncated: true } : { ...leaf, fields };\n  } finally {\n    ancestors.delete(obj);\n  }\n}\n\n/**\n * Produce a bounded, reference-free, structured-clone-safe summary of an\n * arbitrary payload. Never throws; never holds a reference into the source\n * value (every node is a fresh object whose fields are primitives). Bounds\n * are documented in the module header.\n */\nexport function summarizePayload(payload: unknown): PayloadSummary {\n  const budget: SummarizeBudget = { nodesLeft: PAYLOAD_SUMMARY_MAX_NODES };\n  const root = summarizeNode(payload, 0, budget, new Set<object>());\n  return { __payloadSummary: true, ...root };\n}\n\n/** Materialize the payload per policy — see the module header contract. */\nfunction capturePayload(request: CaptureRequest, policy: CapturePolicy, hooks?: CaptureHooks): unknown {\n  if (policy === 'ref') {\n    hooks?.warn?.(\n      `[footprintjs capture] 'ref' capture for ${request.channel}.${request.method} passes a LIVE reference ` +\n        'through deferred delivery — the caller asserts the payload is immutable until delivered.',\n    );\n    return request.payload;\n  }\n  if (policy === 'clone') {\n    try {\n      return structuredClone(request.payload);\n    } catch {\n      hooks?.warn?.(\n        `[footprintjs capture] 'clone' capture for ${request.channel}.${request.method} failed ` +\n          \"(structuredClone threw — unclonable payload); degraded to 'summary'.\",\n      );\n      return summarizePayload(request.payload);\n    }\n  }\n  return summarizePayload(request.payload);\n}\n\n/**\n * Capture one observer event into an immutable {@link CaptureEnvelope}.\n *\n * Guarantees:\n *   - Never throws into the producer (`'clone'` degradation, summarizer\n *     never-throws contract).\n *   - The returned envelope is shallow-frozen — `seq`/`channel`/... cannot\n *     be reassigned. Under `'summary'`/`'clone'` the payload holds no live\n *     reference into the source; under `'ref'` it intentionally does.\n *   - Default policy is `'summary'` (cheapest safe tier).\n */\nexport function capture(\n  request: CaptureRequest,\n  policy: CapturePolicy = 'summary',\n  hooks?: CaptureHooks,\n): CaptureEnvelope {\n  const capturedAt = hooks?.now !== undefined ? hooks.now() : Date.now();\n  return Object.freeze({\n    seq: request.seq,\n    channel: request.channel,\n    method: request.method,\n    runtimeStageId: request.runtimeStageId,\n    runId: request.runId,\n    payload: capturePayload(request, policy, hooks),\n    capturedAt,\n  });\n}\n"]}

package/dist/esm/lib/engine/handlers/ContinuationResolver.js

@@ -27,6 +27,18 @@ export class ContinuationResolver {
      * Key: node.id, Value: visit count (0 = first visit).
      */
     iterationCounters = new Map();
+    /**
+     * Total fn-bearing dynamic-next hops this traverser has followed.
+     *
+     * Fresh fn-bearing nodes bypass the per-node-id iteration counter (they
+     * are new nodes, often without stable ids — there is no back-edge to
+     * count). Without a bound, a stage that keeps returning a function-bearing
+     * dynamic `next` runs FOREVER on the flat trampoline (no stack overflow
+     * brakes it either). This run-total counter puts such chains under the
+     * same `maxIterations` budget (default 1000, tuned via
+     * `RunOptions.maxIterations`) that bounds loop edges.
+     */
+    dynamicNextHops = 0;
     onIterationUpdate;
     maxIterations;
     constructor(deps, nodeResolver, onIterationUpdate, maxIterations) {
@@ -52,14 +64,21 @@ export class ContinuationResolver {
      * `onLoop` narrative), in the same order.
      *
      * Three dynamicNext patterns:
-     * - StageNode with fn → truly dynamic node, returned as-is (no iteration
-     *   tracking — it is a fresh node, not a back-edge).
+     * - StageNode with fn → truly dynamic node, returned as-is (no per-node
+     *   iteration tracking — it is a fresh node, not a back-edge — but the
+     *   run-total dynamic-hop budget applies; see `dynamicNextHops`).
      * - String ID → reference to an existing node, resolved via NodeResolver.
      * - StageNode without fn → reference by ID, resolved via NodeResolver.
      */
     resolveTarget(dynamicNext, currentNode, context, branchPath, traversalContext) {
-        // Truly dynamic node (has fn) → execute directly, no iteration tracking.
+        // Truly dynamic node (has fn) → execute directly, no per-node iteration
+        // tracking (fresh node, not a back-edge) — but the CHAIN of such hops is
+        // bounded by the run-total guard below, mirroring the loop budget.
         if (typeof dynamicNext !== 'string' && dynamicNext.fn) {
+            if (this.dynamicNextHops >= this.maxIterations) {
+                throw new Error(`Maximum dynamic-next continuations (${this.maxIterations}) exceeded at stage '${currentNode.id ?? currentNode.name}' ` + `(dynamic target '${dynamicNext.name}'). Set maxIterations to increase the limit.`);
+            }
+            this.dynamicNextHops++;
             context.addLog('dynamicNextDirect', true);
             context.addLog('dynamicNextName', dynamicNext.name);
             context.addFlowDebugMessage('next', `Moving to ${dynamicNext.name} stage (dynamic)`, {
@@ -120,4 +139,4 @@ export class ContinuationResolver {
         return iteration === 0 ? baseName : `${baseName}.${iteration}`;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ContinuationResolver.js","sourceRoot":"","sources":["../../../../../src/lib/engine/handlers/ContinuationResolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AASH,MAAM,CAAC,MAAM,sBAAsB,GAAG,IAAI,CAAC;AAa3C,MAAM,OAAO,oBAAoB;IAWZ;IACA;IAXnB;;;OAGG;IACK,iBAAiB,GAAwB,IAAI,GAAG,EAAE,CAAC;IAE1C,iBAAiB,CAA2C;IAC5D,aAAa,CAAS;IAEvC,YACmB,IAA+B,EAC/B,YAAwC,EACzD,iBAA2D,EAC3D,aAAsB;QAHL,SAAI,GAAJ,IAAI,CAA2B;QAC/B,iBAAY,GAAZ,YAAY,CAA4B;QAIzD,IAAI,CAAC,iBAAiB,GAAG,iBAAiB,CAAC;QAC3C,IAAI,CAAC,aAAa,GAAG,aAAa,IAAI,sBAAsB,CAAC;IAC/D,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,OAAO,CACX,WAA6C,EAC7C,IAA6B,EAC7B,OAAqB,EACrB,SAAmC,EACnC,UAA8B,EAC9B,WAAwC,EACxC,gBAAmC;QAEnC,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,WAAW,EAAE,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,gBAAgB,CAAC,CAAC;QAC5F,OAAO,WAAW,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,OAAO,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;IACzE,CAAC;IAED;;;;;;;;;;;OAWG;IACH,aAAa,CACX,WAA6C,EAC7C,WAAoC,EACpC,OAAqB,EACrB,UAA8B,EAC9B,gBAAmC;QAEnC,yEAAyE;QACzE,IAAI,OAAO,WAAW,KAAK,QAAQ,IAAI,WAAW,CAAC,EAAE,EAAE,CAAC;YACtD,OAAO,CAAC,MAAM,CAAC,mBAAmB,EAAE,IAAI,CAAC,CAAC;YAC1C,OAAO,CAAC,MAAM,CAAC,iBAAiB,EAAE,WAAW,CAAC,IAAI,CAAC,CAAC;YAEpD,OAAO,CAAC,mBAAmB,CAAC,MAAM,EAAE,aAAa,WAAW,CAAC,IAAI,kBAAkB,EAAE;gBACnF,WAAW,EAAE,WAAW,CAAC,IAAI;aAC9B,CAAC,CAAC;YAEH,MAAM,gBAAgB,GAAG,OAAO,CAAC,UAAU,CAAC,UAAoB,EAAE,WAAW,CAAC,IAAI,EAAE,WAAW,CAAC,EAAE,CAAC,CAAC;YACpG,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,gBAAgB,EAAE,CAAC;QAC1D,CAAC;QAED,sEAAsE;QACtE,uEAAuE;QACvE,sEAAsE;QACtE,IAAI,OAAO,WAAW,KAAK,QAAQ,IAAI,CAAC,WAAW,CAAC,EAAE,EAAE,CAAC;YACvD,MAAM,YAAY,GAAG,yDAAyD,CAAC;YAC/E,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,sBAAsB,UAAU,YAAY,WAAW,CAAC,IAAI,IAAI,EAAE,EAAE,KAAK,EAAE,YAAY,EAAE,CAAC,CAAC;YAClH,MAAM,IAAI,KAAK,CAAC,YAAY,CAAC,CAAC;QAChC,CAAC;QACD,MAAM,UAAU,GAAG,OAAO,WAAW,KAAK,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,WAAW,CAAC,EAAG,CAAC;QAEnF,MAAM,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;QAC9D,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,MAAM,YAAY,GAAG,sCAAsC,UAAU,EAAE,CAAC;YACxE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,sBAAsB,UAAU,YAAY,WAAW,CAAC,IAAI,IAAI,EAAE,EAAE,KAAK,EAAE,YAAY,EAAE,CAAC,CAAC;YAClH,MAAM,IAAI,KAAK,CAAC,YAAY,CAAC,CAAC;QAChC,CAAC;QAED,MAAM,SAAS,GAAG,IAAI,CAAC,wBAAwB,CAAC,UAAU,CAAC,CAAC;QAC5D,MAAM,iBAAiB,GAAG,IAAI,CAAC,oBAAoB,CAAC,UAAU,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;QAChF,OAAO,CAAC,MAAM,CAAC,mBAAmB,EAAE,UAAU,CAAC,CAAC;QAChD,OAAO,CAAC,MAAM,CAAC,sBAAsB,EAAE,SAAS,CAAC,CAAC;QAElD,OAAO,CAAC,mBAAmB,CAAC,MAAM,EAAE,mBAAmB,UAAU,CAAC,IAAI,eAAe,SAAS,GAAG,CAAC,GAAG,EAAE;YACrG,WAAW,EAAE,UAAU,CAAC,IAAI;YAC5B,SAAS,EAAE,SAAS,GAAG,CAAC;SACzB,CAAC,CAAC;QAEH,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,SAAS,GAAG,CAAC,EAAE,UAAU,CAAC,WAAW,EAAE,gBAAgB,CAAC,CAAC;QAE9G,MAAM,gBAAgB,GAAG,OAAO,CAAC,UAAU,CAAC,UAAoB,EAAE,iBAAiB,EAAE,UAAU,CAAC,EAAE,CAAC,CAAC;QACpG,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,gBAAgB,EAAE,CAAC;IACzD,CAAC;IAED;;;;OAIG;IACH,wBAAwB,CAAC,MAAc;QACrC,MAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACxD,IAAI,OAAO,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YAClC,MAAM,IAAI,KAAK,CACb,4BAA4B,IAAI,CAAC,aAAa,wBAAwB,MAAM,KAAK;gBAC/E,0CAA0C,CAC7C,CAAC;QACJ,CAAC;QACD,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,MAAM,EAAE,OAAO,GAAG,CAAC,CAAC,CAAC;QAEhD,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAC3B,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,OAAO,GAAG,CAAC,CAAC,CAAC;QAC9C,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;;OAGG;IACH,oBAAoB,CAAC,QAAgB,EAAE,SAAiB;QACtD,OAAO,SAAS,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,IAAI,SAAS,EAAE,CAAC;IACjE,CAAC;CACF","sourcesContent":["/**\n * ContinuationResolver — Back-edge resolution + iteration counting.\n *\n * Resolves dynamic continuations (loop-backs, dynamic next) and tracks\n * per-node iteration counts for context tree naming.\n *\n * Supports three dynamicNext patterns:\n * - String ID → reference to existing node (resolve via NodeResolver)\n * - StageNode with fn → truly dynamic node (execute directly)\n * - StageNode without fn → reference by ID (resolve via NodeResolver)\n *\n * Two entry points:\n * - `resolveTarget` — resolves the continuation to `{ node, context }` and\n *   fires every side effect (iteration counting, debug logs, `onLoop`\n *   narrative) WITHOUT executing. The traverser's trampoline driver uses\n *   this to follow loop edges iteratively — flat stack, so the iteration\n *   limit (not call-stack depth) is what bounds a loop.\n * - `resolve` — resolveTarget + immediate execution via the provided\n *   `executeNode` callback. Kept for direct/advanced callers.\n */\n\nimport type { StageContext } from '../../memory/StageContext.js';\nimport type { StageNode } from '../graph/StageNode.js';\nimport type { TraversalContext } from '../narrative/types.js';\nimport type { HandlerDeps } from '../types.js';\nimport type { NodeResolver } from './NodeResolver.js';\nimport type { ExecuteNodeFn } from './types.js';\n\nexport const DEFAULT_MAX_ITERATIONS = 1000;\n\n/**\n * A resolved continuation target — the node to execute next plus the\n * StageContext to execute it in. All side effects (iteration counting,\n * debug logs, `onLoop` narrative) have already fired by the time this\n * is returned.\n */\nexport interface ResolvedContinuation<TOut = any, TScope = any> {\n  node: StageNode<TOut, TScope>;\n  context: StageContext;\n}\n\nexport class ContinuationResolver<TOut = any, TScope = any> {\n  /**\n   * Iteration counter per node ID.\n   * Key: node.id, Value: visit count (0 = first visit).\n   */\n  private iterationCounters: Map<string, number> = new Map();\n\n  private readonly onIterationUpdate?: (nodeId: string, count: number) => void;\n  private readonly maxIterations: number;\n\n  constructor(\n    private readonly deps: HandlerDeps<TOut, TScope>,\n    private readonly nodeResolver: NodeResolver<TOut, TScope>,\n    onIterationUpdate?: (nodeId: string, count: number) => void,\n    maxIterations?: number,\n  ) {\n    this.onIterationUpdate = onIterationUpdate;\n    this.maxIterations = maxIterations ?? DEFAULT_MAX_ITERATIONS;\n  }\n\n  /**\n   * Resolve a dynamic continuation and execute it immediately.\n   * Equivalent to `executeNode(...resolveTarget(...))` — the traverser's\n   * driver loop calls `resolveTarget` directly instead so the continuation\n   * becomes a flat trampoline hop rather than a retained recursive frame.\n   */\n  async resolve(\n    dynamicNext: string | StageNode<TOut, TScope>,\n    node: StageNode<TOut, TScope>,\n    context: StageContext,\n    breakFlag: { shouldBreak: boolean },\n    branchPath: string | undefined,\n    executeNode: ExecuteNodeFn<TOut, TScope>,\n    traversalContext?: TraversalContext,\n  ): Promise<any> {\n    const target = this.resolveTarget(dynamicNext, node, context, branchPath, traversalContext);\n    return executeNode(target.node, target.context, breakFlag, branchPath);\n  }\n\n  /**\n   * Resolve a dynamic continuation to its target node + next StageContext\n   * WITHOUT executing it. Fires the same side effects `resolve` always did\n   * (iteration counting + limit, `dynamicNext*` logs, loop debug message,\n   * `onLoop` narrative), in the same order.\n   *\n   * Three dynamicNext patterns:\n   * - StageNode with fn → truly dynamic node, returned as-is (no iteration\n   *   tracking — it is a fresh node, not a back-edge).\n   * - String ID → reference to an existing node, resolved via NodeResolver.\n   * - StageNode without fn → reference by ID, resolved via NodeResolver.\n   */\n  resolveTarget(\n    dynamicNext: string | StageNode<TOut, TScope>,\n    currentNode: StageNode<TOut, TScope>,\n    context: StageContext,\n    branchPath: string | undefined,\n    traversalContext?: TraversalContext,\n  ): ResolvedContinuation<TOut, TScope> {\n    // Truly dynamic node (has fn) → execute directly, no iteration tracking.\n    if (typeof dynamicNext !== 'string' && dynamicNext.fn) {\n      context.addLog('dynamicNextDirect', true);\n      context.addLog('dynamicNextName', dynamicNext.name);\n\n      context.addFlowDebugMessage('next', `Moving to ${dynamicNext.name} stage (dynamic)`, {\n        targetStage: dynamicNext.name,\n      });\n\n      const nextStageContext = context.createNext(branchPath as string, dynamicNext.name, dynamicNext.id);\n      return { node: dynamicNext, context: nextStageContext };\n    }\n\n    // Reference — by string ID or by node-without-fn ID. A node reference\n    // without an id is a usage error; a string reference is passed through\n    // verbatim (an unknown id surfaces as \"target node not found\" below).\n    if (typeof dynamicNext !== 'string' && !dynamicNext.id) {\n      const errorMessage = 'dynamicNext node must have an id when used as reference';\n      this.deps.logger.error(`Error in pipeline (${branchPath}) stage [${currentNode.name}]:`, { error: errorMessage });\n      throw new Error(errorMessage);\n    }\n    const nextNodeId = typeof dynamicNext === 'string' ? dynamicNext : dynamicNext.id!;\n\n    const targetNode = this.nodeResolver.findNodeById(nextNodeId);\n    if (!targetNode) {\n      const errorMessage = `dynamicNext target node not found: ${nextNodeId}`;\n      this.deps.logger.error(`Error in pipeline (${branchPath}) stage [${currentNode.name}]:`, { error: errorMessage });\n      throw new Error(errorMessage);\n    }\n\n    const iteration = this.getAndIncrementIteration(nextNodeId);\n    const iteratedStageName = this.getIteratedStageName(targetNode.name, iteration);\n    context.addLog('dynamicNextTarget', nextNodeId);\n    context.addLog('dynamicNextIteration', iteration);\n\n    context.addFlowDebugMessage('loop', `Looping back to ${targetNode.name} (iteration ${iteration + 1})`, {\n      targetStage: targetNode.name,\n      iteration: iteration + 1,\n    });\n\n    this.deps.narrativeGenerator.onLoop(targetNode.name, iteration + 1, targetNode.description, traversalContext);\n\n    const nextStageContext = context.createNext(branchPath as string, iteratedStageName, targetNode.id);\n    return { node: targetNode, context: nextStageContext };\n  }\n\n  /**\n   * Get the next iteration number for a node and increment.\n   * Returns 0 for first visit, 1 for second, etc.\n   * Throws if maxIterations exceeded (infinite loop guard).\n   */\n  getAndIncrementIteration(nodeId: string): number {\n    const current = this.iterationCounters.get(nodeId) ?? 0;\n    if (current >= this.maxIterations) {\n      throw new Error(\n        `Maximum loop iterations (${this.maxIterations}) exceeded for node '${nodeId}'. ` +\n          'Set maxIterations to increase the limit.',\n      );\n    }\n    this.iterationCounters.set(nodeId, current + 1);\n\n    if (this.onIterationUpdate) {\n      this.onIterationUpdate(nodeId, current + 1);\n    }\n\n    return current;\n  }\n\n  /**\n   * Generate an iterated stage name for context tree.\n   * First visit: \"askLLM\", second: \"askLLM.1\", third: \"askLLM.2\".\n   */\n  getIteratedStageName(baseName: string, iteration: number): string {\n    return iteration === 0 ? baseName : `${baseName}.${iteration}`;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ContinuationResolver.js","sourceRoot":"","sources":["../../../../../src/lib/engine/handlers/ContinuationResolver.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ContinuationResolver — Back-edge resolution + iteration counting.\n *\n * Resolves dynamic continuations (loop-backs, dynamic next) and tracks\n * per-node iteration counts for context tree naming.\n *\n * Supports three dynamicNext patterns:\n * - String ID → reference to existing node (resolve via NodeResolver)\n * - StageNode with fn → truly dynamic node (execute directly)\n * - StageNode without fn → reference by ID (resolve via NodeResolver)\n *\n * Two entry points:\n * - `resolveTarget` — resolves the continuation to `{ node, context }` and\n *   fires every side effect (iteration counting, debug logs, `onLoop`\n *   narrative) WITHOUT executing. The traverser's trampoline driver uses\n *   this to follow loop edges iteratively — flat stack, so the iteration\n *   limit (not call-stack depth) is what bounds a loop.\n * - `resolve` — resolveTarget + immediate execution via the provided\n *   `executeNode` callback. Kept for direct/advanced callers.\n */\n\nimport type { StageContext } from '../../memory/StageContext.js';\nimport type { StageNode } from '../graph/StageNode.js';\nimport type { TraversalContext } from '../narrative/types.js';\nimport type { HandlerDeps } from '../types.js';\nimport type { NodeResolver } from './NodeResolver.js';\nimport type { ExecuteNodeFn } from './types.js';\n\nexport const DEFAULT_MAX_ITERATIONS = 1000;\n\n/**\n * A resolved continuation target — the node to execute next plus the\n * StageContext to execute it in. All side effects (iteration counting,\n * debug logs, `onLoop` narrative) have already fired by the time this\n * is returned.\n */\nexport interface ResolvedContinuation<TOut = any, TScope = any> {\n  node: StageNode<TOut, TScope>;\n  context: StageContext;\n}\n\nexport class ContinuationResolver<TOut = any, TScope = any> {\n  /**\n   * Iteration counter per node ID.\n   * Key: node.id, Value: visit count (0 = first visit).\n   */\n  private iterationCounters: Map<string, number> = new Map();\n\n  /**\n   * Total fn-bearing dynamic-next hops this traverser has followed.\n   *\n   * Fresh fn-bearing nodes bypass the per-node-id iteration counter (they\n   * are new nodes, often without stable ids — there is no back-edge to\n   * count). Without a bound, a stage that keeps returning a function-bearing\n   * dynamic `next` runs FOREVER on the flat trampoline (no stack overflow\n   * brakes it either). This run-total counter puts such chains under the\n   * same `maxIterations` budget (default 1000, tuned via\n   * `RunOptions.maxIterations`) that bounds loop edges.\n   */\n  private dynamicNextHops = 0;\n\n  private readonly onIterationUpdate?: (nodeId: string, count: number) => void;\n  private readonly maxIterations: number;\n\n  constructor(\n    private readonly deps: HandlerDeps<TOut, TScope>,\n    private readonly nodeResolver: NodeResolver<TOut, TScope>,\n    onIterationUpdate?: (nodeId: string, count: number) => void,\n    maxIterations?: number,\n  ) {\n    this.onIterationUpdate = onIterationUpdate;\n    this.maxIterations = maxIterations ?? DEFAULT_MAX_ITERATIONS;\n  }\n\n  /**\n   * Resolve a dynamic continuation and execute it immediately.\n   * Equivalent to `executeNode(...resolveTarget(...))` — the traverser's\n   * driver loop calls `resolveTarget` directly instead so the continuation\n   * becomes a flat trampoline hop rather than a retained recursive frame.\n   */\n  async resolve(\n    dynamicNext: string | StageNode<TOut, TScope>,\n    node: StageNode<TOut, TScope>,\n    context: StageContext,\n    breakFlag: { shouldBreak: boolean },\n    branchPath: string | undefined,\n    executeNode: ExecuteNodeFn<TOut, TScope>,\n    traversalContext?: TraversalContext,\n  ): Promise<any> {\n    const target = this.resolveTarget(dynamicNext, node, context, branchPath, traversalContext);\n    return executeNode(target.node, target.context, breakFlag, branchPath);\n  }\n\n  /**\n   * Resolve a dynamic continuation to its target node + next StageContext\n   * WITHOUT executing it. Fires the same side effects `resolve` always did\n   * (iteration counting + limit, `dynamicNext*` logs, loop debug message,\n   * `onLoop` narrative), in the same order.\n   *\n   * Three dynamicNext patterns:\n   * - StageNode with fn → truly dynamic node, returned as-is (no per-node\n   *   iteration tracking — it is a fresh node, not a back-edge — but the\n   *   run-total dynamic-hop budget applies; see `dynamicNextHops`).\n   * - String ID → reference to an existing node, resolved via NodeResolver.\n   * - StageNode without fn → reference by ID, resolved via NodeResolver.\n   */\n  resolveTarget(\n    dynamicNext: string | StageNode<TOut, TScope>,\n    currentNode: StageNode<TOut, TScope>,\n    context: StageContext,\n    branchPath: string | undefined,\n    traversalContext?: TraversalContext,\n  ): ResolvedContinuation<TOut, TScope> {\n    // Truly dynamic node (has fn) → execute directly, no per-node iteration\n    // tracking (fresh node, not a back-edge) — but the CHAIN of such hops is\n    // bounded by the run-total guard below, mirroring the loop budget.\n    if (typeof dynamicNext !== 'string' && dynamicNext.fn) {\n      if (this.dynamicNextHops >= this.maxIterations) {\n        throw new Error(\n          `Maximum dynamic-next continuations (${this.maxIterations}) exceeded at stage '${\n            currentNode.id ?? currentNode.name\n          }' ` + `(dynamic target '${dynamicNext.name}'). Set maxIterations to increase the limit.`,\n        );\n      }\n      this.dynamicNextHops++;\n\n      context.addLog('dynamicNextDirect', true);\n      context.addLog('dynamicNextName', dynamicNext.name);\n\n      context.addFlowDebugMessage('next', `Moving to ${dynamicNext.name} stage (dynamic)`, {\n        targetStage: dynamicNext.name,\n      });\n\n      const nextStageContext = context.createNext(branchPath as string, dynamicNext.name, dynamicNext.id);\n      return { node: dynamicNext, context: nextStageContext };\n    }\n\n    // Reference — by string ID or by node-without-fn ID. A node reference\n    // without an id is a usage error; a string reference is passed through\n    // verbatim (an unknown id surfaces as \"target node not found\" below).\n    if (typeof dynamicNext !== 'string' && !dynamicNext.id) {\n      const errorMessage = 'dynamicNext node must have an id when used as reference';\n      this.deps.logger.error(`Error in pipeline (${branchPath}) stage [${currentNode.name}]:`, { error: errorMessage });\n      throw new Error(errorMessage);\n    }\n    const nextNodeId = typeof dynamicNext === 'string' ? dynamicNext : dynamicNext.id!;\n\n    const targetNode = this.nodeResolver.findNodeById(nextNodeId);\n    if (!targetNode) {\n      const errorMessage = `dynamicNext target node not found: ${nextNodeId}`;\n      this.deps.logger.error(`Error in pipeline (${branchPath}) stage [${currentNode.name}]:`, { error: errorMessage });\n      throw new Error(errorMessage);\n    }\n\n    const iteration = this.getAndIncrementIteration(nextNodeId);\n    const iteratedStageName = this.getIteratedStageName(targetNode.name, iteration);\n    context.addLog('dynamicNextTarget', nextNodeId);\n    context.addLog('dynamicNextIteration', iteration);\n\n    context.addFlowDebugMessage('loop', `Looping back to ${targetNode.name} (iteration ${iteration + 1})`, {\n      targetStage: targetNode.name,\n      iteration: iteration + 1,\n    });\n\n    this.deps.narrativeGenerator.onLoop(targetNode.name, iteration + 1, targetNode.description, traversalContext);\n\n    const nextStageContext = context.createNext(branchPath as string, iteratedStageName, targetNode.id);\n    return { node: targetNode, context: nextStageContext };\n  }\n\n  /**\n   * Get the next iteration number for a node and increment.\n   * Returns 0 for first visit, 1 for second, etc.\n   * Throws if maxIterations exceeded (infinite loop guard).\n   */\n  getAndIncrementIteration(nodeId: string): number {\n    const current = this.iterationCounters.get(nodeId) ?? 0;\n    if (current >= this.maxIterations) {\n      throw new Error(\n        `Maximum loop iterations (${this.maxIterations}) exceeded for node '${nodeId}'. ` +\n          'Set maxIterations to increase the limit.',\n      );\n    }\n    this.iterationCounters.set(nodeId, current + 1);\n\n    if (this.onIterationUpdate) {\n      this.onIterationUpdate(nodeId, current + 1);\n    }\n\n    return current;\n  }\n\n  /**\n   * Generate an iterated stage name for context tree.\n   * First visit: \"askLLM\", second: \"askLLM.1\", third: \"askLLM.2\".\n   */\n  getIteratedStageName(baseName: string, iteration: number): string {\n    return iteration === 0 ? baseName : `${baseName}.${iteration}`;\n  }\n}\n"]}

package/dist/esm/lib/engine/types.js

@@ -27,4 +27,4 @@ export var ArrayMergeMode;
     /** Overwrite parent array with subflow output. Use for Dynamic loops. */
     ArrayMergeMode["Replace"] = "replace";
 })(ArrayMergeMode || (ArrayMergeMode = {}));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/lib/engine/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAaH,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAe9E,oCAAoC;AACpC,wDAAwD;AACxD,MAAM,CAAC,MAAM,aAAa,GAAY;IACpC,IAAI,EAAE,CAAC,OAAa,EAAE,GAAG,IAAW,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC;IACvE,GAAG,EAAE,CAAC,OAAa,EAAE,GAAG,IAAW,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC;IACrE,KAAK,EAAE,CAAC,OAAa,EAAE,GAAG,IAAW,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC;IACzE,KAAK,EAAE,CAAC,OAAa,EAAE,GAAG,IAAW,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC;IACzE,IAAI,EAAE,CAAC,OAAa,EAAE,GAAG,IAAW,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC;CACxE,CAAC;AAmDF,8EAA8E;AAC9E,UAAU;AACV,8EAA8E;AAE9E;;GAEG;AACH,MAAM,CAAN,IAAY,cAKX;AALD,WAAY,cAAc;IACxB,wFAAwF;IACxF,mCAAiB,CAAA;IACjB,yEAAyE;IACzE,qCAAmB,CAAA;AACrB,CAAC,EALW,cAAc,KAAd,cAAc,QAKzB","sourcesContent":["/**\n * types.ts — All type definitions for the engine library.\n *\n * Centralizes type definitions to avoid circular dependencies.\n * Every handler receives HandlerDeps (the DI bag) instead of importing the traverser.\n */\n\nimport type { StageContext } from '../memory/StageContext.js';\nimport type { FlowControlType, FlowMessage } from '../memory/types.js';\nimport type { ScopeProtectionMode } from '../scope/protection/types.js';\nimport type { Decider, Selector, StageNode } from './graph/StageNode.js';\nimport type { IControlFlowNarrative } from './narrative/types.js';\n\n// Re-export StageNode types for convenience\nexport type { Decider, Selector, StageNode } from './graph/StageNode.js';\n\n// Re-export pause types from pause/ library\nexport type { FlowchartCheckpoint, PausableHandler, PauseResult } from '../pause/index.js';\nexport { isPauseResult, isPauseSignal, PauseSignal } from '../pause/index.js';\n\n// ---------------------------------------------------------------------------\n// Logger\n// ---------------------------------------------------------------------------\n\n/** Minimal logging contract. Mirrors Console API subset. */\nexport interface ILogger {\n  info(message?: any, ...optionalParams: any[]): void;\n  log(message?: any, ...optionalParams: any[]): void;\n  debug(message?: any, ...optionalParams: any[]): void;\n  error(message?: any, ...optionalParams: any[]): void;\n  warn(message?: any, ...optionalParams: any[]): void;\n}\n\n/** Default console-based logger. */\n/* istanbul ignore next -- trivial console delegation */\nexport const defaultLogger: ILogger = {\n  info: (message?: any, ...args: any[]) => console.info(message, ...args),\n  log: (message?: any, ...args: any[]) => console.log(message, ...args),\n  debug: (message?: any, ...args: any[]) => console.debug(message, ...args),\n  error: (message?: any, ...args: any[]) => console.error(message, ...args),\n  warn: (message?: any, ...args: any[]) => console.warn(message, ...args),\n};\n\n// ---------------------------------------------------------------------------\n// Stage Function\n// ---------------------------------------------------------------------------\n\n/** Callback that receives tokens during streaming. */\nexport type StreamCallback = (token: string) => void;\n\n/**\n * The function signature for stage handlers.\n * - TOut: return type produced by the stage\n * - TScope: the scope object passed to the stage\n * - Optional 3rd parameter `streamCallback` injected for streaming stages.\n */\nexport type StageFunction<TOut = any, TScope = any> = (\n  scope: TScope,\n  breakPipeline: () => void,\n  streamCallback?: StreamCallback,\n) => Promise<TOut | void> | TOut | void;\n\n/**\n * Stage function for pausable stages — return value is the pause data (any type).\n * Return non-void to pause, return void to continue normally.\n */\nexport type PausableStageFunction<TScope = any> = (\n  scope: TScope,\n  breakPipeline: () => void,\n) => Promise<unknown> | unknown;\n\n/** Factory that creates a scope instance for each stage. */\nexport type ScopeFactory<TScope = any> = (\n  context: StageContext,\n  stageName: string,\n  readOnlyContext?: unknown,\n  executionEnv?: ExecutionEnv,\n) => TScope;\n\n// ---------------------------------------------------------------------------\n// Streaming\n// ---------------------------------------------------------------------------\n\nexport type StreamTokenHandler = (streamId: string, token: string) => void;\nexport type StreamLifecycleHandler = (streamId: string, fullText?: string) => void;\n\nexport interface StreamHandlers {\n  onToken?: StreamTokenHandler;\n  onStart?: StreamLifecycleHandler;\n  onEnd?: StreamLifecycleHandler;\n}\n\n// ---------------------------------------------------------------------------\n// Subflow\n// ---------------------------------------------------------------------------\n\n/**\n * Controls how array values from outputMapper are merged into parent scope.\n */\nexport enum ArrayMergeMode {\n  /** Append subflow output to existing parent array: [...existing, ...value]. Default. */\n  Concat = 'concat',\n  /** Overwrite parent array with subflow output. Use for Dynamic loops. */\n  Replace = 'replace',\n}\n\nexport interface SubflowMountOptions<TParentScope = any, TSubflowInput = any, TSubflowOutput = any> {\n  inputMapper?: (parentScope: TParentScope) => TSubflowInput;\n  /**\n   * Maps subflow output back into parent scope.\n   *\n   * **Array merge behavior** is controlled by `arrayMerge`:\n   * - `'concat'` (default): `[...existing, ...value]` — return only **delta** items\n   * - `'replace'`: overwrites the parent value — return the full array\n   *\n   * Scalar values are always replaced regardless of `arrayMerge`.\n   *\n   * @example\n   * ```typescript\n   * // Delta mode (default) — return only new items, concat appends\n   * outputMapper: (sf) => ({ messages: sf.newMessages })\n   *\n   * // Replace mode — return full array, parent value is overwritten\n   * // Useful in Dynamic loops where the subflow recomputes the full value each iteration\n   * outputMapper: (sf) => ({ toolDescriptions: sf.toolDescriptions }),\n   * arrayMerge: ArrayMergeMode.Replace,\n   *\n   * // Scalars are fine in both modes — always replaced\n   * outputMapper: (sf) => ({ status: sf.result, count: sf.total })\n   * ```\n   */\n  outputMapper?: (subflowOutput: TSubflowOutput, parentScope: TParentScope) => Record<string, unknown>;\n  /**\n   * Controls how array values from outputMapper are merged into parent scope.\n   * Applies only to top-level array keys. Nested arrays inside objects\n   * always use append (appendToArray) regardless of this setting.\n   *\n   * @default ArrayMergeMode.Concat\n   */\n  arrayMerge?: ArrayMergeMode;\n\n  /**\n   * STRUCTURE-ONLY: the downstream stage id this branch's convergence edge\n   * points to, overriding the default \"converge at the next linear stage.\"\n   *\n   * When a fork/selector/decider branch carries `convergeAt`, its visualized\n   * `next` edge is fired to the named stage instead of to the shared\n   * convergence node its siblings use. This expresses an unequal-depth merge\n   * — e.g. a `tools` slot that bypasses the `messageAPI` assembly node and\n   * pairs with its output at `call-llm` (so `call-llm` reads as a 2-parent\n   * merge), faithful to the Anthropic wire protocol (system+messages = the\n   * message payload; tools = a separate top-level field).\n   *\n   * **This affects the STRUCTURE/topology graph only** — the runtime is\n   * unchanged (the branch's outputs ride shared scope; the named target reads\n   * them when it runs). It does NOT introduce a join barrier. The target is a\n   * FORWARD stage (added later in the chain), so it is not validated at\n   * branch-declaration time.\n   */\n  convergeAt?: string;\n\n  /**\n   * When `true`, an inner `scope.$break(reason)` call inside this subflow\n   * propagates up to the parent — i.e., the parent's `breakFlag` is set\n   * after the subflow exits, terminating the parent's outer loop too.\n   *\n   * **Default: `false`** (current behaviour — inner break stops only the\n   * subflow; parent continues).\n   *\n   * ## When to use\n   *\n   * Set `propagateBreak: true` on subflow mounts that represent\n   * **terminal** branches — \"if this subflow fires, the outer loop is\n   * done\". Examples:\n   *\n   * - A human-review runner that takes over from an agent's tool-calling\n   *   loop and produces the final response.\n   * - A safety-gate subflow that halts the outer workflow when a policy\n   *   violation is detected.\n   * - An error-recovery subflow that restores state and then terminates.\n   *\n   * ## Semantics\n   *\n   * 1. Inside the subflow, a stage calls `scope.$break(reason)`.\n   * 2. The subflow's own execution stops (normal `$break` behaviour).\n   * 3. `SubflowExecutor` inspects the subflow's exit state. If\n   *    `propagateBreak === true` AND the inner break fired, it forwards\n   *    the break (and its reason) to the parent's `breakFlag`.\n   * 4. The parent traverser sees `shouldBreak` on its next step and exits.\n   * 5. A `FlowRecorder.onBreak` event fires at the parent-mount level with\n   *    `propagatedFromSubflow` = the subflow's id and the inner reason.\n   *\n   * ## Parallel/fan-out\n   *\n   * Follows the existing library rule in `ChildrenExecutor`: the parent\n   * breaks only when **every** child of a fork broke. A single\n   * `propagateBreak: true` subflow contributing its break to the count\n   * does not on its own terminate the parent fan-out.\n   *\n   * ## outputMapper still runs\n   *\n   * The subflow's `outputMapper` (if supplied) ALWAYS runs before the\n   * break propagates, so the subflow's partial state is still written to\n   * the parent scope. This is intentional — the typical use case is an\n   * \"escalation\" subflow whose output IS the final answer that needs to\n   * land in the parent scope before the outer loop terminates. If you\n   * want to suppress output mapping on break, check the break state\n   * inside your `outputMapper` and return `{}` early.\n   *\n   * @default false\n   */\n  propagateBreak?: boolean;\n}\n\nexport interface SubflowResult {\n  subflowId: string;\n  subflowName: string;\n  treeContext: {\n    globalContext: Record<string, unknown>;\n    stageContexts: Record<string, unknown>;\n    history: unknown[];\n  };\n  parentStageId: string;\n  pipelineStructure?: unknown;\n}\n\n// ---------------------------------------------------------------------------\n// Subflow Traverser Factory\n// ---------------------------------------------------------------------------\n\n/**\n * SubflowTraverserFactory — Creates a FlowchartTraverser for subflow execution.\n *\n * Injected into SubflowExecutor to break the circular dependency:\n * FlowchartTraverser → SubflowExecutor → FlowchartTraverser.\n *\n * The factory captures parent traverser config (stageMap, scopeFactory, narrative, etc.)\n * in a closure. SubflowExecutor calls it with subflow-specific overrides (root, runtime, input).\n * The returned traverser uses the SAME 7-phase algorithm as the top-level traverser,\n * so deciders, selectors, loops, lazy subflows, and abort signals all work inside subflows.\n */\nexport type SubflowTraverserFactory<TOut = any, TScope = any> = (options: {\n  /** Root node of the subflow (with isSubflowRoot stripped). */\n  root: StageNode<TOut, TScope>;\n  /** Isolated execution runtime for the subflow. */\n  executionRuntime: IExecutionRuntime;\n  /** Mapped input from parent scope (becomes readOnlyContext for stages). */\n  readOnlyContext?: unknown;\n  /** Subflow identifier — used as branchPath for narrative context. */\n  subflowId?: string;\n}) => SubflowTraverserHandle<TOut, TScope>;\n\n/**\n * Handle returned by SubflowTraverserFactory.\n * Provides execute() + access to nested subflow results.\n */\nexport interface SubflowTraverserHandle<TOut = any, TScope = any> {\n  /** Execute the subflow's graph using the full 7-phase traversal algorithm. */\n  execute(): Promise<TraversalResult>;\n  /** Collect nested subflow results (from subflows mounted inside this subflow). */\n  getSubflowResults(): Map<string, SubflowResult>;\n  /**\n   * Final break state of the subflow after `execute()` returns.\n   *\n   *   - `shouldBreak: true`  → a stage inside the subflow called\n   *     `scope.$break(reason)`, stopping the subflow's own traversal.\n   *   - `reason`             → the optional string passed to `$break`.\n   *\n   * Used by `SubflowExecutor` to implement `SubflowMountOptions.propagateBreak`:\n   * if the mount opts in AND the subflow broke, the parent's break flag is\n   * forwarded.\n   */\n  getBreakState(): { shouldBreak: boolean; reason?: string };\n}\n\n// ---------------------------------------------------------------------------\n// Execution Runtime Interface\n// ---------------------------------------------------------------------------\n\n/**\n * IExecutionRuntime — Interface for the runtime environment.\n *\n * Defines the contract that engine handlers need from the runner layer,\n * avoiding circular imports between engine/ and runner/.\n */\nexport interface IExecutionRuntime {\n  globalStore: { getState(): Record<string, unknown> };\n  rootStageContext: StageContext;\n  executionHistory: { list(): unknown[] };\n  getSnapshot(options?: { redact?: boolean }): {\n    sharedState: Record<string, unknown>;\n    executionTree: unknown;\n    commitLog: unknown[];\n    subflowResults?: Record<string, unknown>;\n    recorders?: Array<{ id: string; name: string; data: unknown }>;\n  };\n  setRootObject(path: string[], key: string, value: unknown): void;\n  getPipelines(): string[];\n}\n\n// ---------------------------------------------------------------------------\n// Execution Environment — read-only, propagates through nested executors\n// ---------------------------------------------------------------------------\n\n/**\n * ExecutionEnv — infrastructure values that propagate through nested executors.\n *\n * Like `process.env` for flowcharts: read-only, inherited by child executors,\n * infrastructure-only (not business logic).\n *\n * Litmus test: Created external to the flowchart + passed in for execution = env.\n * Business config for a specific flowchart = args (getArgs()).\n *\n * Intentionally a closed type — not extensible to prevent coupling between\n * parent and child flowcharts.\n */\nexport interface ExecutionEnv {\n  /** AbortSignal for cooperative cancellation across nested executors. */\n  readonly signal?: AbortSignal;\n  /** Timeout budget in milliseconds. */\n  readonly timeoutMs?: number;\n  /** Trace identifier for distributed tracing / observability. */\n  readonly traceId?: string;\n}\n\n// ---------------------------------------------------------------------------\n// Handler Dependencies (DI bag) — was PipelineContext\n// ---------------------------------------------------------------------------\n\n/**\n * HandlerDeps — Dependency injection bag passed to all handler modules.\n *\n * Provides shared state (stageMap, runtime, scopeFactory, etc.) without\n * handlers needing to import the traverser directly. Avoids circular deps.\n */\nexport interface HandlerDeps<TOut = any, TScope = any> {\n  stageMap: Map<string, StageFunction<TOut, TScope>>;\n  root: StageNode<TOut, TScope>;\n  executionRuntime: IExecutionRuntime;\n  scopeFactory: ScopeFactory<TScope>;\n  subflows?: Record<string, { root: StageNode<TOut, TScope> }>;\n  throttlingErrorChecker?: (error: unknown) => boolean;\n  streamHandlers?: StreamHandlers;\n  scopeProtectionMode: ScopeProtectionMode;\n  readOnlyContext?: unknown;\n  /** Execution environment — propagates to subflows automatically. */\n  executionEnv?: ExecutionEnv;\n  narrativeGenerator: IControlFlowNarrative;\n  logger: ILogger;\n  signal?: AbortSignal;\n  /**\n   * On resume, the per-subflow scope captures from the checkpoint.\n   * Keyed by path-prefixed `subflowId` (matches `PauseSignal.subflowPath`).\n   *\n   * `SubflowExecutor` consults this on entry: if a key matches the\n   * current subflow id, the nested runtime is seeded from this state\n   * and the inputMapper is SKIPPED (the captured state already\n   * reflects post-input pre-pause memory). This is what makes\n   * cross-executor resume work for pauses INSIDE a subflow.\n   *\n   * Undefined on normal `run()` paths — only the resume path sets it.\n   */\n  subflowStatesForResume?: Record<string, Record<string, unknown>>;\n}\n\n/** Options for FlowChartExecutor.run(). */\nexport interface RunOptions {\n  /** AbortSignal for cooperative cancellation. */\n  signal?: AbortSignal;\n  /** Timeout in milliseconds. Creates an internal AbortController. */\n  timeoutMs?: number;\n  /**\n   * Runtime input data for the pipeline.\n   * Becomes the readOnlyContext accessible via `scope.getArgs()`.\n   * Stages cannot overwrite these keys with `setValue()`.\n   */\n  input?: unknown;\n  /**\n   * Execution environment — read-only infrastructure values that propagate\n   * through nested executors (like `process.env` for flowcharts).\n   * Accessible via `scope.getEnv()`. Inherited by subflows automatically.\n   */\n  env?: ExecutionEnv;\n  /**\n   * Override the maximum nested `executeNode` depth for this run.\n   * Defaults to `FlowchartTraverser.MAX_EXECUTE_DEPTH` (500).\n   *\n   * Depth counts TREE nesting only — fork children, decider/selector branch\n   * dispatch, recursive composition. Linear chains and loop iterations run\n   * on a flat trampoline and never consume depth, so this rarely needs\n   * raising. Must be >= 1.\n   */\n  maxDepth?: number;\n  /**\n   * Override the maximum loop iterations per node for this run (the\n   * `ContinuationResolver` infinite-loop guard). Defaults to 1000.\n   * This is the binding constraint for loop-heavy pipelines — raise it for\n   * legitimately long loops (`loopTo` chains run with a flat stack, so high\n   * values are safe; memory for state/narrative still grows per iteration).\n   * Propagates to subflows. Must be >= 1.\n   */\n  maxIterations?: number;\n}\n\n// ---------------------------------------------------------------------------\n// Flow Control Narrative — canonical definitions live in memory/types.ts\n// ---------------------------------------------------------------------------\n\nexport type { FlowControlType, FlowMessage };\n\n// ---------------------------------------------------------------------------\n// Runtime Structure Metadata (used by RuntimeStructureManager)\n// ---------------------------------------------------------------------------\n\nexport interface RuntimeStructureMetadata {\n  type: 'stage' | 'decider' | 'selector' | 'fork' | 'streaming' | 'subflow' | 'loop';\n  subflowId?: string;\n  isSubflowRoot?: boolean;\n  subflowName?: string;\n  isParallelChild?: boolean;\n  parallelGroupId?: string;\n  loopTarget?: string;\n  isDynamic?: boolean;\n  isLoopReference?: boolean;\n  streamId?: string;\n}\n\n// ---------------------------------------------------------------------------\n// Node Result\n// ---------------------------------------------------------------------------\n\nexport type NodeResultType = {\n  id: string;\n  result: unknown;\n  isError?: boolean;\n};\n\n// ---------------------------------------------------------------------------\n// Execution Response\n// ---------------------------------------------------------------------------\n\nexport type BranchResult = {\n  result: string | Error;\n  isError: boolean;\n};\n\nexport type BranchResults = { [branchId: string]: BranchResult };\nexport type TraversalResult = BranchResults | string | Error;\n\n/** Returned by run()/resume() when execution pauses. */\nexport type PausedResult = {\n  readonly paused: true;\n  readonly checkpoint: import('../pause/types.js').FlowchartCheckpoint;\n};\n\n/** Full return type of FlowChartExecutor.run() and resume(). */\nexport type ExecutorResult = TraversalResult | PausedResult;\n\n// ---------------------------------------------------------------------------\n// Serialized Pipeline Structure (for visualization)\n// ---------------------------------------------------------------------------\n\nexport interface SerializedPipelineNode {\n  name: string;\n  id: string;\n  type?:\n    | 'stage'\n    | 'decider'\n    | 'selector'\n    | 'fork'\n    | 'streaming'\n    | 'subflow'\n    | 'loop'\n    | 'user'\n    | 'tool'\n    | 'function'\n    | 'sequence';\n  description?: string;\n  children?: SerializedPipelineNode[];\n  next?: SerializedPipelineNode;\n  branches?: Record<string, SerializedPipelineNode>;\n  hasDecider?: boolean;\n  hasSelector?: boolean;\n  hasSubtree?: boolean;\n  isStreaming?: boolean;\n  streamId?: string;\n  isSubflowRoot?: boolean;\n  subflowId?: string;\n  subflowName?: string;\n  loopTarget?: string;\n  isLoopReference?: boolean;\n  isParallelChild?: boolean;\n  parallelGroupId?: string;\n  isDynamic?: boolean;\n  /** When true, this stage can pause execution (PausableHandler pattern). */\n  isPausable?: boolean;\n}\n\n// ---------------------------------------------------------------------------\n// FlowChart is defined in `../builder/types.ts`. The engine layer consumes it\n// via import from there. A duplicate minimal definition previously lived here\n// and caused TS confusion at composition boundaries (ComposableRunner vs\n// addSubFlowChart parameter). Single source of truth now lives in builder/.\n// ---------------------------------------------------------------------------\n\n/** Alias for SerializedPipelineNode used as full structure */\nexport type SerializedPipelineStructure = SerializedPipelineNode & {\n  branchIds?: string[];\n  subflowStructure?: SerializedPipelineStructure;\n  iterationCount?: number;\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/lib/engine/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAaH,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAe9E,oCAAoC;AACpC,wDAAwD;AACxD,MAAM,CAAC,MAAM,aAAa,GAAY;IACpC,IAAI,EAAE,CAAC,OAAa,EAAE,GAAG,IAAW,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC;IACvE,GAAG,EAAE,CAAC,OAAa,EAAE,GAAG,IAAW,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC;IACrE,KAAK,EAAE,CAAC,OAAa,EAAE,GAAG,IAAW,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC;IACzE,KAAK,EAAE,CAAC,OAAa,EAAE,GAAG,IAAW,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC;IACzE,IAAI,EAAE,CAAC,OAAa,EAAE,GAAG,IAAW,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC;CACxE,CAAC;AAmDF,8EAA8E;AAC9E,UAAU;AACV,8EAA8E;AAE9E;;GAEG;AACH,MAAM,CAAN,IAAY,cAKX;AALD,WAAY,cAAc;IACxB,wFAAwF;IACxF,mCAAiB,CAAA;IACjB,yEAAyE;IACzE,qCAAmB,CAAA;AACrB,CAAC,EALW,cAAc,KAAd,cAAc,QAKzB","sourcesContent":["/**\n * types.ts — All type definitions for the engine library.\n *\n * Centralizes type definitions to avoid circular dependencies.\n * Every handler receives HandlerDeps (the DI bag) instead of importing the traverser.\n */\n\nimport type { StageContext } from '../memory/StageContext.js';\nimport type { FlowControlType, FlowMessage } from '../memory/types.js';\nimport type { ScopeProtectionMode } from '../scope/protection/types.js';\nimport type { Decider, Selector, StageNode } from './graph/StageNode.js';\nimport type { IControlFlowNarrative } from './narrative/types.js';\n\n// Re-export StageNode types for convenience\nexport type { Decider, Selector, StageNode } from './graph/StageNode.js';\n\n// Re-export pause types from pause/ library\nexport type { FlowchartCheckpoint, PausableHandler, PauseResult } from '../pause/index.js';\nexport { isPauseResult, isPauseSignal, PauseSignal } from '../pause/index.js';\n\n// ---------------------------------------------------------------------------\n// Logger\n// ---------------------------------------------------------------------------\n\n/** Minimal logging contract. Mirrors Console API subset. */\nexport interface ILogger {\n  info(message?: any, ...optionalParams: any[]): void;\n  log(message?: any, ...optionalParams: any[]): void;\n  debug(message?: any, ...optionalParams: any[]): void;\n  error(message?: any, ...optionalParams: any[]): void;\n  warn(message?: any, ...optionalParams: any[]): void;\n}\n\n/** Default console-based logger. */\n/* istanbul ignore next -- trivial console delegation */\nexport const defaultLogger: ILogger = {\n  info: (message?: any, ...args: any[]) => console.info(message, ...args),\n  log: (message?: any, ...args: any[]) => console.log(message, ...args),\n  debug: (message?: any, ...args: any[]) => console.debug(message, ...args),\n  error: (message?: any, ...args: any[]) => console.error(message, ...args),\n  warn: (message?: any, ...args: any[]) => console.warn(message, ...args),\n};\n\n// ---------------------------------------------------------------------------\n// Stage Function\n// ---------------------------------------------------------------------------\n\n/** Callback that receives tokens during streaming. */\nexport type StreamCallback = (token: string) => void;\n\n/**\n * The function signature for stage handlers.\n * - TOut: return type produced by the stage\n * - TScope: the scope object passed to the stage\n * - Optional 3rd parameter `streamCallback` injected for streaming stages.\n */\nexport type StageFunction<TOut = any, TScope = any> = (\n  scope: TScope,\n  breakPipeline: () => void,\n  streamCallback?: StreamCallback,\n) => Promise<TOut | void> | TOut | void;\n\n/**\n * Stage function for pausable stages — return value is the pause data (any type).\n * Return non-void to pause, return void to continue normally.\n */\nexport type PausableStageFunction<TScope = any> = (\n  scope: TScope,\n  breakPipeline: () => void,\n) => Promise<unknown> | unknown;\n\n/** Factory that creates a scope instance for each stage. */\nexport type ScopeFactory<TScope = any> = (\n  context: StageContext,\n  stageName: string,\n  readOnlyContext?: unknown,\n  executionEnv?: ExecutionEnv,\n) => TScope;\n\n// ---------------------------------------------------------------------------\n// Streaming\n// ---------------------------------------------------------------------------\n\nexport type StreamTokenHandler = (streamId: string, token: string) => void;\nexport type StreamLifecycleHandler = (streamId: string, fullText?: string) => void;\n\nexport interface StreamHandlers {\n  onToken?: StreamTokenHandler;\n  onStart?: StreamLifecycleHandler;\n  onEnd?: StreamLifecycleHandler;\n}\n\n// ---------------------------------------------------------------------------\n// Subflow\n// ---------------------------------------------------------------------------\n\n/**\n * Controls how array values from outputMapper are merged into parent scope.\n */\nexport enum ArrayMergeMode {\n  /** Append subflow output to existing parent array: [...existing, ...value]. Default. */\n  Concat = 'concat',\n  /** Overwrite parent array with subflow output. Use for Dynamic loops. */\n  Replace = 'replace',\n}\n\nexport interface SubflowMountOptions<TParentScope = any, TSubflowInput = any, TSubflowOutput = any> {\n  inputMapper?: (parentScope: TParentScope) => TSubflowInput;\n  /**\n   * Maps subflow output back into parent scope.\n   *\n   * **Array merge behavior** is controlled by `arrayMerge`:\n   * - `'concat'` (default): `[...existing, ...value]` — return only **delta** items\n   * - `'replace'`: overwrites the parent value — return the full array\n   *\n   * Scalar values are always replaced regardless of `arrayMerge`.\n   *\n   * @example\n   * ```typescript\n   * // Delta mode (default) — return only new items, concat appends\n   * outputMapper: (sf) => ({ messages: sf.newMessages })\n   *\n   * // Replace mode — return full array, parent value is overwritten\n   * // Useful in Dynamic loops where the subflow recomputes the full value each iteration\n   * outputMapper: (sf) => ({ toolDescriptions: sf.toolDescriptions }),\n   * arrayMerge: ArrayMergeMode.Replace,\n   *\n   * // Scalars are fine in both modes — always replaced\n   * outputMapper: (sf) => ({ status: sf.result, count: sf.total })\n   * ```\n   */\n  outputMapper?: (subflowOutput: TSubflowOutput, parentScope: TParentScope) => Record<string, unknown>;\n  /**\n   * Controls how array values from outputMapper are merged into parent scope.\n   * Applies only to top-level array keys. Nested arrays inside objects\n   * always use append (appendToArray) regardless of this setting.\n   *\n   * @default ArrayMergeMode.Concat\n   */\n  arrayMerge?: ArrayMergeMode;\n\n  /**\n   * STRUCTURE-ONLY: the downstream stage id this branch's convergence edge\n   * points to, overriding the default \"converge at the next linear stage.\"\n   *\n   * When a fork/selector/decider branch carries `convergeAt`, its visualized\n   * `next` edge is fired to the named stage instead of to the shared\n   * convergence node its siblings use. This expresses an unequal-depth merge\n   * — e.g. a `tools` slot that bypasses the `messageAPI` assembly node and\n   * pairs with its output at `call-llm` (so `call-llm` reads as a 2-parent\n   * merge), faithful to the Anthropic wire protocol (system+messages = the\n   * message payload; tools = a separate top-level field).\n   *\n   * **This affects the STRUCTURE/topology graph only** — the runtime is\n   * unchanged (the branch's outputs ride shared scope; the named target reads\n   * them when it runs). It does NOT introduce a join barrier. The target is a\n   * FORWARD stage (added later in the chain), so it is not validated at\n   * branch-declaration time.\n   */\n  convergeAt?: string;\n\n  /**\n   * When `true`, an inner `scope.$break(reason)` call inside this subflow\n   * propagates up to the parent — i.e., the parent's `breakFlag` is set\n   * after the subflow exits, terminating the parent's outer loop too.\n   *\n   * **Default: `false`** (current behaviour — inner break stops only the\n   * subflow; parent continues).\n   *\n   * ## When to use\n   *\n   * Set `propagateBreak: true` on subflow mounts that represent\n   * **terminal** branches — \"if this subflow fires, the outer loop is\n   * done\". Examples:\n   *\n   * - A human-review runner that takes over from an agent's tool-calling\n   *   loop and produces the final response.\n   * - A safety-gate subflow that halts the outer workflow when a policy\n   *   violation is detected.\n   * - An error-recovery subflow that restores state and then terminates.\n   *\n   * ## Semantics\n   *\n   * 1. Inside the subflow, a stage calls `scope.$break(reason)`.\n   * 2. The subflow's own execution stops (normal `$break` behaviour).\n   * 3. `SubflowExecutor` inspects the subflow's exit state. If\n   *    `propagateBreak === true` AND the inner break fired, it forwards\n   *    the break (and its reason) to the parent's `breakFlag`.\n   * 4. The parent traverser sees `shouldBreak` on its next step and exits.\n   * 5. A `FlowRecorder.onBreak` event fires at the parent-mount level with\n   *    `propagatedFromSubflow` = the subflow's id and the inner reason.\n   *\n   * ## Parallel/fan-out\n   *\n   * Follows the existing library rule in `ChildrenExecutor`: the parent\n   * breaks only when **every** child of a fork broke. A single\n   * `propagateBreak: true` subflow contributing its break to the count\n   * does not on its own terminate the parent fan-out.\n   *\n   * ## outputMapper still runs\n   *\n   * The subflow's `outputMapper` (if supplied) ALWAYS runs before the\n   * break propagates, so the subflow's partial state is still written to\n   * the parent scope. This is intentional — the typical use case is an\n   * \"escalation\" subflow whose output IS the final answer that needs to\n   * land in the parent scope before the outer loop terminates. If you\n   * want to suppress output mapping on break, check the break state\n   * inside your `outputMapper` and return `{}` early.\n   *\n   * @default false\n   */\n  propagateBreak?: boolean;\n}\n\nexport interface SubflowResult {\n  subflowId: string;\n  subflowName: string;\n  treeContext: {\n    globalContext: Record<string, unknown>;\n    stageContexts: Record<string, unknown>;\n    history: unknown[];\n  };\n  parentStageId: string;\n  pipelineStructure?: unknown;\n}\n\n// ---------------------------------------------------------------------------\n// Subflow Traverser Factory\n// ---------------------------------------------------------------------------\n\n/**\n * SubflowTraverserFactory — Creates a FlowchartTraverser for subflow execution.\n *\n * Injected into SubflowExecutor to break the circular dependency:\n * FlowchartTraverser → SubflowExecutor → FlowchartTraverser.\n *\n * The factory captures parent traverser config (stageMap, scopeFactory, narrative, etc.)\n * in a closure. SubflowExecutor calls it with subflow-specific overrides (root, runtime, input).\n * The returned traverser uses the SAME 7-phase algorithm as the top-level traverser,\n * so deciders, selectors, loops, lazy subflows, and abort signals all work inside subflows.\n */\nexport type SubflowTraverserFactory<TOut = any, TScope = any> = (options: {\n  /** Root node of the subflow (with isSubflowRoot stripped). */\n  root: StageNode<TOut, TScope>;\n  /** Isolated execution runtime for the subflow. */\n  executionRuntime: IExecutionRuntime;\n  /** Mapped input from parent scope (becomes readOnlyContext for stages). */\n  readOnlyContext?: unknown;\n  /** Subflow identifier — used as branchPath for narrative context. */\n  subflowId?: string;\n}) => SubflowTraverserHandle<TOut, TScope>;\n\n/**\n * Handle returned by SubflowTraverserFactory.\n * Provides execute() + access to nested subflow results.\n */\nexport interface SubflowTraverserHandle<TOut = any, TScope = any> {\n  /** Execute the subflow's graph using the full 7-phase traversal algorithm. */\n  execute(): Promise<TraversalResult>;\n  /** Collect nested subflow results (from subflows mounted inside this subflow). */\n  getSubflowResults(): Map<string, SubflowResult>;\n  /**\n   * Final break state of the subflow after `execute()` returns.\n   *\n   *   - `shouldBreak: true`  → a stage inside the subflow called\n   *     `scope.$break(reason)`, stopping the subflow's own traversal.\n   *   - `reason`             → the optional string passed to `$break`.\n   *\n   * Used by `SubflowExecutor` to implement `SubflowMountOptions.propagateBreak`:\n   * if the mount opts in AND the subflow broke, the parent's break flag is\n   * forwarded.\n   */\n  getBreakState(): { shouldBreak: boolean; reason?: string };\n}\n\n// ---------------------------------------------------------------------------\n// Execution Runtime Interface\n// ---------------------------------------------------------------------------\n\n/**\n * IExecutionRuntime — Interface for the runtime environment.\n *\n * Defines the contract that engine handlers need from the runner layer,\n * avoiding circular imports between engine/ and runner/.\n */\nexport interface IExecutionRuntime {\n  globalStore: { getState(): Record<string, unknown> };\n  rootStageContext: StageContext;\n  executionHistory: { list(): unknown[] };\n  getSnapshot(options?: { redact?: boolean }): {\n    sharedState: Record<string, unknown>;\n    executionTree: unknown;\n    commitLog: unknown[];\n    subflowResults?: Record<string, unknown>;\n    recorders?: Array<{ id: string; name: string; data: unknown }>;\n  };\n  setRootObject(path: string[], key: string, value: unknown): void;\n  getPipelines(): string[];\n}\n\n// ---------------------------------------------------------------------------\n// Execution Environment — read-only, propagates through nested executors\n// ---------------------------------------------------------------------------\n\n/**\n * ExecutionEnv — infrastructure values that propagate through nested executors.\n *\n * Like `process.env` for flowcharts: read-only, inherited by child executors,\n * infrastructure-only (not business logic).\n *\n * Litmus test: Created external to the flowchart + passed in for execution = env.\n * Business config for a specific flowchart = args (getArgs()).\n *\n * Intentionally a closed type — not extensible to prevent coupling between\n * parent and child flowcharts.\n */\nexport interface ExecutionEnv {\n  /** AbortSignal for cooperative cancellation across nested executors. */\n  readonly signal?: AbortSignal;\n  /** Timeout budget in milliseconds. */\n  readonly timeoutMs?: number;\n  /** Trace identifier for distributed tracing / observability. */\n  readonly traceId?: string;\n}\n\n// ---------------------------------------------------------------------------\n// Handler Dependencies (DI bag) — was PipelineContext\n// ---------------------------------------------------------------------------\n\n/**\n * HandlerDeps — Dependency injection bag passed to all handler modules.\n *\n * Provides shared state (stageMap, runtime, scopeFactory, etc.) without\n * handlers needing to import the traverser directly. Avoids circular deps.\n */\nexport interface HandlerDeps<TOut = any, TScope = any> {\n  stageMap: Map<string, StageFunction<TOut, TScope>>;\n  root: StageNode<TOut, TScope>;\n  executionRuntime: IExecutionRuntime;\n  scopeFactory: ScopeFactory<TScope>;\n  subflows?: Record<string, { root: StageNode<TOut, TScope> }>;\n  throttlingErrorChecker?: (error: unknown) => boolean;\n  streamHandlers?: StreamHandlers;\n  scopeProtectionMode: ScopeProtectionMode;\n  readOnlyContext?: unknown;\n  /** Execution environment — propagates to subflows automatically. */\n  executionEnv?: ExecutionEnv;\n  narrativeGenerator: IControlFlowNarrative;\n  logger: ILogger;\n  signal?: AbortSignal;\n  /**\n   * On resume, the per-subflow scope captures from the checkpoint.\n   * Keyed by path-prefixed `subflowId` (matches `PauseSignal.subflowPath`).\n   *\n   * `SubflowExecutor` consults this on entry: if a key matches the\n   * current subflow id, the nested runtime is seeded from this state\n   * and the inputMapper is SKIPPED (the captured state already\n   * reflects post-input pre-pause memory). This is what makes\n   * cross-executor resume work for pauses INSIDE a subflow.\n   *\n   * Undefined on normal `run()` paths — only the resume path sets it.\n   */\n  subflowStatesForResume?: Record<string, Record<string, unknown>>;\n}\n\n/** Options for FlowChartExecutor.run(). */\nexport interface RunOptions {\n  /** AbortSignal for cooperative cancellation. */\n  signal?: AbortSignal;\n  /** Timeout in milliseconds. Creates an internal AbortController. */\n  timeoutMs?: number;\n  /**\n   * Runtime input data for the pipeline.\n   * Becomes the readOnlyContext accessible via `scope.getArgs()`.\n   * Stages cannot overwrite these keys with `setValue()`.\n   */\n  input?: unknown;\n  /**\n   * Execution environment — read-only infrastructure values that propagate\n   * through nested executors (like `process.env` for flowcharts).\n   * Accessible via `scope.getEnv()`. Inherited by subflows automatically.\n   */\n  env?: ExecutionEnv;\n  /**\n   * Override the maximum nested `executeNode` depth for this run.\n   * Defaults to `FlowchartTraverser.MAX_EXECUTE_DEPTH` (500).\n   *\n   * Depth counts TREE nesting only — fork children, decider/selector branch\n   * dispatch, recursive composition. Linear chains and loop iterations run\n   * on a flat trampoline and never consume depth, so this rarely needs\n   * raising. Must be >= 1.\n   */\n  maxDepth?: number;\n  /**\n   * Override the maximum loop iterations per node for this run (the\n   * `ContinuationResolver` infinite-loop guard). Defaults to 1000.\n   * This is the binding constraint for loop-heavy pipelines — raise it for\n   * legitimately long loops (`loopTo` chains run with a flat stack, so high\n   * values are safe; memory for state/narrative still grows per iteration).\n   * Also bounds the run-total chain of function-bearing dynamic `next`\n   * continuations (fresh nodes returned from stages) — a runaway dynamic\n   * chain errors instead of running forever.\n   * Propagates to subflows. Must be >= 1.\n   */\n  maxIterations?: number;\n}\n\n// ---------------------------------------------------------------------------\n// Flow Control Narrative — canonical definitions live in memory/types.ts\n// ---------------------------------------------------------------------------\n\nexport type { FlowControlType, FlowMessage };\n\n// ---------------------------------------------------------------------------\n// Runtime Structure Metadata (used by RuntimeStructureManager)\n// ---------------------------------------------------------------------------\n\nexport interface RuntimeStructureMetadata {\n  type: 'stage' | 'decider' | 'selector' | 'fork' | 'streaming' | 'subflow' | 'loop';\n  subflowId?: string;\n  isSubflowRoot?: boolean;\n  subflowName?: string;\n  isParallelChild?: boolean;\n  parallelGroupId?: string;\n  loopTarget?: string;\n  isDynamic?: boolean;\n  isLoopReference?: boolean;\n  streamId?: string;\n}\n\n// ---------------------------------------------------------------------------\n// Node Result\n// ---------------------------------------------------------------------------\n\nexport type NodeResultType = {\n  id: string;\n  result: unknown;\n  isError?: boolean;\n};\n\n// ---------------------------------------------------------------------------\n// Execution Response\n// ---------------------------------------------------------------------------\n\nexport type BranchResult = {\n  result: string | Error;\n  isError: boolean;\n};\n\nexport type BranchResults = { [branchId: string]: BranchResult };\nexport type TraversalResult = BranchResults | string | Error;\n\n/** Returned by run()/resume() when execution pauses. */\nexport type PausedResult = {\n  readonly paused: true;\n  readonly checkpoint: import('../pause/types.js').FlowchartCheckpoint;\n};\n\n/** Full return type of FlowChartExecutor.run() and resume(). */\nexport type ExecutorResult = TraversalResult | PausedResult;\n\n// ---------------------------------------------------------------------------\n// Serialized Pipeline Structure (for visualization)\n// ---------------------------------------------------------------------------\n\nexport interface SerializedPipelineNode {\n  name: string;\n  id: string;\n  type?:\n    | 'stage'\n    | 'decider'\n    | 'selector'\n    | 'fork'\n    | 'streaming'\n    | 'subflow'\n    | 'loop'\n    | 'user'\n    | 'tool'\n    | 'function'\n    | 'sequence';\n  description?: string;\n  children?: SerializedPipelineNode[];\n  next?: SerializedPipelineNode;\n  branches?: Record<string, SerializedPipelineNode>;\n  hasDecider?: boolean;\n  hasSelector?: boolean;\n  hasSubtree?: boolean;\n  isStreaming?: boolean;\n  streamId?: string;\n  isSubflowRoot?: boolean;\n  subflowId?: string;\n  subflowName?: string;\n  loopTarget?: string;\n  isLoopReference?: boolean;\n  isParallelChild?: boolean;\n  parallelGroupId?: string;\n  isDynamic?: boolean;\n  /** When true, this stage can pause execution (PausableHandler pattern). */\n  isPausable?: boolean;\n}\n\n// ---------------------------------------------------------------------------\n// FlowChart is defined in `../builder/types.ts`. The engine layer consumes it\n// via import from there. A duplicate minimal definition previously lived here\n// and caused TS confusion at composition boundaries (ComposableRunner vs\n// addSubFlowChart parameter). Single source of truth now lives in builder/.\n// ---------------------------------------------------------------------------\n\n/** Alias for SerializedPipelineNode used as full structure */\nexport type SerializedPipelineStructure = SerializedPipelineNode & {\n  branchIds?: string[];\n  subflowStructure?: SerializedPipelineStructure;\n  iterationCount?: number;\n};\n"]}