footprintjs 9.35.0 → 9.37.0

package/dist/esm/lib/engine/graph/prefixNodeTree.d.ts

@@ -0,0 +1,26 @@
+/**
+ * prefixNodeTree — the ONE subflow-id prefixer (F7, 9.37.0).
+ *
+ * A mounted subflow's node tree is re-addressed under its mount: every `name`,
+ * `id` and nested `subflowId` gains `<prefix>/`. The builder does it at MOUNT
+ * time (`FlowChartBuilder · _prefixNodeTree`); the traverser at RUN time (lazy
+ * subflows, and the generated branches of `addParallelForEach`). Both call
+ * this function, so a chart comes out identical either way — until 9.36.0 they
+ * were two byte-twin copies, pinned against drift by
+ * `test/lib/engine/branch-segment-prefixer-equivalence.test.ts`, which now
+ * guards the one implementation.
+ *
+ * Generated branch segments (`<stageId>~<index>`, see `ids/branchSegment.ts`)
+ * ride this exact path with no special case: a segment is just a prefix, so a
+ * branch's inner ids become `<segment>/<id>` and its stages address as
+ * `<segment>/<id>#<n>`.
+ *
+ * Never refuses: the ids it writes carry `/` on purpose. The refusal of
+ * reserved characters is the builder's, at its id doors (`refuseReservedId`).
+ *
+ * `branchId` is left UNPREFIXED — decider/selector matching reads
+ * `child.branchId ?? child.id`. The input is never mutated (each node is a
+ * shallow clone).
+ */
+import type { StageNode } from './StageNode.js';
+export declare function prefixNodeTree<N extends StageNode<any, any>>(node: N, prefix: string): N;

package/dist/esm/lib/engine/graph/prefixNodeTree.js

@@ -0,0 +1,40 @@
+/**
+ * prefixNodeTree — the ONE subflow-id prefixer (F7, 9.37.0).
+ *
+ * A mounted subflow's node tree is re-addressed under its mount: every `name`,
+ * `id` and nested `subflowId` gains `<prefix>/`. The builder does it at MOUNT
+ * time (`FlowChartBuilder · _prefixNodeTree`); the traverser at RUN time (lazy
+ * subflows, and the generated branches of `addParallelForEach`). Both call
+ * this function, so a chart comes out identical either way — until 9.36.0 they
+ * were two byte-twin copies, pinned against drift by
+ * `test/lib/engine/branch-segment-prefixer-equivalence.test.ts`, which now
+ * guards the one implementation.
+ *
+ * Generated branch segments (`<stageId>~<index>`, see `ids/branchSegment.ts`)
+ * ride this exact path with no special case: a segment is just a prefix, so a
+ * branch's inner ids become `<segment>/<id>` and its stages address as
+ * `<segment>/<id>#<n>`.
+ *
+ * Never refuses: the ids it writes carry `/` on purpose. The refusal of
+ * reserved characters is the builder's, at its id doors (`refuseReservedId`).
+ *
+ * `branchId` is left UNPREFIXED — decider/selector matching reads
+ * `child.branchId ?? child.id`. The input is never mutated (each node is a
+ * shallow clone).
+ */
+import { joinPath } from '../../ids/runtimeStageId.js';
+export function prefixNodeTree(node, prefix) {
+    if (!node)
+        return node;
+    const clone = { ...node };
+    clone.name = joinPath(prefix, node.name);
+    clone.id = joinPath(prefix, node.id);
+    if (clone.subflowId)
+        clone.subflowId = joinPath(prefix, clone.subflowId);
+    if (clone.next)
+        clone.next = prefixNodeTree(clone.next, prefix);
+    if (clone.children)
+        clone.children = clone.children.map((c) => prefixNodeTree(c, prefix));
+    return clone;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/engine/handlers/ParallelForEachHandler.d.ts

@@ -10,7 +10,7 @@
  * Almost everything here is existing machinery, wired together:
  *
  * - **Each branch is a generated SUBFLOW.** Its path segment is
- *   `<parentStageId>~<index>` (see `engine/branchSegment.ts`) — a subflowPath
+ *   `<parentStageId>~<index>` (see `ids/branchSegment.ts`) — a subflowPath
  *   segment in the grammar that already ships, NOT a new delimiter class. So a
  *   branch gets, for free: a fresh isolated `ExecutionRuntime` (branches cannot
  *   corrupt each other's in-flight state), the inputMapper seam for feeding the

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

@@ -10,7 +10,7 @@
  * Almost everything here is existing machinery, wired together:
  *
  * - **Each branch is a generated SUBFLOW.** Its path segment is
- *   `<parentStageId>~<index>` (see `engine/branchSegment.ts`) — a subflowPath
+ *   `<parentStageId>~<index>` (see `ids/branchSegment.ts`) — a subflowPath
  *   segment in the grammar that already ships, NOT a new delimiter class. So a
  *   branch gets, for free: a fresh isolated `ExecutionRuntime` (branches cannot
  *   corrupt each other's in-flight state), the inputMapper seam for feeding the
@@ -50,10 +50,10 @@
  * follows its fan-out event — unavoidable and honest: the result is not
  * knowable until the branches settle.
  */
+import { buildBranchSegment } from '../../ids/branchSegment.js';
 import { unwrapHandles } from '../../reactive/handles.js';
 import { IS_TYPED_SCOPE } from '../../reactive/types.js';
 import { createProtectedScope } from '../../scope/protection/createProtectedScope.js';
-import { buildBranchSegment } from '../branchSegment.js';
 export class ParallelForEachHandler {
     deps;
     childrenExecutor;
@@ -227,4 +227,4 @@ function notify(scope, method) {
     if (s && typeof s[method] === 'function')
         s[method]();
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ParallelForEachHandler.js","sourceRoot":"","sources":["../../../../../src/lib/engine/handlers/ParallelForEachHandler.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ParallelForEachHandler — dynamic fan-out: one branch per item, branch COUNT\n * decided at runtime from the payload.\n *\n * Design: docs/design/execution-control.md (D1 + D2). Round B builds exactly\n * that document.\n *\n * ## What this handler does NOT invent\n *\n * Almost everything here is existing machinery, wired together:\n *\n * - **Each branch is a generated SUBFLOW.** Its path segment is\n *   `<parentStageId>~<index>` (see `engine/branchSegment.ts`) — a subflowPath\n *   segment in the grammar that already ships, NOT a new delimiter class. So a\n *   branch gets, for free: a fresh isolated `ExecutionRuntime` (branches cannot\n *   corrupt each other's in-flight state), the inputMapper seam for feeding the\n *   item in, and — the point of the whole design — `parseRuntimeStageId`,\n *   `causalChain`, `sliceForKey` and `forwardSliceForKey` reading branch\n *   commits with ZERO changes, because the id shape IS the shipped shape.\n * - **The fan-out itself is `ChildrenExecutor`.** That is what makes the\n *   failure policy \"Parallel's existing failure policy\" rather than a second\n *   one: `failFast` → `Promise.all`, otherwise best-effort `Promise.allSettled`.\n *   It also fires `onFork` + `onStageExecuted('fork')` and bubbles a\n *   `PauseSignal` out of a branch, all unchanged.\n *\n * ## The laws this handler owns\n *\n * **Order is items order.** Results are assembled by index from the fan-out's\n * keyed results, never by completion order, and land as ONE array write on the\n * parent — so `into[i]` is always branch `i`'s result no matter which branch\n * finished first. A failed branch (best-effort mode) leaves `undefined` in its\n * slot; which branch failed is not reported here, because that gap is\n * pre-existing in the parallel fan-out and not this feature's to widen.\n *\n * **maxBranches truncates, and says so.** Items past the ceiling do not run.\n * The truncation is recorded in the stage's own commit-visible log and as a\n * flow message — bounded execution, stated, never silent.\n *\n * **Branch charts are re-registered on EVERY visit.** The generated segments\n * are stable across loop iterations, and subflow registration is normally\n * first-write-wins — which would mean a looping fan-out silently re-executing\n * iteration 1's branch charts forever, even when the factory returns different\n * charts. This handler overwrites instead. Per-iteration results stay\n * addressable through the mount's `runtimeStageId` key, exactly as they do for\n * a hand-authored looping subflow.\n *\n * **Event order.** `onStageStart` → the `items` read → `onFork` → branches →\n * the ordered-array write → `onStageEnd` → `onCommit`. The stage's own commit\n * therefore lands AFTER its `onFork`, which is the one place a stage's commit\n * follows its fan-out event — unavoidable and honest: the result is not\n * knowable until the branches settle.\n */\n\nimport type { StageContext } from '../../memory/StageContext.js';\nimport { unwrapHandles } from '../../reactive/handles.js';\nimport { IS_TYPED_SCOPE } from '../../reactive/types.js';\nimport { createProtectedScope } from '../../scope/protection/createProtectedScope.js';\nimport { buildBranchSegment } from '../branchSegment.js';\nimport type { StageNode } from '../graph/StageNode.js';\nimport type { TraversalContext } from '../narrative/types.js';\nimport type { BranchChart, HandlerDeps, NodeResultType, ParallelForEachConfig } from '../types.js';\nimport type { ChildrenExecutor } from './ChildrenExecutor.js';\n\n/**\n * Traverser-owned operations the handler needs. Passed as functions (not the\n * traverser) so the handler keeps the same no-back-reference shape as every\n * other handler in this directory.\n */\nexport interface ParallelForEachHooks<TOut = any, TScope = any> {\n  /** The traverser's `prefixNodeTree` — byte-twin of the builder's `_prefixNodeTree`. */\n  prefixNodeTree(node: StageNode<TOut, TScope>, prefix: string): StageNode<TOut, TScope>;\n  /** Register (OVERWRITING) a generated branch subflow + its stage functions. */\n  registerBranchSubflow(subflowId: string, root: StageNode<TOut, TScope>, chart: BranchChart): void;\n  /** Read a completed branch's final shared state, for the `subflowOutput ?? state` fallback. */\n  branchSharedState(subflowId: string): Record<string, unknown> | undefined;\n  /** Mirror the generated branches into the runtime structure, for visualization. */\n  recordBranchStructure(nodeId: string, branches: StageNode<TOut, TScope>[]): void;\n}\n\nexport class ParallelForEachHandler<TOut = any, TScope = any> {\n  constructor(\n    private deps: HandlerDeps<TOut, TScope>,\n    private childrenExecutor: ChildrenExecutor<TOut, TScope>,\n    private hooks: ParallelForEachHooks<TOut, TScope>,\n  ) {}\n\n  /**\n   * Run the fan-out to completion and commit the ordered results.\n   * Returns the results array (the stage's output).\n   */\n  async run(\n    node: StageNode<TOut, TScope>,\n    context: StageContext,\n    branchPath: string | undefined,\n    traversalContext: TraversalContext,\n  ): Promise<unknown[]> {\n    const config = node.parallelForEach as ParallelForEachConfig<unknown, TScope>;\n\n    // Same scope construction StageRunner performs, protection included: this\n    // stage has no user function, but `items(scope)` IS user code, so its reads\n    // are tracked and a stray assignment inside it is caught by the same\n    // protection every other stage gets. (TypedScope brings its own proxy.)\n    const rawScope = this.deps.scopeFactory(context, node.name, this.deps.readOnlyContext, this.deps.executionEnv);\n    const isTypedScope = rawScope && (rawScope as any)[IS_TYPED_SCOPE] === true;\n    const scope = isTypedScope\n      ? rawScope\n      : (createProtectedScope(rawScope as object, {\n          mode: this.deps.scopeProtectionMode,\n          stageName: node.name,\n        }) as TScope);\n    notify(rawScope, 'notifyStageStart');\n\n    const items = this.resolveItems(config, scope, node);\n    const total = items.length;\n    const branchCount = Math.min(total, config.maxBranches);\n    const truncated = total > branchCount;\n\n    context.addLog('parallelForEach', {\n      items: total,\n      branches: branchCount,\n      maxBranches: config.maxBranches,\n      truncated,\n      into: config.into,\n    });\n    if (truncated) {\n      // Stated, not silent — in the stage's own flow messages AND its logs above.\n      context.addFlowDebugMessage(\n        'children',\n        `maxBranches reached: running ${branchCount} of ${total} items (${total - branchCount} not run)`,\n        { count: branchCount },\n      );\n    }\n\n    let results: unknown[];\n    if (branchCount === 0) {\n      // Zero items = zero branches: no fan-out event, an empty ordered array.\n      results = [];\n    } else {\n      const branches = this.buildBranches(node, items, branchCount);\n      this.hooks.recordBranchStructure(node.id, branches);\n\n      // The fan-out node handed to ChildrenExecutor is a temp view carrying the\n      // generated branches (same shape `executeSelectedChildren` uses for its\n      // selected subset) — the shared graph node is never mutated, so a loop\n      // revisit regenerates cleanly.\n      const forkView: StageNode<TOut, TScope> = {\n        ...node,\n        children: branches,\n        ...(config.failFast !== undefined && { failFast: config.failFast }),\n      };\n\n      const childResults = await this.childrenExecutor.executeNodeChildren(\n        forkView,\n        context,\n        undefined,\n        branchPath,\n        traversalContext,\n      );\n\n      results = this.collectOrdered(node, branchCount, childResults);\n    }\n\n    this.writeResults(rawScope, context, config.into, results);\n    notify(rawScope, 'notifyStageEnd');\n    context.commit();\n\n    return results;\n  }\n\n  /**\n   * Evaluate the items selector against the live scope. A non-array return is\n   * a chart bug, not a runtime condition — it fails loudly, naming the stage.\n   *\n   * The selector reads the typed scope, so what it returns is usually the\n   * scope's own array HANDLE (a Proxy bound to the parent stage) and every\n   * `items[index]` an element handle. The items are about to cross into\n   * branch runtimes — closed over by `branch(item, index)` and seeded as the\n   * branch's `item` — so they are taken as VALUES here (`unwrapHandles`,\n   * reactive/handles.ts). 9.22.0–9.23.2 seeded the handle itself and every\n   * branch over an object item failed at its seed commit (DataCloneError).\n   */\n  private resolveItems(\n    config: ParallelForEachConfig<unknown, TScope>,\n    scope: TScope,\n    node: StageNode<TOut, TScope>,\n  ): readonly unknown[] {\n    const items = unwrapHandles(config.items(scope));\n    if (items === undefined || items === null) return [];\n    if (!Array.isArray(items)) {\n      throw new Error(\n        `parallelForEach '${node.id}': items() must return an array (got ${typeof items}). ` +\n          'Return [] to run zero branches.',\n      );\n    }\n    return items;\n  }\n\n  /** Generate one subflow-mount node per branch, registering each branch chart. */\n  private buildBranches(\n    node: StageNode<TOut, TScope>,\n    items: readonly unknown[],\n    branchCount: number,\n  ): StageNode<TOut, TScope>[] {\n    const config = node.parallelForEach as ParallelForEachConfig<unknown, TScope>;\n    const branches: StageNode<TOut, TScope>[] = [];\n\n    for (let index = 0; index < branchCount; index++) {\n      const item = items[index];\n      const subflowId = buildBranchSegment(node.id, index);\n      const chart = config.branch(item, index);\n      if (!chart || !chart.root) {\n        throw new Error(\n          `parallelForEach '${node.id}': branch(item, ${index}) must return a built chart ` +\n            '(the result of flowChart(...).build()).',\n        );\n      }\n\n      // Same prefixing a lazy subflow gets — the branch's inner ids become\n      // `<segment>/<id>`, so its stages address as `<segment>/<id>#<n>`.\n      const prefixedRoot = this.hooks.prefixNodeTree(chart.root as StageNode<TOut, TScope>, subflowId);\n      this.hooks.registerBranchSubflow(subflowId, prefixedRoot, chart);\n\n      branches.push({\n        name: `${node.name} [${index}]`,\n        id: subflowId,\n        isSubflowRoot: true,\n        subflowId,\n        subflowName: `${node.name} [${index}]`,\n        subflowMountOptions: {\n          // D1's \"inputMapper seam for feeding the item in\": the item is\n          // visible IN the branch's scope (and so in its commit log) as well as\n          // closed over by the factory — provenance beats a hidden closure.\n          inputMapper: () => ({ item, index }),\n        },\n      });\n    }\n\n    return branches;\n  }\n\n  /**\n   * Assemble results in ITEMS order — never completion order.\n   *\n   * The branch's value is its subflow output, falling back to the branch's\n   * final shared state (the TypedScope case, where stage functions return\n   * void) — the same `subflowOutput ?? sharedState` rule `SubflowExecutor`\n   * applies to an outputMapper.\n   */\n  private collectOrdered(\n    node: StageNode<TOut, TScope>,\n    branchCount: number,\n    childResults: Record<string, NodeResultType>,\n  ): unknown[] {\n    const ordered: unknown[] = [];\n    for (let index = 0; index < branchCount; index++) {\n      const subflowId = buildBranchSegment(node.id, index);\n      const entry = childResults[subflowId];\n      if (entry === undefined || entry.isError) {\n        // Best-effort mode: a failed branch keeps its SLOT (order is items\n        // order) with an undefined value. failFast mode never reaches here —\n        // the error already rejected the whole stage.\n        ordered.push(undefined);\n        continue;\n      }\n      ordered.push(entry.result ?? this.hooks.branchSharedState(subflowId));\n    }\n    return ordered;\n  }\n\n  /**\n   * Write the ordered array as ONE value on the parent scope.\n   *\n   * `$setValue` deliberately, where available: the TypedScope set trap\n   * JSON-round-trips every object write (Date→string, Map→{}), and branch\n   * results are exactly the kind of payload that would silently degrade.\n   */\n  private writeResults(rawScope: TScope, context: StageContext, into: string, results: unknown[]): void {\n    const s = rawScope as unknown as Record<string, unknown>;\n    if (typeof s?.$setValue === 'function') {\n      (s.$setValue as (key: string, value: unknown) => void)(into, results);\n      return;\n    }\n    if (typeof s?.setValue === 'function') {\n      (s.setValue as (key: string, value: unknown) => void)(into, results);\n      return;\n    }\n    // No facade (hand-rolled scope factory) — write straight to the frame.\n    context.setGlobal(into, results);\n  }\n}\n\n/** Fire a scope lifecycle notification if the scope supports it. */\nfunction notify(scope: unknown, method: 'notifyStageStart' | 'notifyStageEnd'): void {\n  const s = scope as Record<string, unknown> | undefined;\n  if (s && typeof s[method] === 'function') (s[method] as () => void)();\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ParallelForEachHandler.js","sourceRoot":"","sources":["../../../../../src/lib/engine/handlers/ParallelForEachHandler.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ParallelForEachHandler — dynamic fan-out: one branch per item, branch COUNT\n * decided at runtime from the payload.\n *\n * Design: docs/design/execution-control.md (D1 + D2). Round B builds exactly\n * that document.\n *\n * ## What this handler does NOT invent\n *\n * Almost everything here is existing machinery, wired together:\n *\n * - **Each branch is a generated SUBFLOW.** Its path segment is\n *   `<parentStageId>~<index>` (see `ids/branchSegment.ts`) — a subflowPath\n *   segment in the grammar that already ships, NOT a new delimiter class. So a\n *   branch gets, for free: a fresh isolated `ExecutionRuntime` (branches cannot\n *   corrupt each other's in-flight state), the inputMapper seam for feeding the\n *   item in, and — the point of the whole design — `parseRuntimeStageId`,\n *   `causalChain`, `sliceForKey` and `forwardSliceForKey` reading branch\n *   commits with ZERO changes, because the id shape IS the shipped shape.\n * - **The fan-out itself is `ChildrenExecutor`.** That is what makes the\n *   failure policy \"Parallel's existing failure policy\" rather than a second\n *   one: `failFast` → `Promise.all`, otherwise best-effort `Promise.allSettled`.\n *   It also fires `onFork` + `onStageExecuted('fork')` and bubbles a\n *   `PauseSignal` out of a branch, all unchanged.\n *\n * ## The laws this handler owns\n *\n * **Order is items order.** Results are assembled by index from the fan-out's\n * keyed results, never by completion order, and land as ONE array write on the\n * parent — so `into[i]` is always branch `i`'s result no matter which branch\n * finished first. A failed branch (best-effort mode) leaves `undefined` in its\n * slot; which branch failed is not reported here, because that gap is\n * pre-existing in the parallel fan-out and not this feature's to widen.\n *\n * **maxBranches truncates, and says so.** Items past the ceiling do not run.\n * The truncation is recorded in the stage's own commit-visible log and as a\n * flow message — bounded execution, stated, never silent.\n *\n * **Branch charts are re-registered on EVERY visit.** The generated segments\n * are stable across loop iterations, and subflow registration is normally\n * first-write-wins — which would mean a looping fan-out silently re-executing\n * iteration 1's branch charts forever, even when the factory returns different\n * charts. This handler overwrites instead. Per-iteration results stay\n * addressable through the mount's `runtimeStageId` key, exactly as they do for\n * a hand-authored looping subflow.\n *\n * **Event order.** `onStageStart` → the `items` read → `onFork` → branches →\n * the ordered-array write → `onStageEnd` → `onCommit`. The stage's own commit\n * therefore lands AFTER its `onFork`, which is the one place a stage's commit\n * follows its fan-out event — unavoidable and honest: the result is not\n * knowable until the branches settle.\n */\n\nimport { buildBranchSegment } from '../../ids/branchSegment.js';\nimport type { StageContext } from '../../memory/StageContext.js';\nimport { unwrapHandles } from '../../reactive/handles.js';\nimport { IS_TYPED_SCOPE } from '../../reactive/types.js';\nimport { createProtectedScope } from '../../scope/protection/createProtectedScope.js';\nimport type { StageNode } from '../graph/StageNode.js';\nimport type { TraversalContext } from '../narrative/types.js';\nimport type { BranchChart, HandlerDeps, NodeResultType, ParallelForEachConfig } from '../types.js';\nimport type { ChildrenExecutor } from './ChildrenExecutor.js';\n\n/**\n * Traverser-owned operations the handler needs. Passed as functions (not the\n * traverser) so the handler keeps the same no-back-reference shape as every\n * other handler in this directory.\n */\nexport interface ParallelForEachHooks<TOut = any, TScope = any> {\n  /** The traverser's `prefixNodeTree` — byte-twin of the builder's `_prefixNodeTree`. */\n  prefixNodeTree(node: StageNode<TOut, TScope>, prefix: string): StageNode<TOut, TScope>;\n  /** Register (OVERWRITING) a generated branch subflow + its stage functions. */\n  registerBranchSubflow(subflowId: string, root: StageNode<TOut, TScope>, chart: BranchChart): void;\n  /** Read a completed branch's final shared state, for the `subflowOutput ?? state` fallback. */\n  branchSharedState(subflowId: string): Record<string, unknown> | undefined;\n  /** Mirror the generated branches into the runtime structure, for visualization. */\n  recordBranchStructure(nodeId: string, branches: StageNode<TOut, TScope>[]): void;\n}\n\nexport class ParallelForEachHandler<TOut = any, TScope = any> {\n  constructor(\n    private deps: HandlerDeps<TOut, TScope>,\n    private childrenExecutor: ChildrenExecutor<TOut, TScope>,\n    private hooks: ParallelForEachHooks<TOut, TScope>,\n  ) {}\n\n  /**\n   * Run the fan-out to completion and commit the ordered results.\n   * Returns the results array (the stage's output).\n   */\n  async run(\n    node: StageNode<TOut, TScope>,\n    context: StageContext,\n    branchPath: string | undefined,\n    traversalContext: TraversalContext,\n  ): Promise<unknown[]> {\n    const config = node.parallelForEach as ParallelForEachConfig<unknown, TScope>;\n\n    // Same scope construction StageRunner performs, protection included: this\n    // stage has no user function, but `items(scope)` IS user code, so its reads\n    // are tracked and a stray assignment inside it is caught by the same\n    // protection every other stage gets. (TypedScope brings its own proxy.)\n    const rawScope = this.deps.scopeFactory(context, node.name, this.deps.readOnlyContext, this.deps.executionEnv);\n    const isTypedScope = rawScope && (rawScope as any)[IS_TYPED_SCOPE] === true;\n    const scope = isTypedScope\n      ? rawScope\n      : (createProtectedScope(rawScope as object, {\n          mode: this.deps.scopeProtectionMode,\n          stageName: node.name,\n        }) as TScope);\n    notify(rawScope, 'notifyStageStart');\n\n    const items = this.resolveItems(config, scope, node);\n    const total = items.length;\n    const branchCount = Math.min(total, config.maxBranches);\n    const truncated = total > branchCount;\n\n    context.addLog('parallelForEach', {\n      items: total,\n      branches: branchCount,\n      maxBranches: config.maxBranches,\n      truncated,\n      into: config.into,\n    });\n    if (truncated) {\n      // Stated, not silent — in the stage's own flow messages AND its logs above.\n      context.addFlowDebugMessage(\n        'children',\n        `maxBranches reached: running ${branchCount} of ${total} items (${total - branchCount} not run)`,\n        { count: branchCount },\n      );\n    }\n\n    let results: unknown[];\n    if (branchCount === 0) {\n      // Zero items = zero branches: no fan-out event, an empty ordered array.\n      results = [];\n    } else {\n      const branches = this.buildBranches(node, items, branchCount);\n      this.hooks.recordBranchStructure(node.id, branches);\n\n      // The fan-out node handed to ChildrenExecutor is a temp view carrying the\n      // generated branches (same shape `executeSelectedChildren` uses for its\n      // selected subset) — the shared graph node is never mutated, so a loop\n      // revisit regenerates cleanly.\n      const forkView: StageNode<TOut, TScope> = {\n        ...node,\n        children: branches,\n        ...(config.failFast !== undefined && { failFast: config.failFast }),\n      };\n\n      const childResults = await this.childrenExecutor.executeNodeChildren(\n        forkView,\n        context,\n        undefined,\n        branchPath,\n        traversalContext,\n      );\n\n      results = this.collectOrdered(node, branchCount, childResults);\n    }\n\n    this.writeResults(rawScope, context, config.into, results);\n    notify(rawScope, 'notifyStageEnd');\n    context.commit();\n\n    return results;\n  }\n\n  /**\n   * Evaluate the items selector against the live scope. A non-array return is\n   * a chart bug, not a runtime condition — it fails loudly, naming the stage.\n   *\n   * The selector reads the typed scope, so what it returns is usually the\n   * scope's own array HANDLE (a Proxy bound to the parent stage) and every\n   * `items[index]` an element handle. The items are about to cross into\n   * branch runtimes — closed over by `branch(item, index)` and seeded as the\n   * branch's `item` — so they are taken as VALUES here (`unwrapHandles`,\n   * reactive/handles.ts). 9.22.0–9.23.2 seeded the handle itself and every\n   * branch over an object item failed at its seed commit (DataCloneError).\n   */\n  private resolveItems(\n    config: ParallelForEachConfig<unknown, TScope>,\n    scope: TScope,\n    node: StageNode<TOut, TScope>,\n  ): readonly unknown[] {\n    const items = unwrapHandles(config.items(scope));\n    if (items === undefined || items === null) return [];\n    if (!Array.isArray(items)) {\n      throw new Error(\n        `parallelForEach '${node.id}': items() must return an array (got ${typeof items}). ` +\n          'Return [] to run zero branches.',\n      );\n    }\n    return items;\n  }\n\n  /** Generate one subflow-mount node per branch, registering each branch chart. */\n  private buildBranches(\n    node: StageNode<TOut, TScope>,\n    items: readonly unknown[],\n    branchCount: number,\n  ): StageNode<TOut, TScope>[] {\n    const config = node.parallelForEach as ParallelForEachConfig<unknown, TScope>;\n    const branches: StageNode<TOut, TScope>[] = [];\n\n    for (let index = 0; index < branchCount; index++) {\n      const item = items[index];\n      const subflowId = buildBranchSegment(node.id, index);\n      const chart = config.branch(item, index);\n      if (!chart || !chart.root) {\n        throw new Error(\n          `parallelForEach '${node.id}': branch(item, ${index}) must return a built chart ` +\n            '(the result of flowChart(...).build()).',\n        );\n      }\n\n      // Same prefixing a lazy subflow gets — the branch's inner ids become\n      // `<segment>/<id>`, so its stages address as `<segment>/<id>#<n>`.\n      const prefixedRoot = this.hooks.prefixNodeTree(chart.root as StageNode<TOut, TScope>, subflowId);\n      this.hooks.registerBranchSubflow(subflowId, prefixedRoot, chart);\n\n      branches.push({\n        name: `${node.name} [${index}]`,\n        id: subflowId,\n        isSubflowRoot: true,\n        subflowId,\n        subflowName: `${node.name} [${index}]`,\n        subflowMountOptions: {\n          // D1's \"inputMapper seam for feeding the item in\": the item is\n          // visible IN the branch's scope (and so in its commit log) as well as\n          // closed over by the factory — provenance beats a hidden closure.\n          inputMapper: () => ({ item, index }),\n        },\n      });\n    }\n\n    return branches;\n  }\n\n  /**\n   * Assemble results in ITEMS order — never completion order.\n   *\n   * The branch's value is its subflow output, falling back to the branch's\n   * final shared state (the TypedScope case, where stage functions return\n   * void) — the same `subflowOutput ?? sharedState` rule `SubflowExecutor`\n   * applies to an outputMapper.\n   */\n  private collectOrdered(\n    node: StageNode<TOut, TScope>,\n    branchCount: number,\n    childResults: Record<string, NodeResultType>,\n  ): unknown[] {\n    const ordered: unknown[] = [];\n    for (let index = 0; index < branchCount; index++) {\n      const subflowId = buildBranchSegment(node.id, index);\n      const entry = childResults[subflowId];\n      if (entry === undefined || entry.isError) {\n        // Best-effort mode: a failed branch keeps its SLOT (order is items\n        // order) with an undefined value. failFast mode never reaches here —\n        // the error already rejected the whole stage.\n        ordered.push(undefined);\n        continue;\n      }\n      ordered.push(entry.result ?? this.hooks.branchSharedState(subflowId));\n    }\n    return ordered;\n  }\n\n  /**\n   * Write the ordered array as ONE value on the parent scope.\n   *\n   * `$setValue` deliberately, where available: the TypedScope set trap\n   * JSON-round-trips every object write (Date→string, Map→{}), and branch\n   * results are exactly the kind of payload that would silently degrade.\n   */\n  private writeResults(rawScope: TScope, context: StageContext, into: string, results: unknown[]): void {\n    const s = rawScope as unknown as Record<string, unknown>;\n    if (typeof s?.$setValue === 'function') {\n      (s.$setValue as (key: string, value: unknown) => void)(into, results);\n      return;\n    }\n    if (typeof s?.setValue === 'function') {\n      (s.setValue as (key: string, value: unknown) => void)(into, results);\n      return;\n    }\n    // No facade (hand-rolled scope factory) — write straight to the frame.\n    context.setGlobal(into, results);\n  }\n}\n\n/** Fire a scope lifecycle notification if the scope supports it. */\nfunction notify(scope: unknown, method: 'notifyStageStart' | 'notifyStageEnd'): void {\n  const s = scope as Record<string, unknown> | undefined;\n  if (s && typeof s[method] === 'function') (s[method] as () => void)();\n}\n"]}

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

@@ -61,7 +61,7 @@
  * root with its inputMapper (its earlier stages recompute what the capture
  * would have held), exactly as 9.27.0 did.
  */
-import { PauseSignal } from '../../pause/types.js';
+import { isPausedExecution, PauseSignal } from '../../pause/types.js';
 export class ResumeEntry {
     /**
      * Where the resumed TOP-LEVEL traversal starts: the stand-in (a top-level
@@ -217,6 +217,10 @@ export function raiseQueuedPause(queue) {
     const [first, ...rest] = queue;
     const { pause, level } = first;
     const signal = new PauseSignal(pause.pauseData, pause.pausedStageId, pause.pausedBy);
+    // The sibling paused in an EARLIER run: its own execution, not this run's.
+    if (isPausedExecution(pause.pausedExecution)) {
+        signal.stampExecution(pause.pausedExecution.runtimeStageId, pause.pausedExecution.runId);
+    }
     const below = pause.subflowPath.slice(level);
     for (let i = below.length - 1; i >= 0; i--) {
         const state = ownEntry(pause.subflowStates, below[i]);
@@ -462,10 +466,15 @@ function validPendingPause(raw, n) {
         subflowStates: states ?? {},
         ...(record.pauseData !== undefined && { pauseData: record.pauseData }),
         ...(record.pausedBy === 'interrupt' && { pausedBy: 'interrupt' }),
+        // A record, never a plan input: kept only when well-formed (an older or
+        // hand-edited entry simply resumes without a link).
+        ...(isPausedExecution(record.pausedExecution) && {
+            pausedExecution: { runId: record.pausedExecution.runId, runtimeStageId: record.pausedExecution.runtimeStageId },
+        }),
     };
 }
 /** `record[key]` only when it is the record's OWN property — never through the prototype chain. */
 function ownEntry(record, key) {
     return record && Object.prototype.hasOwnProperty.call(record, key) ? record[key] : undefined;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ResumeEntry.js","sourceRoot":"","sources":["../../../../../src/lib/engine/handlers/ResumeEntry.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ResumeEntry — the resume's ONE-SHOT re-entry (M2, pause/resume).\n *\n * A resume has to get back to a stage in the middle of a chart. It does that\n * with a small synthetic structure: a stand-in for the paused stage (the\n * stage's own node with its function swapped for the resume half — or, for an\n * `interrupt()` pause, for its own function with the answer deposited), and,\n * for a pause inside subflows, the checkpoint's capture of each subflow's\n * state on the way down.\n *\n * THE LAW: that structure is used EXACTLY ONCE, for the re-entry. The stand-in\n * is where the resumed traversal STARTS (or where the leaf subflow's traversal\n * starts) — it is never a node any id can resolve to. Each subflow on the pause\n * path takes its seed and its entry point on its FIRST entry and never again.\n * After that the run belongs to the real chart: every loop target, every later\n * subflow entry (real root, inputMapper runs), every re-visit of the paused\n * stage (which pauses again) resolves against the chart as built.\n *\n * ONE RULE AT EVERY LEVEL — what runs after the entry. On the original run,\n * whatever DISPATCHED the paused stage (or the mount of the next subflow on\n * the path) — a decider, a selector, a fork — ran its own continuation once\n * that child's chain ended: the decider's `next`, the fork's join. A resume\n * enters AT the child, so that continuation must be carried: the entry is\n * the child with the enclosing dispatcher's continuation attached at the end\n * of its own chain (`{ ...child, next: dispatcher.next }` for a chart the\n * builder made). It is read from the CHART, level by level — never from the\n * checkpoint, so an edited checkpoint cannot redirect a run — and it lands\n * at the level it belongs to: a top-level decider's `next` runs at the top\n * level, after the subflow's outputMapper, not inside the subflow.\n *\n * PARALLEL SIBLINGS THAT PAUSED TOO (9.28.0). When two children of one\n * fan-out paused, the checkpoint asks the first and carries the others\n * (`FlowchartCheckpoint.pendingPauses`). At that fan-out's level the entry is\n * the child's own chain only — no join — and once it ends, the next sibling's\n * pause is raised again as it was (its question, its captured state), without\n * re-running anything. The join runs only when the last sibling is resumed.\n *\n * Before 9.28.0 the structure stayed in force for the whole resumed run — the\n * traversal was ROOTED at the stand-in (so a loop back to the paused id re-ran\n * the resume half, and a loop target upstream of the resume point was\n * unreachable: one stage ran, then the run ended silently), and the leaf\n * subflow's root was SWAPPED for the stand-in in the subflow dictionary (so a\n * later entry into it would re-run the resume half on a stale seed).\n *\n * @example\n * ```typescript\n * // What FlowChartExecutor.resume() builds for a pause at 'sf-a/sf-b/ask'\n * // (subflowPath ['sf-a', 'sf-a/sf-b']), 'sf-a/sf-b' mounted as a decider\n * // branch inside sf-a whose decider continues to 'sf-a/after':\n * const entry = ResumeEntry.plan({ root, subflows, path, captures, standIn });\n * entry.start;                     // the top-level mount of 'sf-a'\n * entry.enterSubflow('sf-a');      // { seed: sf-a's capture, entry: { ...mount of 'sf-a/sf-b', next: sf-a/after } }\n * entry.enterSubflow('sf-a/sf-b'); // { seed: sf-b's capture, entry: the stand-in }\n * entry.enterSubflow('sf-a/sf-b'); // undefined — a later entry is an ordinary one\n * ```\n *\n * A pause two (or more) subflows deep therefore re-enters each outer subflow\n * AT the mount of the next one — the outer subflow's stages before that mount\n * do not run again (they did before 9.28.0). The one exception is a degraded\n * checkpoint missing an outer subflow's capture: that subflow re-runs from its\n * root with its inputMapper (its earlier stages recompute what the capture\n * would have held), exactly as 9.27.0 did.\n */\n\nimport type { PendingPause } from '../../pause/types.js';\nimport { PauseSignal } from '../../pause/types.js';\nimport type { StageNode } from '../graph/StageNode.js';\n\n/**\n * A parallel sibling's pause, queued at the level of its fan-out: raised\n * again there once the resumed child's chain ends (see {@link raiseQueuedPause}).\n */\nexport interface QueuedPause {\n  /** The sibling's pause as the checkpoint carries it — its path from the top. */\n  readonly pause: PendingPause;\n  /** How many subflows deep the fan-out sits (0 = the top level). */\n  readonly level: number;\n  /** The sibling's paused stage's name, for the `onPause` event. */\n  readonly stageName: string;\n}\n\n/** One subflow boundary on the way back to a paused stage. */\nexport interface ResumeHop<TOut = any, TScope = any> {\n  /** The path-prefixed subflow id (a `FlowchartCheckpoint.subflowPath` entry). */\n  readonly subflowId: string;\n  /**\n   * The subflow's state at the pause (`checkpoint.subflowStates[subflowId]`).\n   * Seeds the nested runtime INSTEAD of the inputMapper's values — the capture\n   * already holds the post-input, pre-pause memory (the inputMapper still\n   * runs, for the stages' read-only args only). Absent when the checkpoint\n   * holds no capture for this subflow; the inputMapper then seeds it, as on\n   * any entry.\n   */\n  readonly seed?: Record<string, unknown>;\n  /**\n   * Where this subflow's traversal starts on the re-entry: the mount of the\n   * next subflow on the path, or — on the last hop — the paused stage's\n   * stand-in, each with its dispatcher's continuation attached (see the\n   * module doc). Absent: the subflow's own root — a seed-only hop (see\n   * {@link ResumeEntry.fromCaptures}), or an outer subflow whose capture the\n   * checkpoint lacks.\n   */\n  readonly entry?: StageNode<TOut, TScope>;\n  /**\n   * Pauses of parallel siblings whose fan-out sits in THIS subflow, raised in\n   * order once `entry`'s chain ends (the first is raised, the rest wait\n   * behind it). Absent when no sibling is waiting here.\n   */\n  readonly pendingPauses?: readonly QueuedPause[];\n}\n\nexport class ResumeEntry<TOut = any, TScope = any> {\n  /**\n   * Where the resumed TOP-LEVEL traversal starts: the stand-in (a top-level\n   * pause) or the mount of the first subflow on the path — each with its\n   * dispatcher's continuation attached. `undefined` for a seed-only entry —\n   * the traversal starts at its root.\n   */\n  readonly start: StageNode<TOut, TScope> | undefined;\n  /** Sibling pauses whose fan-out sits at the TOP level — raised once `start`'s chain ends. */\n  readonly startPendingPauses: readonly QueuedPause[] | undefined;\n  /**\n   * How many stage executions the resumed run makes before the stand-in runs\n   * — one per subflow on the path, each entered at its mount — so the\n   * executor's `onResume` names the stand-in's own `runtimeStageId`.\n   * `undefined` when it cannot be known before the run: an outer subflow\n   * missing its capture re-runs from its root.\n   */\n  readonly stepsBeforeStandIn: number | undefined;\n  /** Hops not taken yet, by subflow id. A hop leaves this map when it is taken. */\n  private readonly pending: Map<string, ResumeHop<TOut, TScope>>;\n\n  private constructor(\n    start: StageNode<TOut, TScope> | undefined,\n    hops: readonly ResumeHop<TOut, TScope>[],\n    startPendingPauses?: readonly QueuedPause[],\n    stepsBeforeStandIn?: number,\n  ) {\n    this.start = start;\n    this.startPendingPauses = startPendingPauses;\n    this.stepsBeforeStandIn = stepsBeforeStandIn;\n    this.pending = new Map(hops.map((hop) => [hop.subflowId, hop]));\n  }\n\n  /**\n   * Plan the re-entry of a paused chart. Every mount on the path, every\n   * dispatcher continuation and every waiting sibling is resolved HERE,\n   * against the chart as built, before a single stage runs — so a checkpoint\n   * whose path the chart cannot walk is refused up front instead of resuming\n   * into the wrong shape.\n   *\n   * @param args - `root` and `subflows`: the chart as built\n   *   (`FlowChart.root`, `FlowChart.subflows`); `path`:\n   *   `checkpoint.subflowPath`, outermost first; `captures`:\n   *   `checkpoint.subflowStates` (a detached copy); `standIn`: the node that\n   *   runs the resume half — the paused stage's own node, function swapped\n   *   (its continuation is attached here); `pendingPauses`:\n   *   `checkpoint.pendingPauses` (a detached copy).\n   * @throws when a subflow on the path is missing, mounted more than once, or\n   *   its mount cannot be reached from the enclosing graph; or when a pending\n   *   pause is malformed or is not a parallel sibling of the paused stage\n   */\n  static plan<TOut, TScope>(args: {\n    root: StageNode<TOut, TScope>;\n    subflows: Record<string, { root: StageNode<TOut, TScope> }> | undefined;\n    path: readonly string[];\n    captures: Record<string, Record<string, unknown>> | undefined;\n    standIn: StageNode<TOut, TScope>;\n    pendingPauses?: readonly PendingPause[];\n  }): ResumeEntry<TOut, TScope> {\n    const { root, subflows, path, captures, standIn } = args;\n    const chart = new ChartIndex<TOut, TScope>();\n\n    // 1. Walk the path: the graph of every level, the mount of every subflow.\n    const graphs: StageNode<TOut, TScope>[] = [root];\n    const mounts: StageNode<TOut, TScope>[] = [];\n    for (let i = 0; i < path.length; i++) {\n      const subflowId = path[i];\n      mounts.push(chart.onlyMount(graphs[i], subflowId, i === 0 ? 'the flowchart' : `subflow '${path[i - 1]}'`));\n      // Own entries only: a path segment is data from a stored checkpoint,\n      // and `'__proto__'` must not resolve through the prototype chain.\n      const definition = ownEntry(subflows, subflowId);\n      if (!definition) {\n        throw new Error(\n          `Cannot resume: subflow '${subflowId}' is not registered in the flowchart. ` +\n            'The chart may have changed since the checkpoint was created.',\n        );\n      }\n      graphs.push(definition.root);\n    }\n    const leafLevel = path.length;\n    // The paused stage's REAL node — whose dispatcher the stand-in's\n    // continuation comes from. (The executor already found it; a direct\n    // caller's stand-in that is not in the leaf graph simply has none.)\n    const paused = chart.stage(graphs[leafLevel], standIn.id);\n\n    // 2. Queue every waiting sibling pause at the level of its fan-out.\n    const queues = queueSiblingPauses(args.pendingPauses, { chart, subflows, root, path, graphs, mounts, paused });\n\n    // 3. The one-shot entry of every level: the child, then its dispatcher's\n    //    continuation — up to the fan-out when siblings wait there.\n    const childAt = (level: number) => (level < leafLevel ? mounts[level] : paused);\n    const entryAt = (level: number): StageNode<TOut, TScope> => {\n      const child = childAt(level);\n      const replacement = level < leafLevel ? mounts[level] : standIn;\n      if (!child) return replacement;\n      return chart.entry(graphs[level], child, replacement, queues[level]?.fanOut);\n    };\n    // 4. The hops. A subflow with no capture is entered at its ROOT with its\n    //    inputMapper (its earlier stages recompute what the capture held) —\n    //    except the leaf, whose entry is always the stand-in: re-running it\n    //    from its root would ask again and lose the answer.\n    const hops: ResumeHop<TOut, TScope>[] = [];\n    let everyLevelAtItsEntry = true;\n    for (let i = 0; i < path.length; i++) {\n      const subflowId = path[i];\n      const seed = ownEntry(captures, subflowId);\n      const isLeafHop = i === path.length - 1;\n      if (seed === undefined && !isLeafHop) {\n        everyLevelAtItsEntry = false;\n        hops.push({ subflowId });\n        continue;\n      }\n      const waiting = queues[i + 1]?.pauses;\n      hops.push({\n        subflowId,\n        ...(seed !== undefined && { seed }),\n        entry: entryAt(i + 1),\n        ...(waiting && { pendingPauses: waiting }),\n      });\n    }\n    // Every level entered at its entry: one execution (the mount) per level\n    // runs before the stand-in.\n    return new ResumeEntry(entryAt(0), hops, queues[0]?.pauses, everyLevelAtItsEntry ? path.length : undefined);\n  }\n\n  /**\n   * A seed-only entry: each capture seeds the FIRST entry into its subflow,\n   * which then starts at its own root. What the deprecated\n   * `subflowStatesForResume` option (TraverserOptions / HandlerDeps) means\n   * since 9.28.0 — the same one-shot law, without a stand-in or a path.\n   */\n  static fromCaptures<TOut, TScope>(captures: Record<string, Record<string, unknown>>): ResumeEntry<TOut, TScope> {\n    return new ResumeEntry<TOut, TScope>(\n      undefined,\n      Object.entries(captures).map(([subflowId, seed]) => ({ subflowId, seed })),\n    );\n  }\n\n  /**\n   * The re-entry into `subflowId`, taken — or `undefined` when this entry is\n   * an ordinary one (the subflow is off the pause path, or its hop was already\n   * taken). ONE-SHOT: a hop is returned at most once, so a second entry into\n   * the same subflow (a loop passing its mount again) runs the real subflow\n   * from its real root with its inputMapper.\n   */\n  enterSubflow(subflowId: string): ResumeHop<TOut, TScope> | undefined {\n    const hop = this.pending.get(subflowId);\n    if (hop !== undefined) this.pending.delete(subflowId);\n    return hop;\n  }\n\n  /** `true` once every hop has been taken — the rest of the run is ordinary. */\n  get spent(): boolean {\n    return this.pending.size === 0;\n  }\n}\n\n// ── Raising a waiting sibling's pause ────────────────────────────────────────\n\n/**\n * Queue `queue` behind a pause passing through its level: a pause raised\n * while siblings still wait must carry them to its checkpoint. Each path is\n * cut to that level — the bubble-up prepends the levels above.\n */\nexport function queueBehind(signal: PauseSignal, queue: readonly QueuedPause[]): void {\n  for (const { pause, level } of queue) {\n    signal.addPendingPause({ ...pause, subflowPath: pause.subflowPath.slice(level) });\n  }\n}\n\n/**\n * The first waiting sibling's pause, raised again at its fan-out's level —\n * exactly as it bubbled up to that level the first time (its stage, its\n * question, its own subflow captures), nothing re-run; the rest of the queue\n * waits behind it. The subflows ABOVE the fan-out capture themselves afresh\n * as it bubbles up, so they carry what the resumed child wrote.\n */\nexport function raiseQueuedPause(queue: readonly QueuedPause[]): PauseSignal {\n  const [first, ...rest] = queue;\n  const { pause, level } = first;\n  const signal = new PauseSignal(pause.pauseData, pause.pausedStageId, pause.pausedBy);\n  const below = pause.subflowPath.slice(level);\n  for (let i = below.length - 1; i >= 0; i--) {\n    const state = ownEntry(pause.subflowStates, below[i]);\n    if (state !== undefined) signal.captureSubflowScope(below[i], state);\n    signal.prependSubflow(below[i]);\n  }\n  queueBehind(signal, rest);\n  return signal;\n}\n\n// ── Reading the chart ────────────────────────────────────────────────────────\n\n/**\n * The node that mounts `subflowId`, found by DFS from `start` over `next` and\n * `children` (loop-ref stubs skipped — they share their target's id and carry\n * nothing). Cycle-safe (visited by identity, so an absent id terminates too);\n * first match in DFS pre-order (children before `next`, like the builder).\n */\nexport function findMount<TOut, TScope>(\n  start: StageNode<TOut, TScope>,\n  subflowId: string,\n): StageNode<TOut, TScope> | undefined {\n  for (const node of dispatcherIndex(start).keys()) {\n    if (node.subflowId === subflowId) return node;\n  }\n  return undefined;\n}\n\n/**\n * Every real node of one level's graph, in DFS pre-order, mapped to the\n * DISPATCHER whose child-chain holds it — the node whose `children` it\n * descends from (a decider, a selector, a fork) — or `undefined` for a node\n * on the level's own spine. Loop stubs are skipped; visited by identity, so\n * two mounts sharing an id are both indexed and a cycle terminates.\n */\nfunction dispatcherIndex<TOut, TScope>(\n  root: StageNode<TOut, TScope>,\n): Map<StageNode<TOut, TScope>, StageNode<TOut, TScope> | undefined> {\n  const index = new Map<StageNode<TOut, TScope>, StageNode<TOut, TScope> | undefined>();\n  const stack: Array<[StageNode<TOut, TScope>, StageNode<TOut, TScope> | undefined]> = [[root, undefined]];\n  for (let top = stack.pop(); top !== undefined; top = stack.pop()) {\n    const [node, dispatcher] = top;\n    if (node.isLoopRef || index.has(node)) continue;\n    index.set(node, dispatcher);\n    // LIFO: push `next` first and children reversed, so children are visited\n    // before `next` and the first child first — pre-order, like the builder.\n    if (node.next) stack.push([node.next, dispatcher]);\n    if (node.children) {\n      for (let i = node.children.length - 1; i >= 0; i--) stack.push([node.children[i], node]);\n    }\n  }\n  return index;\n}\n\n/** One plan's view of the chart: each level's index built once. */\nclass ChartIndex<TOut, TScope> {\n  private readonly indexes = new Map<\n    StageNode<TOut, TScope>,\n    Map<StageNode<TOut, TScope>, StageNode<TOut, TScope> | undefined>\n  >();\n\n  private of(root: StageNode<TOut, TScope>) {\n    let index = this.indexes.get(root);\n    if (!index) {\n      index = dispatcherIndex(root);\n      this.indexes.set(root, index);\n    }\n    return index;\n  }\n\n  /** Every mount of `subflowId` in `root`'s graph, in DFS pre-order. */\n  mountsOf(root: StageNode<TOut, TScope>, subflowId: string): StageNode<TOut, TScope>[] {\n    return [...this.of(root).keys()].filter((node) => node.subflowId === subflowId);\n  }\n\n  /** The one mount of `subflowId` in `root`'s graph — refused when absent or ambiguous. */\n  onlyMount(root: StageNode<TOut, TScope>, subflowId: string, graphName: string): StageNode<TOut, TScope> {\n    const found = this.mountsOf(root, subflowId);\n    if (found.length === 0) {\n      throw new Error(\n        `Cannot resume: the mount of subflow '${subflowId}' is not reachable from ${graphName}. ` +\n          \"The checkpoint's subflowPath does not match this chart — it may have changed since the checkpoint was created.\",\n      );\n    }\n    if (found.length > 1) {\n      throw new Error(\n        `Cannot resume: subflow '${subflowId}' is mounted more than once in ${graphName} ` +\n          `(${found.map((node) => `'${node.name}'`).join(', ')}), and a checkpoint's subflowPath cannot say which ` +\n          'mount paused. Give each mount its own subflow id to make a pause inside it resumable.',\n      );\n    }\n    return found[0];\n  }\n\n  /** The real stage `id` in `root`'s graph (first in DFS pre-order), if any. */\n  stage(root: StageNode<TOut, TScope>, id: string): StageNode<TOut, TScope> | undefined {\n    for (const node of this.of(root).keys()) if (node.id === id) return node;\n    return undefined;\n  }\n\n  /** The dispatcher whose child-chain holds `node` in `root`'s graph (`undefined` on the spine). */\n  dispatcherOf(root: StageNode<TOut, TScope>, node: StageNode<TOut, TScope>): StageNode<TOut, TScope> | undefined {\n    return this.of(root).get(node);\n  }\n\n  /**\n   * The one-shot entry for `child` (a mount on the path, or the paused stage)\n   * in `root`'s graph: `replacement` (the node that runs — the mount itself,\n   * or the stand-in) with what ran after `child`'s chain on the original run\n   * attached where that chain ends — `{ ...child, next: dispatcher.next }` for\n   * a chart the builder made:\n   *\n   *   • on the level's spine: nothing to attach — the spine goes on by itself;\n   *   • a DECIDER's or SELECTOR's branch: the dispatcher's `next`;\n   *   • a FORK child: the fork's `next` — its join.\n   *\n   * Past a dispatcher with no `next`, the walk goes on OUTWARD to the one\n   * enclosing it. It stops at `stopAt` — the fan-out where siblings still\n   * wait, whose join must not run yet. Nothing to attach: `replacement`\n   * itself.\n   */\n  entry(\n    root: StageNode<TOut, TScope>,\n    child: StageNode<TOut, TScope>,\n    replacement: StageNode<TOut, TScope>,\n    stopAt: StageNode<TOut, TScope> | undefined,\n  ): StageNode<TOut, TScope> {\n    return appendAtChainEnd(replacement, this.after(root, child, stopAt));\n  }\n\n  /**\n   * What runs once `node`'s chain ends: its dispatcher's `next` chain, then —\n   * where THAT ends — the continuation of the dispatcher enclosing it, outward,\n   * up to `stopAt` (exclusive). `undefined` on the spine.\n   */\n  private after(\n    root: StageNode<TOut, TScope>,\n    node: StageNode<TOut, TScope>,\n    stopAt: StageNode<TOut, TScope> | undefined,\n  ): StageNode<TOut, TScope> | undefined {\n    const dispatcher = this.dispatcherOf(root, node);\n    if (dispatcher === undefined || dispatcher === stopAt) return undefined;\n    const outer = this.after(root, dispatcher, stopAt);\n    return dispatcher.next ? appendAtChainEnd(dispatcher.next, outer) : outer;\n  }\n}\n\n/**\n * `start`'s chain with `after` attached where it ends — the chain's nodes\n * copied on the way (never registered anywhere: ids still resolve to the real\n * nodes). A chain that ends in a loop stub (or loops back on itself) is\n * returned as is: control leaves it through the loop, never \"after\" it.\n */\nfunction appendAtChainEnd<TOut, TScope>(\n  start: StageNode<TOut, TScope>,\n  after: StageNode<TOut, TScope> | undefined,\n): StageNode<TOut, TScope> {\n  if (after === undefined) return start;\n  const chain: StageNode<TOut, TScope>[] = [];\n  const seen = new Set<StageNode<TOut, TScope>>();\n  for (let node: StageNode<TOut, TScope> | undefined = start; node !== undefined; node = node.next) {\n    if (node.isLoopRef || seen.has(node)) return start;\n    seen.add(node);\n    chain.push(node);\n  }\n  let next = after;\n  for (let i = chain.length - 1; i >= 0; i--) next = { ...chain[i], next };\n  return next;\n}\n\n// ── Waiting siblings ─────────────────────────────────────────────────────────\n\n/** The sibling pauses waiting at one level, and the fan-out they wait in. */\ninterface LevelQueue<TOut, TScope> {\n  readonly fanOut: StageNode<TOut, TScope>;\n  readonly pauses: QueuedPause[];\n}\n\n/**\n * Validate `checkpoint.pendingPauses` (untrusted input) and queue each at the\n * level of its fan-out: the depth where its path parts from the paused\n * stage's. There, the paused stage's child (a mount on the path, or the stage\n * itself) and the sibling's must both hang off ONE parallel dispatcher — a\n * fork or a selector — or the record is not a sibling and the resume is\n * refused rather than asked a question the chart could not have raised.\n */\nfunction queueSiblingPauses<TOut, TScope>(\n  pending: readonly PendingPause[] | undefined,\n  at: {\n    chart: ChartIndex<TOut, TScope>;\n    subflows: Record<string, { root: StageNode<TOut, TScope> }> | undefined;\n    root: StageNode<TOut, TScope>;\n    path: readonly string[];\n    graphs: readonly StageNode<TOut, TScope>[];\n    mounts: readonly StageNode<TOut, TScope>[];\n    paused: StageNode<TOut, TScope> | undefined;\n  },\n): Array<LevelQueue<TOut, TScope> | undefined> {\n  const queues: Array<LevelQueue<TOut, TScope> | undefined> = [];\n  if (pending === undefined) return queues;\n  if (!Array.isArray(pending)) throw new Error('Invalid checkpoint: pendingPauses must be an array.');\n  const { chart, subflows, root, path, graphs, mounts, paused } = at;\n  const seen = new Set<string>();\n\n  pending.forEach((raw: unknown, n) => {\n    const pause = validPendingPause(raw, n);\n    // One record per paused sibling: a repeat would ask the same question twice.\n    const key = JSON.stringify([pause.subflowPath, pause.pausedStageId]);\n    if (seen.has(key)) {\n      throw new Error(\n        `Cannot resume: checkpoint.pendingPauses[${n}] ('${pause.pausedStageId}') repeats an earlier entry.`,\n      );\n    }\n    seen.add(key);\n    let level = 0;\n    while (level < path.length && level < pause.subflowPath.length && path[level] === pause.subflowPath[level]) level++;\n    const graph = graphs[level];\n    const ours = level < path.length ? mounts[level] : paused;\n    const theirMounts = level < pause.subflowPath.length ? chart.mountsOf(graph, pause.subflowPath[level]) : [];\n    const theirs =\n      level < pause.subflowPath.length\n        ? theirMounts.length === 1\n          ? theirMounts[0]\n          : undefined\n        : chart.stage(graph, pause.pausedStageId);\n    const fanOut = ours ? chart.dispatcherOf(graph, ours) : undefined;\n    const isSibling =\n      ours !== undefined &&\n      theirs !== undefined &&\n      ours !== theirs &&\n      fanOut !== undefined &&\n      chart.dispatcherOf(graph, theirs) === fanOut &&\n      !fanOut.deciderFn &&\n      (queues[level] === undefined || queues[level]!.fanOut === fanOut);\n    if (!isSibling || !walksToItsStage(chart, subflows, graph, pause, level)) {\n      throw new Error(\n        `Cannot resume: checkpoint.pendingPauses[${n}] ('${pause.pausedStageId}') is not a parallel sibling of ` +\n          `the paused stage '${paused?.id ?? '?'}' in this chart — no fork or selector runs them both, or its ` +\n          'path does not lead to that stage. The chart may have changed since the checkpoint was created.',\n      );\n    }\n    const leafRoot =\n      pause.subflowPath.length === 0 ? root : ownEntry(subflows, pause.subflowPath[pause.subflowPath.length - 1])?.root;\n    const stageName = (leafRoot && chart.stage(leafRoot, pause.pausedStageId)?.name) ?? pause.pausedStageId;\n    const queue = (queues[level] ??= { fanOut: fanOut!, pauses: [] });\n    queue.pauses.push({ pause, level, stageName });\n  });\n  return queues;\n}\n\n/**\n * Whether a waiting sibling's WHOLE path below its fan-out walks this chart:\n * every segment the only mount of its subflow in the enclosing graph, every\n * subflow registered, and the paused stage in the last graph — checked at\n * the FIRST resume, so a tampered record is refused up front, not when its\n * turn comes.\n */\nfunction walksToItsStage<TOut, TScope>(\n  chart: ChartIndex<TOut, TScope>,\n  subflows: Record<string, { root: StageNode<TOut, TScope> }> | undefined,\n  fanOutGraph: StageNode<TOut, TScope>,\n  pause: PendingPause,\n  level: number,\n): boolean {\n  let graph = fanOutGraph;\n  for (let i = level; i < pause.subflowPath.length; i++) {\n    if (chart.mountsOf(graph, pause.subflowPath[i]).length !== 1) return false;\n    const definition = ownEntry(subflows, pause.subflowPath[i]);\n    if (!definition) return false;\n    graph = definition.root;\n  }\n  return chart.stage(graph, pause.pausedStageId) !== undefined;\n}\n\n/** One `pendingPauses` entry, checked field by field — it comes from stored, untrusted data. */\nfunction validPendingPause(raw: unknown, n: number): PendingPause {\n  const refuse = (what: string): never => {\n    throw new Error(`Invalid checkpoint: pendingPauses[${n}] ${what}.`);\n  };\n  if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) refuse('must be an object');\n  const record = raw as Record<string, unknown>;\n  if (typeof record.pausedStageId !== 'string' || record.pausedStageId === '') {\n    refuse('must name its paused stage (pausedStageId, a non-empty string)');\n  }\n  const subflowPath = record.subflowPath;\n  if (!Array.isArray(subflowPath) || !subflowPath.every((s) => typeof s === 'string')) {\n    refuse('must carry its subflowPath (an array of strings)');\n  }\n  const states = record.subflowStates;\n  if (states !== undefined && (states === null || typeof states !== 'object' || Array.isArray(states))) {\n    refuse('must carry its subflowStates as an object');\n  }\n  if (record.pausedBy !== undefined && record.pausedBy !== 'interrupt')\n    refuse(\"has an unknown pausedBy (only 'interrupt')\");\n  return {\n    pausedStageId: record.pausedStageId as string,\n    subflowPath: subflowPath as string[],\n    subflowStates: (states as Record<string, Record<string, unknown>> | undefined) ?? {},\n    ...(record.pauseData !== undefined && { pauseData: record.pauseData }),\n    ...(record.pausedBy === 'interrupt' && { pausedBy: 'interrupt' as const }),\n  };\n}\n\n/** `record[key]` only when it is the record's OWN property — never through the prototype chain. */\nfunction ownEntry<T>(record: Record<string, T> | undefined, key: string): T | undefined {\n  return record && Object.prototype.hasOwnProperty.call(record, key) ? record[key] : undefined;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ResumeEntry.js","sourceRoot":"","sources":["../../../../../src/lib/engine/handlers/ResumeEntry.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ResumeEntry — the resume's ONE-SHOT re-entry (M2, pause/resume).\n *\n * A resume has to get back to a stage in the middle of a chart. It does that\n * with a small synthetic structure: a stand-in for the paused stage (the\n * stage's own node with its function swapped for the resume half — or, for an\n * `interrupt()` pause, for its own function with the answer deposited), and,\n * for a pause inside subflows, the checkpoint's capture of each subflow's\n * state on the way down.\n *\n * THE LAW: that structure is used EXACTLY ONCE, for the re-entry. The stand-in\n * is where the resumed traversal STARTS (or where the leaf subflow's traversal\n * starts) — it is never a node any id can resolve to. Each subflow on the pause\n * path takes its seed and its entry point on its FIRST entry and never again.\n * After that the run belongs to the real chart: every loop target, every later\n * subflow entry (real root, inputMapper runs), every re-visit of the paused\n * stage (which pauses again) resolves against the chart as built.\n *\n * ONE RULE AT EVERY LEVEL — what runs after the entry. On the original run,\n * whatever DISPATCHED the paused stage (or the mount of the next subflow on\n * the path) — a decider, a selector, a fork — ran its own continuation once\n * that child's chain ended: the decider's `next`, the fork's join. A resume\n * enters AT the child, so that continuation must be carried: the entry is\n * the child with the enclosing dispatcher's continuation attached at the end\n * of its own chain (`{ ...child, next: dispatcher.next }` for a chart the\n * builder made). It is read from the CHART, level by level — never from the\n * checkpoint, so an edited checkpoint cannot redirect a run — and it lands\n * at the level it belongs to: a top-level decider's `next` runs at the top\n * level, after the subflow's outputMapper, not inside the subflow.\n *\n * PARALLEL SIBLINGS THAT PAUSED TOO (9.28.0). When two children of one\n * fan-out paused, the checkpoint asks the first and carries the others\n * (`FlowchartCheckpoint.pendingPauses`). At that fan-out's level the entry is\n * the child's own chain only — no join — and once it ends, the next sibling's\n * pause is raised again as it was (its question, its captured state), without\n * re-running anything. The join runs only when the last sibling is resumed.\n *\n * Before 9.28.0 the structure stayed in force for the whole resumed run — the\n * traversal was ROOTED at the stand-in (so a loop back to the paused id re-ran\n * the resume half, and a loop target upstream of the resume point was\n * unreachable: one stage ran, then the run ended silently), and the leaf\n * subflow's root was SWAPPED for the stand-in in the subflow dictionary (so a\n * later entry into it would re-run the resume half on a stale seed).\n *\n * @example\n * ```typescript\n * // What FlowChartExecutor.resume() builds for a pause at 'sf-a/sf-b/ask'\n * // (subflowPath ['sf-a', 'sf-a/sf-b']), 'sf-a/sf-b' mounted as a decider\n * // branch inside sf-a whose decider continues to 'sf-a/after':\n * const entry = ResumeEntry.plan({ root, subflows, path, captures, standIn });\n * entry.start;                     // the top-level mount of 'sf-a'\n * entry.enterSubflow('sf-a');      // { seed: sf-a's capture, entry: { ...mount of 'sf-a/sf-b', next: sf-a/after } }\n * entry.enterSubflow('sf-a/sf-b'); // { seed: sf-b's capture, entry: the stand-in }\n * entry.enterSubflow('sf-a/sf-b'); // undefined — a later entry is an ordinary one\n * ```\n *\n * A pause two (or more) subflows deep therefore re-enters each outer subflow\n * AT the mount of the next one — the outer subflow's stages before that mount\n * do not run again (they did before 9.28.0). The one exception is a degraded\n * checkpoint missing an outer subflow's capture: that subflow re-runs from its\n * root with its inputMapper (its earlier stages recompute what the capture\n * would have held), exactly as 9.27.0 did.\n */\n\nimport type { PendingPause } from '../../pause/types.js';\nimport { isPausedExecution, PauseSignal } from '../../pause/types.js';\nimport type { StageNode } from '../graph/StageNode.js';\n\n/**\n * A parallel sibling's pause, queued at the level of its fan-out: raised\n * again there once the resumed child's chain ends (see {@link raiseQueuedPause}).\n */\nexport interface QueuedPause {\n  /** The sibling's pause as the checkpoint carries it — its path from the top. */\n  readonly pause: PendingPause;\n  /** How many subflows deep the fan-out sits (0 = the top level). */\n  readonly level: number;\n  /** The sibling's paused stage's name, for the `onPause` event. */\n  readonly stageName: string;\n}\n\n/** One subflow boundary on the way back to a paused stage. */\nexport interface ResumeHop<TOut = any, TScope = any> {\n  /** The path-prefixed subflow id (a `FlowchartCheckpoint.subflowPath` entry). */\n  readonly subflowId: string;\n  /**\n   * The subflow's state at the pause (`checkpoint.subflowStates[subflowId]`).\n   * Seeds the nested runtime INSTEAD of the inputMapper's values — the capture\n   * already holds the post-input, pre-pause memory (the inputMapper still\n   * runs, for the stages' read-only args only). Absent when the checkpoint\n   * holds no capture for this subflow; the inputMapper then seeds it, as on\n   * any entry.\n   */\n  readonly seed?: Record<string, unknown>;\n  /**\n   * Where this subflow's traversal starts on the re-entry: the mount of the\n   * next subflow on the path, or — on the last hop — the paused stage's\n   * stand-in, each with its dispatcher's continuation attached (see the\n   * module doc). Absent: the subflow's own root — a seed-only hop (see\n   * {@link ResumeEntry.fromCaptures}), or an outer subflow whose capture the\n   * checkpoint lacks.\n   */\n  readonly entry?: StageNode<TOut, TScope>;\n  /**\n   * Pauses of parallel siblings whose fan-out sits in THIS subflow, raised in\n   * order once `entry`'s chain ends (the first is raised, the rest wait\n   * behind it). Absent when no sibling is waiting here.\n   */\n  readonly pendingPauses?: readonly QueuedPause[];\n}\n\nexport class ResumeEntry<TOut = any, TScope = any> {\n  /**\n   * Where the resumed TOP-LEVEL traversal starts: the stand-in (a top-level\n   * pause) or the mount of the first subflow on the path — each with its\n   * dispatcher's continuation attached. `undefined` for a seed-only entry —\n   * the traversal starts at its root.\n   */\n  readonly start: StageNode<TOut, TScope> | undefined;\n  /** Sibling pauses whose fan-out sits at the TOP level — raised once `start`'s chain ends. */\n  readonly startPendingPauses: readonly QueuedPause[] | undefined;\n  /**\n   * How many stage executions the resumed run makes before the stand-in runs\n   * — one per subflow on the path, each entered at its mount — so the\n   * executor's `onResume` names the stand-in's own `runtimeStageId`.\n   * `undefined` when it cannot be known before the run: an outer subflow\n   * missing its capture re-runs from its root.\n   */\n  readonly stepsBeforeStandIn: number | undefined;\n  /** Hops not taken yet, by subflow id. A hop leaves this map when it is taken. */\n  private readonly pending: Map<string, ResumeHop<TOut, TScope>>;\n\n  private constructor(\n    start: StageNode<TOut, TScope> | undefined,\n    hops: readonly ResumeHop<TOut, TScope>[],\n    startPendingPauses?: readonly QueuedPause[],\n    stepsBeforeStandIn?: number,\n  ) {\n    this.start = start;\n    this.startPendingPauses = startPendingPauses;\n    this.stepsBeforeStandIn = stepsBeforeStandIn;\n    this.pending = new Map(hops.map((hop) => [hop.subflowId, hop]));\n  }\n\n  /**\n   * Plan the re-entry of a paused chart. Every mount on the path, every\n   * dispatcher continuation and every waiting sibling is resolved HERE,\n   * against the chart as built, before a single stage runs — so a checkpoint\n   * whose path the chart cannot walk is refused up front instead of resuming\n   * into the wrong shape.\n   *\n   * @param args - `root` and `subflows`: the chart as built\n   *   (`FlowChart.root`, `FlowChart.subflows`); `path`:\n   *   `checkpoint.subflowPath`, outermost first; `captures`:\n   *   `checkpoint.subflowStates` (a detached copy); `standIn`: the node that\n   *   runs the resume half — the paused stage's own node, function swapped\n   *   (its continuation is attached here); `pendingPauses`:\n   *   `checkpoint.pendingPauses` (a detached copy).\n   * @throws when a subflow on the path is missing, mounted more than once, or\n   *   its mount cannot be reached from the enclosing graph; or when a pending\n   *   pause is malformed or is not a parallel sibling of the paused stage\n   */\n  static plan<TOut, TScope>(args: {\n    root: StageNode<TOut, TScope>;\n    subflows: Record<string, { root: StageNode<TOut, TScope> }> | undefined;\n    path: readonly string[];\n    captures: Record<string, Record<string, unknown>> | undefined;\n    standIn: StageNode<TOut, TScope>;\n    pendingPauses?: readonly PendingPause[];\n  }): ResumeEntry<TOut, TScope> {\n    const { root, subflows, path, captures, standIn } = args;\n    const chart = new ChartIndex<TOut, TScope>();\n\n    // 1. Walk the path: the graph of every level, the mount of every subflow.\n    const graphs: StageNode<TOut, TScope>[] = [root];\n    const mounts: StageNode<TOut, TScope>[] = [];\n    for (let i = 0; i < path.length; i++) {\n      const subflowId = path[i];\n      mounts.push(chart.onlyMount(graphs[i], subflowId, i === 0 ? 'the flowchart' : `subflow '${path[i - 1]}'`));\n      // Own entries only: a path segment is data from a stored checkpoint,\n      // and `'__proto__'` must not resolve through the prototype chain.\n      const definition = ownEntry(subflows, subflowId);\n      if (!definition) {\n        throw new Error(\n          `Cannot resume: subflow '${subflowId}' is not registered in the flowchart. ` +\n            'The chart may have changed since the checkpoint was created.',\n        );\n      }\n      graphs.push(definition.root);\n    }\n    const leafLevel = path.length;\n    // The paused stage's REAL node — whose dispatcher the stand-in's\n    // continuation comes from. (The executor already found it; a direct\n    // caller's stand-in that is not in the leaf graph simply has none.)\n    const paused = chart.stage(graphs[leafLevel], standIn.id);\n\n    // 2. Queue every waiting sibling pause at the level of its fan-out.\n    const queues = queueSiblingPauses(args.pendingPauses, { chart, subflows, root, path, graphs, mounts, paused });\n\n    // 3. The one-shot entry of every level: the child, then its dispatcher's\n    //    continuation — up to the fan-out when siblings wait there.\n    const childAt = (level: number) => (level < leafLevel ? mounts[level] : paused);\n    const entryAt = (level: number): StageNode<TOut, TScope> => {\n      const child = childAt(level);\n      const replacement = level < leafLevel ? mounts[level] : standIn;\n      if (!child) return replacement;\n      return chart.entry(graphs[level], child, replacement, queues[level]?.fanOut);\n    };\n    // 4. The hops. A subflow with no capture is entered at its ROOT with its\n    //    inputMapper (its earlier stages recompute what the capture held) —\n    //    except the leaf, whose entry is always the stand-in: re-running it\n    //    from its root would ask again and lose the answer.\n    const hops: ResumeHop<TOut, TScope>[] = [];\n    let everyLevelAtItsEntry = true;\n    for (let i = 0; i < path.length; i++) {\n      const subflowId = path[i];\n      const seed = ownEntry(captures, subflowId);\n      const isLeafHop = i === path.length - 1;\n      if (seed === undefined && !isLeafHop) {\n        everyLevelAtItsEntry = false;\n        hops.push({ subflowId });\n        continue;\n      }\n      const waiting = queues[i + 1]?.pauses;\n      hops.push({\n        subflowId,\n        ...(seed !== undefined && { seed }),\n        entry: entryAt(i + 1),\n        ...(waiting && { pendingPauses: waiting }),\n      });\n    }\n    // Every level entered at its entry: one execution (the mount) per level\n    // runs before the stand-in.\n    return new ResumeEntry(entryAt(0), hops, queues[0]?.pauses, everyLevelAtItsEntry ? path.length : undefined);\n  }\n\n  /**\n   * A seed-only entry: each capture seeds the FIRST entry into its subflow,\n   * which then starts at its own root. What the deprecated\n   * `subflowStatesForResume` option (TraverserOptions / HandlerDeps) means\n   * since 9.28.0 — the same one-shot law, without a stand-in or a path.\n   */\n  static fromCaptures<TOut, TScope>(captures: Record<string, Record<string, unknown>>): ResumeEntry<TOut, TScope> {\n    return new ResumeEntry<TOut, TScope>(\n      undefined,\n      Object.entries(captures).map(([subflowId, seed]) => ({ subflowId, seed })),\n    );\n  }\n\n  /**\n   * The re-entry into `subflowId`, taken — or `undefined` when this entry is\n   * an ordinary one (the subflow is off the pause path, or its hop was already\n   * taken). ONE-SHOT: a hop is returned at most once, so a second entry into\n   * the same subflow (a loop passing its mount again) runs the real subflow\n   * from its real root with its inputMapper.\n   */\n  enterSubflow(subflowId: string): ResumeHop<TOut, TScope> | undefined {\n    const hop = this.pending.get(subflowId);\n    if (hop !== undefined) this.pending.delete(subflowId);\n    return hop;\n  }\n\n  /** `true` once every hop has been taken — the rest of the run is ordinary. */\n  get spent(): boolean {\n    return this.pending.size === 0;\n  }\n}\n\n// ── Raising a waiting sibling's pause ────────────────────────────────────────\n\n/**\n * Queue `queue` behind a pause passing through its level: a pause raised\n * while siblings still wait must carry them to its checkpoint. Each path is\n * cut to that level — the bubble-up prepends the levels above.\n */\nexport function queueBehind(signal: PauseSignal, queue: readonly QueuedPause[]): void {\n  for (const { pause, level } of queue) {\n    signal.addPendingPause({ ...pause, subflowPath: pause.subflowPath.slice(level) });\n  }\n}\n\n/**\n * The first waiting sibling's pause, raised again at its fan-out's level —\n * exactly as it bubbled up to that level the first time (its stage, its\n * question, its own subflow captures), nothing re-run; the rest of the queue\n * waits behind it. The subflows ABOVE the fan-out capture themselves afresh\n * as it bubbles up, so they carry what the resumed child wrote.\n */\nexport function raiseQueuedPause(queue: readonly QueuedPause[]): PauseSignal {\n  const [first, ...rest] = queue;\n  const { pause, level } = first;\n  const signal = new PauseSignal(pause.pauseData, pause.pausedStageId, pause.pausedBy);\n  // The sibling paused in an EARLIER run: its own execution, not this run's.\n  if (isPausedExecution(pause.pausedExecution)) {\n    signal.stampExecution(pause.pausedExecution.runtimeStageId, pause.pausedExecution.runId);\n  }\n  const below = pause.subflowPath.slice(level);\n  for (let i = below.length - 1; i >= 0; i--) {\n    const state = ownEntry(pause.subflowStates, below[i]);\n    if (state !== undefined) signal.captureSubflowScope(below[i], state);\n    signal.prependSubflow(below[i]);\n  }\n  queueBehind(signal, rest);\n  return signal;\n}\n\n// ── Reading the chart ────────────────────────────────────────────────────────\n\n/**\n * The node that mounts `subflowId`, found by DFS from `start` over `next` and\n * `children` (loop-ref stubs skipped — they share their target's id and carry\n * nothing). Cycle-safe (visited by identity, so an absent id terminates too);\n * first match in DFS pre-order (children before `next`, like the builder).\n */\nexport function findMount<TOut, TScope>(\n  start: StageNode<TOut, TScope>,\n  subflowId: string,\n): StageNode<TOut, TScope> | undefined {\n  for (const node of dispatcherIndex(start).keys()) {\n    if (node.subflowId === subflowId) return node;\n  }\n  return undefined;\n}\n\n/**\n * Every real node of one level's graph, in DFS pre-order, mapped to the\n * DISPATCHER whose child-chain holds it — the node whose `children` it\n * descends from (a decider, a selector, a fork) — or `undefined` for a node\n * on the level's own spine. Loop stubs are skipped; visited by identity, so\n * two mounts sharing an id are both indexed and a cycle terminates.\n */\nfunction dispatcherIndex<TOut, TScope>(\n  root: StageNode<TOut, TScope>,\n): Map<StageNode<TOut, TScope>, StageNode<TOut, TScope> | undefined> {\n  const index = new Map<StageNode<TOut, TScope>, StageNode<TOut, TScope> | undefined>();\n  const stack: Array<[StageNode<TOut, TScope>, StageNode<TOut, TScope> | undefined]> = [[root, undefined]];\n  for (let top = stack.pop(); top !== undefined; top = stack.pop()) {\n    const [node, dispatcher] = top;\n    if (node.isLoopRef || index.has(node)) continue;\n    index.set(node, dispatcher);\n    // LIFO: push `next` first and children reversed, so children are visited\n    // before `next` and the first child first — pre-order, like the builder.\n    if (node.next) stack.push([node.next, dispatcher]);\n    if (node.children) {\n      for (let i = node.children.length - 1; i >= 0; i--) stack.push([node.children[i], node]);\n    }\n  }\n  return index;\n}\n\n/** One plan's view of the chart: each level's index built once. */\nclass ChartIndex<TOut, TScope> {\n  private readonly indexes = new Map<\n    StageNode<TOut, TScope>,\n    Map<StageNode<TOut, TScope>, StageNode<TOut, TScope> | undefined>\n  >();\n\n  private of(root: StageNode<TOut, TScope>) {\n    let index = this.indexes.get(root);\n    if (!index) {\n      index = dispatcherIndex(root);\n      this.indexes.set(root, index);\n    }\n    return index;\n  }\n\n  /** Every mount of `subflowId` in `root`'s graph, in DFS pre-order. */\n  mountsOf(root: StageNode<TOut, TScope>, subflowId: string): StageNode<TOut, TScope>[] {\n    return [...this.of(root).keys()].filter((node) => node.subflowId === subflowId);\n  }\n\n  /** The one mount of `subflowId` in `root`'s graph — refused when absent or ambiguous. */\n  onlyMount(root: StageNode<TOut, TScope>, subflowId: string, graphName: string): StageNode<TOut, TScope> {\n    const found = this.mountsOf(root, subflowId);\n    if (found.length === 0) {\n      throw new Error(\n        `Cannot resume: the mount of subflow '${subflowId}' is not reachable from ${graphName}. ` +\n          \"The checkpoint's subflowPath does not match this chart — it may have changed since the checkpoint was created.\",\n      );\n    }\n    if (found.length > 1) {\n      throw new Error(\n        `Cannot resume: subflow '${subflowId}' is mounted more than once in ${graphName} ` +\n          `(${found.map((node) => `'${node.name}'`).join(', ')}), and a checkpoint's subflowPath cannot say which ` +\n          'mount paused. Give each mount its own subflow id to make a pause inside it resumable.',\n      );\n    }\n    return found[0];\n  }\n\n  /** The real stage `id` in `root`'s graph (first in DFS pre-order), if any. */\n  stage(root: StageNode<TOut, TScope>, id: string): StageNode<TOut, TScope> | undefined {\n    for (const node of this.of(root).keys()) if (node.id === id) return node;\n    return undefined;\n  }\n\n  /** The dispatcher whose child-chain holds `node` in `root`'s graph (`undefined` on the spine). */\n  dispatcherOf(root: StageNode<TOut, TScope>, node: StageNode<TOut, TScope>): StageNode<TOut, TScope> | undefined {\n    return this.of(root).get(node);\n  }\n\n  /**\n   * The one-shot entry for `child` (a mount on the path, or the paused stage)\n   * in `root`'s graph: `replacement` (the node that runs — the mount itself,\n   * or the stand-in) with what ran after `child`'s chain on the original run\n   * attached where that chain ends — `{ ...child, next: dispatcher.next }` for\n   * a chart the builder made:\n   *\n   *   • on the level's spine: nothing to attach — the spine goes on by itself;\n   *   • a DECIDER's or SELECTOR's branch: the dispatcher's `next`;\n   *   • a FORK child: the fork's `next` — its join.\n   *\n   * Past a dispatcher with no `next`, the walk goes on OUTWARD to the one\n   * enclosing it. It stops at `stopAt` — the fan-out where siblings still\n   * wait, whose join must not run yet. Nothing to attach: `replacement`\n   * itself.\n   */\n  entry(\n    root: StageNode<TOut, TScope>,\n    child: StageNode<TOut, TScope>,\n    replacement: StageNode<TOut, TScope>,\n    stopAt: StageNode<TOut, TScope> | undefined,\n  ): StageNode<TOut, TScope> {\n    return appendAtChainEnd(replacement, this.after(root, child, stopAt));\n  }\n\n  /**\n   * What runs once `node`'s chain ends: its dispatcher's `next` chain, then —\n   * where THAT ends — the continuation of the dispatcher enclosing it, outward,\n   * up to `stopAt` (exclusive). `undefined` on the spine.\n   */\n  private after(\n    root: StageNode<TOut, TScope>,\n    node: StageNode<TOut, TScope>,\n    stopAt: StageNode<TOut, TScope> | undefined,\n  ): StageNode<TOut, TScope> | undefined {\n    const dispatcher = this.dispatcherOf(root, node);\n    if (dispatcher === undefined || dispatcher === stopAt) return undefined;\n    const outer = this.after(root, dispatcher, stopAt);\n    return dispatcher.next ? appendAtChainEnd(dispatcher.next, outer) : outer;\n  }\n}\n\n/**\n * `start`'s chain with `after` attached where it ends — the chain's nodes\n * copied on the way (never registered anywhere: ids still resolve to the real\n * nodes). A chain that ends in a loop stub (or loops back on itself) is\n * returned as is: control leaves it through the loop, never \"after\" it.\n */\nfunction appendAtChainEnd<TOut, TScope>(\n  start: StageNode<TOut, TScope>,\n  after: StageNode<TOut, TScope> | undefined,\n): StageNode<TOut, TScope> {\n  if (after === undefined) return start;\n  const chain: StageNode<TOut, TScope>[] = [];\n  const seen = new Set<StageNode<TOut, TScope>>();\n  for (let node: StageNode<TOut, TScope> | undefined = start; node !== undefined; node = node.next) {\n    if (node.isLoopRef || seen.has(node)) return start;\n    seen.add(node);\n    chain.push(node);\n  }\n  let next = after;\n  for (let i = chain.length - 1; i >= 0; i--) next = { ...chain[i], next };\n  return next;\n}\n\n// ── Waiting siblings ─────────────────────────────────────────────────────────\n\n/** The sibling pauses waiting at one level, and the fan-out they wait in. */\ninterface LevelQueue<TOut, TScope> {\n  readonly fanOut: StageNode<TOut, TScope>;\n  readonly pauses: QueuedPause[];\n}\n\n/**\n * Validate `checkpoint.pendingPauses` (untrusted input) and queue each at the\n * level of its fan-out: the depth where its path parts from the paused\n * stage's. There, the paused stage's child (a mount on the path, or the stage\n * itself) and the sibling's must both hang off ONE parallel dispatcher — a\n * fork or a selector — or the record is not a sibling and the resume is\n * refused rather than asked a question the chart could not have raised.\n */\nfunction queueSiblingPauses<TOut, TScope>(\n  pending: readonly PendingPause[] | undefined,\n  at: {\n    chart: ChartIndex<TOut, TScope>;\n    subflows: Record<string, { root: StageNode<TOut, TScope> }> | undefined;\n    root: StageNode<TOut, TScope>;\n    path: readonly string[];\n    graphs: readonly StageNode<TOut, TScope>[];\n    mounts: readonly StageNode<TOut, TScope>[];\n    paused: StageNode<TOut, TScope> | undefined;\n  },\n): Array<LevelQueue<TOut, TScope> | undefined> {\n  const queues: Array<LevelQueue<TOut, TScope> | undefined> = [];\n  if (pending === undefined) return queues;\n  if (!Array.isArray(pending)) throw new Error('Invalid checkpoint: pendingPauses must be an array.');\n  const { chart, subflows, root, path, graphs, mounts, paused } = at;\n  const seen = new Set<string>();\n\n  pending.forEach((raw: unknown, n) => {\n    const pause = validPendingPause(raw, n);\n    // One record per paused sibling: a repeat would ask the same question twice.\n    const key = JSON.stringify([pause.subflowPath, pause.pausedStageId]);\n    if (seen.has(key)) {\n      throw new Error(\n        `Cannot resume: checkpoint.pendingPauses[${n}] ('${pause.pausedStageId}') repeats an earlier entry.`,\n      );\n    }\n    seen.add(key);\n    let level = 0;\n    while (level < path.length && level < pause.subflowPath.length && path[level] === pause.subflowPath[level]) level++;\n    const graph = graphs[level];\n    const ours = level < path.length ? mounts[level] : paused;\n    const theirMounts = level < pause.subflowPath.length ? chart.mountsOf(graph, pause.subflowPath[level]) : [];\n    const theirs =\n      level < pause.subflowPath.length\n        ? theirMounts.length === 1\n          ? theirMounts[0]\n          : undefined\n        : chart.stage(graph, pause.pausedStageId);\n    const fanOut = ours ? chart.dispatcherOf(graph, ours) : undefined;\n    const isSibling =\n      ours !== undefined &&\n      theirs !== undefined &&\n      ours !== theirs &&\n      fanOut !== undefined &&\n      chart.dispatcherOf(graph, theirs) === fanOut &&\n      !fanOut.deciderFn &&\n      (queues[level] === undefined || queues[level]!.fanOut === fanOut);\n    if (!isSibling || !walksToItsStage(chart, subflows, graph, pause, level)) {\n      throw new Error(\n        `Cannot resume: checkpoint.pendingPauses[${n}] ('${pause.pausedStageId}') is not a parallel sibling of ` +\n          `the paused stage '${paused?.id ?? '?'}' in this chart — no fork or selector runs them both, or its ` +\n          'path does not lead to that stage. The chart may have changed since the checkpoint was created.',\n      );\n    }\n    const leafRoot =\n      pause.subflowPath.length === 0 ? root : ownEntry(subflows, pause.subflowPath[pause.subflowPath.length - 1])?.root;\n    const stageName = (leafRoot && chart.stage(leafRoot, pause.pausedStageId)?.name) ?? pause.pausedStageId;\n    const queue = (queues[level] ??= { fanOut: fanOut!, pauses: [] });\n    queue.pauses.push({ pause, level, stageName });\n  });\n  return queues;\n}\n\n/**\n * Whether a waiting sibling's WHOLE path below its fan-out walks this chart:\n * every segment the only mount of its subflow in the enclosing graph, every\n * subflow registered, and the paused stage in the last graph — checked at\n * the FIRST resume, so a tampered record is refused up front, not when its\n * turn comes.\n */\nfunction walksToItsStage<TOut, TScope>(\n  chart: ChartIndex<TOut, TScope>,\n  subflows: Record<string, { root: StageNode<TOut, TScope> }> | undefined,\n  fanOutGraph: StageNode<TOut, TScope>,\n  pause: PendingPause,\n  level: number,\n): boolean {\n  let graph = fanOutGraph;\n  for (let i = level; i < pause.subflowPath.length; i++) {\n    if (chart.mountsOf(graph, pause.subflowPath[i]).length !== 1) return false;\n    const definition = ownEntry(subflows, pause.subflowPath[i]);\n    if (!definition) return false;\n    graph = definition.root;\n  }\n  return chart.stage(graph, pause.pausedStageId) !== undefined;\n}\n\n/** One `pendingPauses` entry, checked field by field — it comes from stored, untrusted data. */\nfunction validPendingPause(raw: unknown, n: number): PendingPause {\n  const refuse = (what: string): never => {\n    throw new Error(`Invalid checkpoint: pendingPauses[${n}] ${what}.`);\n  };\n  if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) refuse('must be an object');\n  const record = raw as Record<string, unknown>;\n  if (typeof record.pausedStageId !== 'string' || record.pausedStageId === '') {\n    refuse('must name its paused stage (pausedStageId, a non-empty string)');\n  }\n  const subflowPath = record.subflowPath;\n  if (!Array.isArray(subflowPath) || !subflowPath.every((s) => typeof s === 'string')) {\n    refuse('must carry its subflowPath (an array of strings)');\n  }\n  const states = record.subflowStates;\n  if (states !== undefined && (states === null || typeof states !== 'object' || Array.isArray(states))) {\n    refuse('must carry its subflowStates as an object');\n  }\n  if (record.pausedBy !== undefined && record.pausedBy !== 'interrupt')\n    refuse(\"has an unknown pausedBy (only 'interrupt')\");\n  return {\n    pausedStageId: record.pausedStageId as string,\n    subflowPath: subflowPath as string[],\n    subflowStates: (states as Record<string, Record<string, unknown>> | undefined) ?? {},\n    ...(record.pauseData !== undefined && { pauseData: record.pauseData }),\n    ...(record.pausedBy === 'interrupt' && { pausedBy: 'interrupt' as const }),\n    // A record, never a plan input: kept only when well-formed (an older or\n    // hand-edited entry simply resumes without a link).\n    ...(isPausedExecution(record.pausedExecution) && {\n      pausedExecution: { runId: record.pausedExecution.runId, runtimeStageId: record.pausedExecution.runtimeStageId },\n    }),\n  };\n}\n\n/** `record[key]` only when it is the record's OWN property — never through the prototype chain. */\nfunction ownEntry<T>(record: Record<string, T> | undefined, key: string): T | undefined {\n  return record && Object.prototype.hasOwnProperty.call(record, key) ? record[key] : undefined;\n}\n"]}