footprintjs 10.0.1 → 10.2.0

package/dist/esm/lib/builder/FlowChartBuilder.js

@@ -12,11 +12,16 @@
  * it belongs in the runner layer (Phase 5).
  */
 import { joinPath } from 'foottrace';
+import { touchesProblem } from '../attempt/effect.js';
+import { retryPolicyProblem } from '../attempt/policy.js';
+import { declareRetryLoopBudget } from '../attempt/retryLoopContext.js';
+import { budgetRefusal, budgetWarning, timeBudget } from '../budget/index.js';
 import { isDevMode } from '../devMode.js';
 import { prefixNodeTree } from '../engine/graph/prefixNodeTree.js';
 import { BRANCH_SEGMENT_MARKER, hasBranchSegmentMarker } from '../ids/branchSegment.js';
 import { refuseReservedId } from '../ids/reservedIds.js';
 import { makeRunnable } from '../runner/RunnableChart.js';
+import { appendRetryLoop } from './retryLoop.js';
 import { StructureRecorderDispatcher } from './structure/StructureRecorderDispatcher.js';
 import { createTypedScopeFactory } from './typedFlowChart.js';
 // ─────────────────────────────────────────────────────────────────────────────
@@ -36,18 +41,53 @@ const fail = (msg) => {
  * typo'd `attempts: 0` should fail while you are writing the chart, not
  * silently turn a stage into a no-op run three months later. `attempts: 1` is
  * accepted on purpose — it means "policy declared, currently off", so a policy
- * can be dialled down without deleting the declaration.
+ * can be dialled down without deleting the declaration. The rule is
+ * `attempt/policy.ts · retryPolicyProblem`, which the traverser also applies to
+ * a StageNode a stage returns at run time.
  */
 function applyRetryPolicy(node, spec, retry, where) {
     if (!retry)
         return;
-    if (typeof retry.attempts !== 'number' || !Number.isInteger(retry.attempts) || retry.attempts < 1) {
-        fail(`${where}: retry.attempts must be a whole number >= 1 (got ${String(retry.attempts)}). ` +
-            'It counts TOTAL runs including the first, so `attempts: 3` means one run plus up to two retries; ' +
-            '`attempts: 1` means the policy is declared but currently off.');
+    const problem = retryPolicyProblem(retry);
+    if (problem !== undefined)
+        fail(`${where}: ${problem}`);
+    // A touching stage declared first: the policy must not make it retry without a key (P3 — either order refuses).
+    if (node.touches) {
+        const touching = touchesProblem(node.touches, retry);
+        if (touching !== undefined)
+            fail(`${where}: stage '${node.name}' ${touching}`);
     }
     node.retry = retry;
     spec.retryAttempts = retry.attempts;
+    // The cap rides the spec beside the count (P5): a JSON-safe fact, so a reader of the spec sees what bounds the stage.
+    if (retry.timeoutMs !== undefined)
+        spec.timeoutMs = retry.timeoutMs;
+}
+/**
+ * Attach a side-effect declaration to a stage node + its spec node (10.1, design §3.3) — the twin of
+ * {@link applyRetryPolicy}: the ONE place `touches` lands, shared by the `.touches()` cursor modifier and every
+ * `options.touches` site.
+ *
+ * The law is `attempt/effect.ts · touchesProblem`, which the traverser also applies to a StageNode returned at run
+ * time and to every stage it runs: `system` a name, the key rule a function, and a stage that may retry must declare
+ * the key rule — a retry of an outside effect without one can apply it twice. Checked here against the policy
+ * already on the node; `applyRetryPolicy` checks a policy that lands after. The spec carries the system NAME only.
+ */
+function applyTouches(node, spec, touches, where) {
+    if (touches === undefined)
+        return;
+    if (node.touches)
+        fail(`${where}: touches already declared at '${node.name}' (${node.touches.system})`);
+    // Each field read ONCE, then checked and frozen: what is checked is exactly what lands (a getter cannot differ).
+    const read = (touches !== null && typeof touches === 'object' ? touches : {});
+    const { system, idempotencyKey } = read;
+    const copy = { system, ...(idempotencyKey !== undefined && { idempotencyKey }) };
+    const problem = touchesProblem(touches === null || typeof touches !== 'object' ? touches : copy, node.retry);
+    if (problem !== undefined)
+        fail(`${where}: stage '${node.name}' ${problem}`);
+    // The node's copy is frozen and holds only the two named fields: nothing else on the caller's object rides along.
+    node.touches = Object.freeze(copy);
+    spec.touches = system;
 }
 /**
  * Attach declared tags to a stage node + its spec node.
@@ -223,6 +263,7 @@ class BranchCursor {
         if (description)
             spec.description = description;
         applyRetryPolicy(node, spec, options?.retry, `addFunctionBranch('${id}')`);
+        applyTouches(node, spec, options?.touches, `addFunctionBranch('${id}')`);
         applyTags(node, spec, options?.tags, `addFunctionBranch('${id}')`);
         this.attach(node, spec, id);
         this.branchDescInfo.push({ id, description });
@@ -245,6 +286,7 @@ class BranchCursor {
         if (description)
             spec.description = description;
         applyRetryPolicy(node, spec, options?.retry, `addPausableFunctionBranch('${id}')`);
+        applyTouches(node, spec, options?.touches, `addPausableFunctionBranch('${id}')`);
         applyTags(node, spec, options?.tags, `addPausableFunctionBranch('${id}')`);
         this.attach(node, spec, id);
         this.branchDescInfo.push({ id, description });
@@ -933,6 +975,7 @@ export class FlowChartBuilder {
         if (description)
             spec.description = description;
         applyRetryPolicy(node, spec, options?.retry, `start('${id}')`);
+        applyTouches(node, spec, options?.touches, `start('${id}')`);
         applyTags(node, spec, options?.tags, `start('${id}')`);
         this._root = node;
         this._rootSpec = spec;
@@ -974,6 +1017,7 @@ export class FlowChartBuilder {
         if (description)
             spec.description = description;
         applyRetryPolicy(node, spec, options?.retry, `startSelector('${id}')`);
+        applyTouches(node, spec, options?.touches, `startSelector('${id}')`);
         applyTags(node, spec, options?.tags, `startSelector('${id}')`);
         this._root = node;
         this._rootSpec = spec;
@@ -1017,6 +1061,28 @@ export class FlowChartBuilder {
         this._appendDescriptionLine(name, description);
         return this;
     }
+    /** Compose a keyed outside operation, reconciliation, shared retry decision and wait as ordinary chart nodes. */
+    addRetryLoop(id, options) {
+        this._needCursor();
+        for (const stageId of [id, `${id}-reconcile`, `${id}-decide`, `${id}-retry`, `${id}-done`, `${id}-stop`]) {
+            admitId('retry loop stage id', stageId, 'stage');
+            if (this._idTaken(stageId))
+                fail(`retry loop stage id '${stageId}' already exists`);
+        }
+        appendRetryLoop(this, id, options, (budget, branch) => {
+            const cursor = this._needCursor();
+            const node = branch === undefined ? cursor : cursor.children?.find((child) => child.id === branch);
+            const spec = branch === undefined
+                ? this._needCursorSpec()
+                : this._needCursorSpec().children?.find((child) => child.id === branch);
+            if (node === undefined || spec === undefined)
+                fail('retry loop budget node missing');
+            declareRetryLoopBudget(node, budget);
+            if (budget.timeoutMs !== undefined)
+                spec.timeoutMs = budget.timeoutMs;
+        });
+        return this;
+    }
     addStreamingFunction(name, fn, id, streamId, description) {
         admitId('stage id', id, 'stage');
         const cur = this._needCursor();
@@ -1227,6 +1293,7 @@ export class FlowChartBuilder {
         if (description)
             spec.description = description;
         applyRetryPolicy(node, spec, options?.retry, `addDeciderFunction('${id}')`);
+        applyTouches(node, spec, options?.touches, `addDeciderFunction('${id}')`);
         applyTags(node, spec, options?.tags, `addDeciderFunction('${id}')`);
         cur.next = node;
         curSpec.next = spec;
@@ -1268,6 +1335,7 @@ export class FlowChartBuilder {
         if (description)
             spec.description = description;
         applyRetryPolicy(node, spec, options?.retry, `addSelectorFunction('${id}')`);
+        applyTouches(node, spec, options?.touches, `addSelectorFunction('${id}')`);
         applyTags(node, spec, options?.tags, `addSelectorFunction('${id}')`);
         cur.next = node;
         curSpec.next = spec;
@@ -1289,7 +1357,7 @@ export class FlowChartBuilder {
         curSpec.type = 'fork';
         if (options?.failFast)
             cur.failFast = true;
-        for (const { id, name, fn, retry, tags } of children) {
+        for (const { id, name, fn, retry, touches, tags } of children) {
             if (!id)
                 fail(`child id required under '${cur.name}'`);
             admitId('fork child id', id, 'stage');
@@ -1309,6 +1377,7 @@ export class FlowChartBuilder {
                 parallelGroupId: forkId,
             };
             applyRetryPolicy(node, spec, retry, `addListOfFunction child '${id}'`);
+            applyTouches(node, spec, touches, `addListOfFunction child '${id}'`);
             applyTags(node, spec, tags, `addListOfFunction child '${id}'`);
             cur.children = cur.children || [];
             cur.children.push(node);
@@ -1618,8 +1687,13 @@ export class FlowChartBuilder {
      * failed calls that came before the successful one left no mark anywhere —
      * an unexplained behaviour in a library whose whole point is that nothing
      * invisible happens. Declared here, every attempt is part of the record: each
-     * failed attempt fires `FlowRecorder.onStageRetry` and appears in the
-     * narrative, in order, between the attempts' own reads and writes.
+     * attempt fires `FlowRecorder.onAttempt` with its `AttemptRecord` (outcome,
+     * duration, failure category, the retry-or-stop decision), which is what
+     * feeds the narrative — one line per attempt, in order, between the
+     * attempts' own reads and writes. The stage's execution-tree node keeps the
+     * records (`attempts`, `attemptSummary`). A failed attempt that is retried
+     * also fires `FlowRecorder.onStageRetry`, which the narrative does not tell
+     * twice.
      *
      * ## What an attempt is
      *
@@ -1672,6 +1746,64 @@ export class FlowChartBuilder {
         applyRetryPolicy(cur, curSpec, policy, `retry() at '${cur.name}'`);
         return this;
     }
+    // ── Side effects ──
+    /**
+     * Declare that the stage you JUST added changes an outside system — a charge, an email, a write to another
+     * service (10.1, design §3.3) — and give the rule for its idempotency key.
+     *
+     * ## Why declare it
+     *
+     * A retry is safe for a read. For a charge it is safe only when the outside system can tell a retry from a new
+     * request — by an idempotency key. So the builder refuses a touching stage that may retry (`.retry({ attempts >
+     * 1 })`, in either order) without a key rule: a double charge must be impossible to write by accident. A default
+     * key made by the library was rejected — the run id changes across a resume and a caller's whole-run retry, the
+     * two places a double charge actually happens. The key must name the OPERATION: derive it from the input the rule
+     * is handed, never from model output (`({ getState }) => …` reads it from state). A
+     * keyless touching stage may not `interrupt()`: a resume re-runs it from its top. In a chart that pauses, derive
+     * keys from state (`({ getState }) => …`): the run's input does not cross a resume.
+     *
+     * ## What it changes at run time
+     *
+     * The stage always runs on the attempt runner. The key rule runs ONCE per execution, before attempt 1, and every
+     * attempt gets the key as `scope.$attempt().idempotencyKey` — pass it to the system. Every attempt record says
+     * what it did there (`effect`: `'applied'`, `'none'` when the error itself declares `effect: 'none'`, else
+     * `'unknown'`). When ANY attempt left the effect unknown — it timed out, was cut, or failed without the adapter
+     * saying nothing was sent — the stage fails with `UnknownEffectError`: reconcile with the system by the key, do
+     * not retry blindly. The spec carries the system's name (`touches`).
+     *
+     * @example
+     * ```ts
+     * flowChart<Order>('Load order', loadFn, 'load')
+     *   .addFunction('Charge card', chargeFn, 'charge')
+     *   .touches('stripe', { idempotencyKey: ({ args }) => `order-${(args as { orderId: string }).orderId}` })
+     *   .retry({ attempts: 3, timeoutMs: 20_000 })
+     * ```
+     *
+     * Applies to the CURRENT cursor, like `.retry()`; where the cursor would be ambiguous (a decider, selector,
+     * branch, or fork child), declare it in that method's own `touches` option. Refused: on a subflow mount, a
+     * parallel-for-each stage or a loop reference (no function of their own), after a mount or a fork (the cursor did
+     * not move), twice, with a system that is not a name, and with a key that is not a function.
+     */
+    touches(system, options) {
+        const cur = this._needCursor();
+        const curSpec = this._needCursorSpec();
+        if (this._cursorTail) {
+            fail(`touches() cannot follow ${this._cursorTail} — that attaches to '${cur.name}' without moving the cursor. ` +
+                'Declare it at its own site: on the stages INSIDE a subflow chart, or via the `touches` field on an ' +
+                'addListOfFunction child.');
+        }
+        if (cur.isSubflowRoot) {
+            fail(`touches() cannot be applied to the subflow mount '${cur.name}' — declare it on the stages INSIDE it.`);
+        }
+        if (cur.isDynamicParallel) {
+            fail(`touches() cannot be applied to the parallel-for-each stage '${cur.name}' — declare it on the stages of ` +
+                'the branch chart.');
+        }
+        if (cur.isLoopRef)
+            fail(`touches() cannot be applied to the loop reference '${cur.name}'`);
+        applyTouches(cur, curSpec, { system, ...(options?.idempotencyKey !== undefined && { idempotencyKey: options.idempotencyKey }) }, `touches() at '${cur.name}'`);
+        return this;
+    }
     // ── Declared tags ──
     /**
      * Put NAMES on the stage you JUST added. The first commit bundle of each
@@ -1750,6 +1882,43 @@ export class FlowChartBuilder {
         this._fireStageTagged(curSpec);
         return this;
     }
+    // ── Time budget ──
+    /**
+     * Declare the chart's time budget: the most milliseconds a caller gives one run (design §3.2).
+     *
+     * WHY: the incident behind it — a stage retried an SDK call four times, 40 s each, past a caller's 120 s, and the
+     * record said "one stage, one error". Both numbers were declared: the policy on the stage, the budget of the
+     * caller. So `build()` checks one against the other: it REFUSES the chart when its declared policies already allow
+     * longer (`attempts × timeoutMs` plus the waits, summed along the slowest path — see `timeBudget`), and in dev mode
+     * names every stage it cannot bound (no `timeoutMs`, a function backoff with no `maxBackoffMs`, a loop, a lazy
+     * subflow, a `parallelForEach`). The spec root carries it (`budgetMs`); at run start, a deadline shorter than it is
+     * a dev-mode warning.
+     *
+     * Chart-level, so it may be declared anywhere before `build()`, once.
+     *
+     * @example
+     * ```ts
+     * flowChart<State>('Read', readFn, 'read', { retry: { attempts: 1, timeoutMs: 5_000 } })
+     *   .addFunction('Charge', chargeFn, 'charge')
+     *   .retry({ attempts: 4, timeoutMs: 40_000, backoffMs: 1_000 })
+     *   .budget(120_000)
+     *   .build(); // throws: its declared policies allow 168000 ms, over its budget by 48000 ms
+     * ```
+     */
+    budget(ms) {
+        if (this._sealed)
+            fail('budget() after build() — declare the budget before building the chart');
+        const rootSpec = this._rootSpec ?? fail('budget() before start() — start the chart first');
+        // At most Number.MAX_SAFE_INTEGER: the worst case saturates there, so a larger budget could never be exceeded.
+        if (!(typeof ms === 'number' && ms > 0 && ms <= Number.MAX_SAFE_INTEGER)) {
+            fail('budget(ms) must be a finite number of milliseconds > 0, at most Number.MAX_SAFE_INTEGER ' +
+                `(got ${typeof ms === 'number' ? ms : typeof ms})`);
+        }
+        if (rootSpec.budgetMs !== undefined)
+            fail(`budget already declared (${rootSpec.budgetMs} ms) — declare it once`);
+        rootSpec.budgetMs = ms;
+        return this;
+    }
     // ── Loop ──
     loopTo(stageId) {
         const cur = this._needCursor();
@@ -1820,8 +1989,27 @@ export class FlowChartBuilder {
             // or any subclass) automatically gets TypedScope — no manual setScopeFactory needed.
             scopeFactory: this._scopeFactory ?? createTypedScopeFactory(),
         };
+        if (rootSpec.budgetMs !== undefined)
+            this._checkBudget(chart);
         return makeRunnable(chart);
     }
+    /**
+     * The declared budget, checked (owner ruling Q2): refused when the chart's bounded part alone allows longer — a
+     * time its declared policies allow a run to take, so the budget cannot be promised; every stage it cannot bound is
+     * a dev-mode warning.
+     */
+    _checkBudget(chart) {
+        const report = timeBudget(chart);
+        const refusal = budgetRefusal(report);
+        if (refusal !== undefined)
+            fail(refusal);
+        if (!isDevMode())
+            return;
+        const warning = budgetWarning(report, chart.root.name);
+        // eslint-disable-next-line no-console
+        if (warning !== undefined)
+            console.warn(warning);
+    }
     /** Override the scope factory. Rarely needed — auto-embeds TypedScope by default. */
     setScopeFactory(factory) {
         this._scopeFactory = factory;
@@ -2075,6 +2263,7 @@ export function flowChart(name, fn, id, options) {
     }
     return builder.start(name, fn, id, options?.description, {
         ...(options?.retry && { retry: options.retry }),
+        ...(options?.touches && { touches: options.touches }),
         ...(options?.tags && { tags: options.tags }),
     });
 }
@@ -2102,6 +2291,7 @@ export function flowChartSelector(name, fn, id, options) {
     return builder.startSelector(name, fn, id, options?.description, {
         ...(options?.failFast !== undefined && { failFast: options.failFast }),
         ...(options?.retry && { retry: options.retry }),
+        ...(options?.touches && { touches: options.touches }),
         ...(options?.tags && { tags: options.tags }),
     });
 }
@@ -2117,4 +2307,4 @@ export function specToStageNode(spec) {
     });
     return inflate(spec);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FlowChartBuilder.js","sourceRoot":"","sources":["../../../../src/lib/builder/FlowChartBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * FlowChartBuilder — Fluent API for constructing flowchart execution graphs.\n *\n * Builds StageNode trees and SerializedPipelineStructure (JSON) in tandem.\n * Zero dependencies on old code — only imports from local types.\n *\n * The builder creates two parallel structures:\n * 1. StageNode tree — runtime graph with embedded functions\n * 2. SerializedPipelineStructure — JSON-safe structure for visualization\n *\n * The execute() convenience method is intentionally omitted —\n * it belongs in the runner layer (Phase 5).\n */\n\nimport { joinPath } from 'foottrace';\n\nimport { isDevMode } from '../devMode.js';\nimport { prefixNodeTree } from '../engine/graph/prefixNodeTree.js';\nimport type { ParallelForEachConfig, RetryPolicy, ScopeFactory } from '../engine/types.js';\nimport { BRANCH_SEGMENT_MARKER, hasBranchSegmentMarker } from '../ids/branchSegment.js';\nimport { type IdPosition, refuseReservedId } from '../ids/reservedIds.js';\nimport type { PausableHandler } from '../pause/types.js';\nimport type { TypedScope } from '../reactive/types.js';\nimport { type RunnableFlowChart, makeRunnable } from '../runner/RunnableChart.js';\nimport type { StructureEdgeKind, StructureRecorder } from './structure/StructureRecorder.js';\nimport { StructureRecorderDispatcher } from './structure/StructureRecorderDispatcher.js';\nimport { type TypedStageFunction, createTypedScopeFactory } from './typedFlowChart.js';\nimport type {\n  FlowChart,\n  FlowChartOptions,\n  FlowChartSpec,\n  ILogger,\n  SerializedPipelineStructure,\n  SimplifiedParallelSpec,\n  StageFunction,\n  StageNode,\n  StreamHandlers,\n  StreamLifecycleHandler,\n  StreamTokenHandler,\n  SubflowMountOptions,\n} from './types.js';\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Internal helpers\n// ─────────────────────────────────────────────────────────────────────────────\n\nconst fail = (msg: string): never => {\n  throw new Error(`[FlowChartBuilder] ${msg}`);\n};\n\n/**\n * Attach a declarative retry policy to a stage node + its spec node.\n *\n * The ONE place a policy lands on a node, shared by the `.retry()` cursor\n * modifier and by every `options.retry` declaration site, so validation and the\n * spec's `retryAttempts` mirror can never drift between them.\n *\n * `attempts` is validated at BUILD time rather than defended at runtime: a\n * typo'd `attempts: 0` should fail while you are writing the chart, not\n * silently turn a stage into a no-op run three months later. `attempts: 1` is\n * accepted on purpose — it means \"policy declared, currently off\", so a policy\n * can be dialled down without deleting the declaration.\n */\nfunction applyRetryPolicy(\n  node: StageNode<any, any>,\n  spec: SerializedPipelineStructure,\n  retry: RetryPolicy | undefined,\n  where: string,\n): void {\n  if (!retry) return;\n  if (typeof retry.attempts !== 'number' || !Number.isInteger(retry.attempts) || retry.attempts < 1) {\n    fail(\n      `${where}: retry.attempts must be a whole number >= 1 (got ${String(retry.attempts)}). ` +\n        'It counts TOTAL runs including the first, so `attempts: 3` means one run plus up to two retries; ' +\n        '`attempts: 1` means the policy is declared but currently off.',\n    );\n  }\n  node.retry = retry;\n  spec.retryAttempts = retry.attempts;\n}\n\n/**\n * Attach declared tags to a stage node + its spec node.\n *\n * The ONE place tags land on a node — the twin of {@link applyRetryPolicy} —\n * shared by the `.tag()` cursor modifier and every `options.tags` declaration\n * site, so the refusals and the spec's mirror can never drift between them.\n *\n * A tag is a NAME declared at build time, never a value, so every refusal is\n * about the name's shape: an empty string names nothing; a non-string is a\n * value, and a value on a stage would ride the commit log past every\n * redaction point; the branch-segment marker is the runtimeStageId grammar's\n * one reserved byte, and a consumer that puts a tag into a path (a URL, a\n * store key) would inherit exactly the ambiguity the reservation exists to\n * prevent; a name declared twice is the typo it usually is. Refused at BUILD\n * time, like `retry.attempts`, so the mistake fails while the chart is being\n * written. An EMPTY list lands nothing: \"absent when empty\" is the law the\n * commit bundle keeps, and the spec keeps it too.\n */\nfunction applyTags(\n  node: StageNode<any, any>,\n  spec: SerializedPipelineStructure,\n  tags: readonly string[] | undefined,\n  where: string,\n): void {\n  if (tags === undefined) return;\n  if (!Array.isArray(tags)) fail(`${where}: tags must be an array of names (got ${typeof tags})`);\n  if (tags.length === 0) return;\n  const seen = new Set<string>();\n  for (const tag of tags) {\n    if (typeof tag !== 'string') {\n      fail(\n        `${where}: a tag must be a string name (got ${tag === null ? 'null' : typeof tag}). A tag is a NAME ` +\n          'declared at build time — a value belongs in state or in $emit, never on the stage.',\n      );\n    }\n    if (tag.trim().length === 0) fail(`${where}: a tag cannot be an empty string`);\n    if (hasBranchSegmentMarker(tag)) {\n      fail(\n        `${where}: tag '${tag}' contains the reserved character '${BRANCH_SEGMENT_MARKER}'. ` +\n          `'${BRANCH_SEGMENT_MARKER}' is reserved for the subflow path segments addParallelForEach() generates, ` +\n          'and a tag that a consumer puts into a path or a key would inherit that ambiguity. Rename the tag ' +\n          '(a dash or a colon reads the same). See docs/design/2026-09-declared-tags.md.',\n      );\n    }\n    if (seen.has(tag)) fail(`${where}: tag '${tag}' is declared twice`);\n    seen.add(tag);\n  }\n  if (node.tags) {\n    fail(\n      `${where}: tags already declared at '${node.name}' (${node.tags.join(', ')}) — declare every tag for a ` +\n        'stage in ONE place, so the Map advertises the whole vocabulary from a single site.',\n    );\n  }\n  // The node's copy is frozen: commit bundles share it by reference and the\n  // library's reads are borrowed, never mutated. The spec's copy is its own\n  // plain array, JSON-safe like the rest of the spec.\n  node.tags = Object.freeze([...tags]);\n  spec.tags = [...tags];\n}\n\n/**\n * The builder's ONE id refusal (F7, R5): every id door calls it once, before\n * the id lands anywhere. The rule lives beside the grammar —\n * `ids/reservedIds.ts · refuseReservedId`: `#` and `/` are refused in\n * every id (they are the runtimeStageId grammar's delimiters), `~` in a\n * `'segment'` id (a subflow id or a `parallelForEach` id — see below).\n *\n * Doors (one call each): `start`, `startSelector`, `addFunction`,\n * `addStreamingFunction`, `addPausableFunction`, `addDeciderFunction`,\n * `addSelectorFunction`, `addListOfFunction` (each child), `addParallelForEach`,\n * every subflow mount (`assertSubflowIdAllowed`) and every decider/selector\n * branch (`BranchCursor · admit`). `addDetachAndForget` /\n * `addDetachAndJoinLater` and `addBranchList` delegate to one of these.\n * Never called by the prefixer or a store — those hold ids that carry the\n * delimiters on purpose.\n */\nconst admitId = (what: string, id: string, position: IdPosition): void => {\n  const refusal = refuseReservedId(what, id, position);\n  if (refusal !== undefined) fail(refusal);\n};\n\n/**\n * Refuse the reserved characters in a user-authored SUBFLOW id.\n *\n * A subflow id IS a path segment in `runtimeStageId`, which is the same\n * position `addParallelForEach` generates its branch segments into. A\n * hand-authored id carrying the marker could therefore collide with a\n * generated branch — and, because this codebase deliberately tolerates\n * id-collision classes (loop-ref stubs), such a collision would not crash. It\n * would silently mis-attribute a trace, which is worse. So the marker is\n * refused at BUILD time, on NEW charts only: a chart that was legal before\n * 9.14.0 and does not use the marker behaves byte-identically.\n *\n * Called at every user-authored subflow-id entry point. Stage ids elsewhere\n * keep `~` (they occupy the `stageId` position, never the `subflowPath`\n * position, so they cannot collide with a segment) but, since 9.37.0, not `#`\n * or `/` — see `admitId`. (`addParallelForEach`'s own id is the one other\n * `'segment'` id, refused at that method.) Design: docs/design/execution-control.md.\n */\nconst assertSubflowIdAllowed = (id: string): void => admitId('subflow id', id, 'segment');\n\n// ─────────────────────────────────────────────────────────────────────────────\n// BranchCursor — what DeciderList and SelectorFnList share (F7)\n// ─────────────────────────────────────────────────────────────────────────────\n\n/** Which dispatcher a {@link BranchCursor} adds branches under. */\ntype BranchKind = 'decider' | 'selector';\n\n/**\n * The branch-adding mechanics of a decider or a selector — ONE implementation,\n * composed by {@link DeciderList} and {@link SelectorFnList} (until 9.36.0 each\n * list carried its own copy of all four branch kinds and `end()`).\n *\n * Owns: the branch-id ledger (duplicate + reserved-character refusal in one\n * `admit`), the node/spec pair each branch kind builds, the structure events,\n * and the closing `finish`. The lists keep only what differs: a decider's\n * `{ loopTo }` / `loopTo()` / `setDefault`, and the type each method returns.\n */\nclass BranchCursor<TOut, TScope> {\n  readonly branchIds = new Set<string>();\n  private readonly branchDescInfo: Array<{ id: string; description?: string }> = [];\n\n  constructor(\n    private readonly kind: BranchKind,\n    readonly b: FlowChartBuilder<TOut, TScope>,\n    readonly curNode: StageNode<TOut, TScope>,\n    readonly curSpec: SerializedPipelineStructure,\n    readonly parentDescriptionParts: string[],\n    private readonly parentStageDescriptions: Map<string, string>,\n    private readonly reservedStepNumber: number,\n    private readonly description?: string,\n  ) {}\n\n  /**\n   * A dispatcher is defined ONCE. `finish` flags its node, and from then on\n   * the node's branches, its `branchIds` and its `onDeciderComplete` are\n   * final. A list held past `.end()` could re-open it — a second `end()`\n   * appended another `'default'` clone, fired a second completion and wrote a\n   * second description line; a late branch or `loopTo` changed a node whose\n   * `branchIds` were already published. This is the one same-node refusal.\n   * The guard that `addDeciderFunction` / `addSelectorFunction` carried until\n   * 10.0.1 read the PREVIOUS node's flags instead, and so refused a dispatcher\n   * that follows a dispatcher — a chain, which is a new node at its `next`.\n   */\n  assertOpen(action: string): void {\n    if (this.curNode.deciderFn || this.curNode.selectorFn) {\n      fail(`cannot ${action}: ${this.kind} '${this.curNode.name}' was already closed by end()`);\n    }\n  }\n\n  /** The one branch-id door: a closed dispatcher, a duplicate, then the reserved characters (R5). */\n  private admit(id: string, position: IdPosition): void {\n    this.assertOpen(`add branch '${id}'`);\n    if (this.branchIds.has(id)) fail(`duplicate ${this.kind} branch id '${id}' under '${this.curNode.name}'`);\n    if (position === 'segment') assertSubflowIdAllowed(id);\n    else admitId('branch id', id, 'stage');\n    this.branchIds.add(id);\n  }\n\n  /** Append the branch's node + spec and fire its stage and decision-branch edge. */\n  private attach(node: StageNode<TOut, TScope>, spec: SerializedPipelineStructure, id: string): void {\n    this.curNode.children = this.curNode.children || [];\n    this.curNode.children.push(node);\n    this.curSpec.children = this.curSpec.children || [];\n    this.curSpec.children.push(spec);\n    // L7.3 — branch: stage + decision-branch edge keyed by id.\n    this.b._fireStageAddedFromSubBuilder(spec);\n    this.b._fireEdgeAddedFromSubBuilder(this.curSpec.id, spec.id, 'decision-branch', id);\n  }\n\n  functionBranch(\n    id: string,\n    name: string,\n    fn: StageFunction<TOut, TScope> | undefined,\n    description: string | undefined,\n    options: { readonly retry?: RetryPolicy; readonly tags?: readonly string[] } | undefined,\n  ): { node: StageNode<TOut, TScope>; spec: SerializedPipelineStructure } {\n    this.admit(id, 'stage');\n\n    const node: StageNode<TOut, TScope> = { name: name ?? id, id, branchId: id };\n    if (description) node.description = description;\n    if (fn) {\n      node.fn = fn;\n    }\n    this.b._registerStage(id, fn);\n\n    const spec: SerializedPipelineStructure = { name: name ?? id, id, type: 'stage' };\n    if (description) spec.description = description;\n    applyRetryPolicy(node, spec, options?.retry, `addFunctionBranch('${id}')`);\n    applyTags(node, spec, options?.tags, `addFunctionBranch('${id}')`);\n\n    this.attach(node, spec, id);\n    this.branchDescInfo.push({ id, description });\n    return { node, spec };\n  }\n\n  pausableBranch(\n    id: string,\n    name: string,\n    handler: PausableHandler<TScope>,\n    description: string | undefined,\n    options: { readonly retry?: RetryPolicy; readonly tags?: readonly string[] } | undefined,\n  ): { node: StageNode<TOut, TScope>; spec: SerializedPipelineStructure } {\n    this.admit(id, 'stage');\n\n    const node: StageNode<TOut, TScope> = {\n      name: name ?? id,\n      id,\n      branchId: id,\n      fn: handler.execute as StageFunction<TOut, TScope>,\n      isPausable: true,\n      resumeFn: handler.resume,\n    };\n    if (description) node.description = description;\n    this.b._addToMap(id, handler.execute as StageFunction<TOut, TScope>);\n\n    const spec: SerializedPipelineStructure = { name: name ?? id, id, type: 'stage', isPausable: true };\n    if (description) spec.description = description;\n    applyRetryPolicy(node, spec, options?.retry, `addPausableFunctionBranch('${id}')`);\n    applyTags(node, spec, options?.tags, `addPausableFunctionBranch('${id}')`);\n\n    this.attach(node, spec, id);\n    this.branchDescInfo.push({ id, description });\n    return { node, spec };\n  }\n\n  subflowBranch(\n    id: string,\n    subflow: FlowChart<any, any>,\n    mountName: string | undefined,\n    options: SubflowMountOptions | undefined,\n  ): void {\n    this.admit(id, 'segment');\n\n    const subflowName = mountName || id;\n    this.b._mountSubflow(id, subflow, () => this.placeSubflowBranch(id, subflow, subflowName, options));\n  }\n\n  /** The branch mount's own node + spec, placed under the decider/selector (see `_mountSubflow`). */\n  private placeSubflowBranch(\n    id: string,\n    subflow: FlowChart<any, any>,\n    subflowName: string,\n    options: SubflowMountOptions | undefined,\n  ): void {\n    const node: StageNode<TOut, TScope> = {\n      name: subflowName,\n      id,\n      branchId: id,\n      isSubflowRoot: true,\n      subflowId: id,\n      subflowName,\n    };\n    if (options) node.subflowMountOptions = options;\n\n    const spec: SerializedPipelineStructure = {\n      name: subflowName,\n      type: 'stage',\n      id,\n      isSubflowRoot: true,\n      subflowId: id,\n      subflowName,\n      subflowStructure: subflow.buildTimeStructure,\n    };\n    // STRUCTURE-ONLY convergence override (see `_fireNextEdgeFromParent` +\n    // `SubflowMountOptions.convergeAt`): this branch's convergence edge points at\n    // `convergeAt` (a DOWNSTREAM stage) instead of the shared next stage — e.g. a\n    // `tools` slot that bypasses `messageAPI` to pair with its output at\n    // `call-llm`. Visualization-only: NO runtime join barrier (data rides scope).\n    // Carried on the spec so the edge-firing chokepoint can read it.\n    if (options?.convergeAt) spec.convergeAt = options.convergeAt;\n\n    applyTags(node, spec, options?.tags, `addSubFlowChartBranch('${id}')`);\n\n    this.attach(node, spec, id);\n    this.b._fireSubflowMountedFromSubBuilder(id, subflowName, id, false, subflow.buildTimeStructure);\n  }\n\n  lazySubflowBranch(\n    id: string,\n    resolver: () => FlowChart<any, any>,\n    mountName: string | undefined,\n    options: SubflowMountOptions | undefined,\n  ): void {\n    this.admit(id, 'segment');\n    this.b._claimFreshId(id, `addLazySubFlowChartBranch('${id}')`);\n\n    const subflowName = mountName || id;\n\n    // Store resolver on the node — NO eager tree cloning\n    const node: StageNode<TOut, TScope> = {\n      name: subflowName,\n      id,\n      branchId: id,\n      isSubflowRoot: true,\n      subflowId: id,\n      subflowName,\n      subflowResolver: resolver as any,\n    };\n    if (options) node.subflowMountOptions = options;\n\n    // Spec stub — no subflowStructure (lazy). The lazy subflow's\n    // internals will be shaped at resolution time.\n    const spec: SerializedPipelineStructure = {\n      name: subflowName,\n      type: 'stage',\n      id,\n      isSubflowRoot: true,\n      subflowId: id,\n      subflowName,\n      isLazy: true,\n    };\n\n    applyTags(node, spec, options?.tags, `addLazySubFlowChartBranch('${id}')`);\n\n    this.attach(node, spec, id);\n    this.b._fireSubflowMountedFromSubBuilder(id, subflowName, id, true);\n  }\n\n  /**\n   * Close the dispatcher: validate the branches, flag the node, describe it,\n   * and fire `onDeciderComplete`. A decider passes its `setDefault` id (the\n   * synthetic `'default'` clone is appended AFTER `branchIds` is taken, so only\n   * user-specified branches are listed); a selector has no default.\n   */\n  finish(defaultId?: string): FlowChartBuilder<TOut, TScope> {\n    this.assertOpen('call end() again');\n    const kind = this.kind;\n    const children = this.curNode.children;\n    if (!children || children.length === 0) {\n      throw new Error(`[FlowChartBuilder] ${kind} at '${this.curNode.name}' requires at least one branch`);\n    }\n\n    // Validate that every branch with no embedded fn is resolvable from the stageMap\n    for (const child of children) {\n      if (!child.fn && child.id && !child.isSubflowRoot && !child.subflowResolver) {\n        const hasInMap = this.b._stageMapHas(child.id) || this.b._stageMapHas(child.name);\n        if (!hasInMap) {\n          throw new Error(\n            `[FlowChartBuilder] ${kind} branch '${child.id}' under '${this.curNode.name}' has no function — ` +\n              `provide a fn argument to addFunctionBranch('${child.id}', ...)`,\n          );\n        }\n      }\n    }\n\n    if (kind === 'decider') this.curNode.deciderFn = true;\n    else this.curNode.selectorFn = true;\n\n    this.curSpec.branchIds = children\n      .map((c) => c.id)\n      .filter((id): id is string => typeof id === 'string' && id.length > 0);\n    this.curSpec.type = kind;\n    if (kind === 'selector') this.curSpec.hasSelector = true;\n\n    if (defaultId) {\n      const defaultChild = children.find((c) => c.id === defaultId);\n      if (defaultChild) {\n        children.push({ ...defaultChild, id: 'default', branchId: 'default' });\n      }\n    }\n\n    if (this.reservedStepNumber > 0) {\n      const label = this.curNode.name;\n      const branchIdList = this.branchDescInfo.map((b) => b.id).join(', ');\n      const mainLine =\n        kind === 'decider'\n          ? this.description\n            ? `${this.reservedStepNumber}. ${label} — ${this.description} (branches: ${branchIdList})`\n            : `${this.reservedStepNumber}. ${label} — Decides between: ${branchIdList}`\n          : this.description\n          ? `${this.reservedStepNumber}. ${label} — ${this.description}`\n          : `${this.reservedStepNumber}. ${label} — Selects from: ${branchIdList}`;\n      this.parentDescriptionParts.push(mainLine);\n\n      if (this.description) {\n        this.parentStageDescriptions.set(this.curNode.name, this.description);\n      }\n\n      for (const branch of this.branchDescInfo) {\n        if (branch.description) this.parentDescriptionParts.push(`   → ${branch.id}: ${branch.description}`);\n        if (branch.description) this.parentStageDescriptions.set(branch.id, branch.description);\n      }\n    }\n\n    // L7.3 — fire `onDeciderComplete` so consumers can trust no more\n    // branches will arrive. Branch iteration order = addition order = Set\n    // insertion order. Selectors have no default branch.\n    if (kind === 'decider') {\n      this.b._fireDeciderCompleteFromSubBuilder(this.curSpec.id, 'decider', [...this.branchIds], defaultId);\n    } else {\n      this.b._fireDeciderCompleteFromSubBuilder(this.curSpec.id, 'selector', [...this.branchIds]);\n    }\n    return this.b;\n  }\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// DeciderList\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Fluent helper returned by addDeciderFunction to add branches.\n * `end()` sets `deciderFn = true` — the fn IS the decider.\n */\nexport class DeciderList<TOut = any, TScope = any> {\n  private readonly cursor: BranchCursor<TOut, TScope>;\n  private defaultId?: string;\n\n  constructor(\n    builder: FlowChartBuilder<TOut, TScope>,\n    curNode: StageNode<TOut, TScope>,\n    curSpec: SerializedPipelineStructure,\n    parentDescriptionParts: string[] = [],\n    parentStageDescriptions: Map<string, string> = new Map(),\n    reservedStepNumber = 0,\n    deciderDescription?: string,\n  ) {\n    this.cursor = new BranchCursor(\n      'decider',\n      builder,\n      curNode,\n      curSpec,\n      parentDescriptionParts,\n      parentStageDescriptions,\n      reservedStepNumber,\n      deciderDescription,\n    );\n  }\n\n  addFunctionBranch(\n    id: string,\n    name: string,\n    fn?: StageFunction<TOut, TScope>,\n    description?: string,\n    /** `{ loopTo }` declares this branch loops back to an already-declared\n     *  stage — the loop is SOURCED FROM THIS BRANCH (not the decider).\n     *  `{ retry }` gives THIS BRANCH's stage a declarative retry policy;\n     *  `{ tags }` puts declared tags on it (see `FlowChartBuilder.tag`). */\n    options?: { readonly loopTo?: string; readonly retry?: RetryPolicy; readonly tags?: readonly string[] },\n  ): DeciderList<TOut, TScope> {\n    const { node, spec } = this.cursor.functionBranch(id, name, fn, description, options);\n    if (options?.loopTo) this._applyBranchLoop(node, spec, options.loopTo);\n    return this;\n  }\n\n  /**\n   * Add a pausable stage as a decider branch.\n   *\n   * When this branch is chosen, the handler's `execute` runs. If it returns\n   * data, the pipeline pauses. On resume, `handler.resume` runs with the\n   * human's input. If `execute` returns void, the stage continues normally\n   * (conditional pause).\n   */\n  addPausableFunctionBranch(\n    id: string,\n    name: string,\n    handler: PausableHandler<TScope>,\n    description?: string,\n    /** `{ loopTo }` declares this branch loops back to an already-declared\n     *  stage — the loop is SOURCED FROM THIS BRANCH (not the decider).\n     *  `{ retry }` gives THIS BRANCH's `execute` half a retry policy (the\n     *  `resume` half runs without it — a different function, a different\n     *  contract); `{ tags }` puts declared tags on it. */\n    options?: { readonly loopTo?: string; readonly retry?: RetryPolicy; readonly tags?: readonly string[] },\n  ): DeciderList<TOut, TScope> {\n    const { node, spec } = this.cursor.pausableBranch(id, name, handler, description, options);\n    if (options?.loopTo) this._applyBranchLoop(node, spec, options.loopTo);\n    return this;\n  }\n\n  addSubFlowChartBranch(\n    id: string,\n    subflow: FlowChart<any, any>,\n    mountName?: string,\n    options?: SubflowMountOptions,\n  ): DeciderList<TOut, TScope> {\n    this.cursor.subflowBranch(id, subflow, mountName, options);\n    return this;\n  }\n\n  addLazySubFlowChartBranch(\n    id: string,\n    resolver: () => FlowChart<any, any>,\n    mountName?: string,\n    options?: SubflowMountOptions,\n  ): DeciderList<TOut, TScope> {\n    this.cursor.lazySubflowBranch(id, resolver, mountName, options);\n    return this;\n  }\n\n  addBranchList(\n    branches: Array<{\n      id: string;\n      name: string;\n      fn?: StageFunction<TOut, TScope>;\n    }>,\n  ): DeciderList<TOut, TScope> {\n    for (const { id, name, fn } of branches) {\n      this.addFunctionBranch(id, name, fn);\n    }\n    return this;\n  }\n\n  setDefault(id: string): DeciderList<TOut, TScope> {\n    this.cursor.assertOpen(`setDefault('${id}')`);\n    this.defaultId = id;\n    return this;\n  }\n\n  /**\n   * Attach a loop-back edge to the LAST-added branch, so the loop is sourced\n   * from THAT branch node (e.g. `'tool-calls' → loopTo('context')`) rather than\n   * from the decider. The chart then reads honestly: the decider splits into a\n   * looping branch `[ToolCalls → back to Context]` and a terminating branch\n   * `[Final → end]`, instead of a single loop hanging off the decider.\n   *\n   * No engine change is needed: the runtime runs the chosen branch and then\n   * follows that branch node's OWN `next` — and a `next` flagged `isLoopRef`\n   * routes back to the target exactly like the decider's own loop does. This\n   * method just lets the builder express what the engine already supports.\n   *\n   * Targets the branch added immediately before this call (chain it right after\n   * the branch's `addFunctionBranch`/`addPausableFunctionBranch`/\n   * `addSubFlowChartBranch`). Mirrors `FlowChartBuilder.loopTo` validation.\n   *\n   * Works on a SUBFLOW branch too: the branch node carries both its subflow\n   * resolver AND the loop-back `next` — they coexist safely (the runtime runs\n   * the subflow, then follows the loop ref). The target must be a stage already\n   * declared BEFORE the decider (e.g. an upstream `context`); branch ids and the\n   * synthetic `'default'` clone are NOT valid loop targets.\n   */\n  loopTo(stageId: string): DeciderList<TOut, TScope> {\n    this.cursor.assertOpen(`loopTo('${stageId}')`);\n    const children = this.cursor.curNode.children;\n    const specChildren = this.cursor.curSpec.children;\n    if (!children || children.length === 0 || !specChildren || specChildren.length === 0) {\n      fail(`loopTo('${stageId}') called before any branch was added under '${this.cursor.curNode.name}'`);\n    }\n    // fail() throws, so children/specChildren are non-empty here.\n    this._applyBranchLoop(children![children!.length - 1]!, specChildren![specChildren!.length - 1]!, stageId);\n    return this;\n  }\n\n  /**\n   * Decorate ONE branch node/spec with a loop-back edge to `stageId`. Shared by\n   * the positional `loopTo()` (which targets the last-added branch) AND the\n   * per-branch `{ loopTo }` option on `addFunctionBranch` /\n   * `addPausableFunctionBranch` / `addSubFlowChartBranch`. Either way the loop\n   * SOURCE is the branch — so visualizers read `tool-calls → context`, never\n   * `Route → context`. Validates the target is a stage declared BEFORE the\n   * decider (branch ids / the synthetic 'default' clone are not valid targets).\n   */\n  private _applyBranchLoop(\n    branchNode: StageNode<TOut, TScope>,\n    branchSpec: SerializedPipelineStructure,\n    stageId: string,\n  ): void {\n    if (branchSpec.loopTarget) fail(`loopTo already defined on branch '${branchSpec.id}'`);\n    if (branchNode.next) {\n      fail(`cannot set loopTo on branch '${branchSpec.id}' — it already has a continuation`);\n    }\n    if (!this.cursor.b._knownStageIdsHas(stageId)) {\n      fail(\n        `loopTo('${stageId}') target not found — a branch loop must target a stage ` +\n          \"declared BEFORE the decider (branch ids and the synthetic 'default' branch \" +\n          'are not valid loop targets; did you pass a stage name instead of an id?)',\n      );\n    }\n\n    branchNode.next = { name: stageId, id: stageId, isLoopRef: true };\n    branchSpec.loopTarget = stageId;\n    branchSpec.next = { name: stageId, id: stageId, type: 'loop', isLoopReference: true };\n\n    // Branch-scoped description — attribute the loop to the branch, not the\n    // decider (parentDescriptionParts is the decider's description context).\n    this.cursor.parentDescriptionParts.push(`   → branch '${branchSpec.id}' loops back to ${stageId}`);\n\n    // Fire the loop back-edge SOURCED FROM THE BRANCH so visualizers read\n    // `tool-calls → context`, not `Route → context`.\n    this.cursor.b._fireLoopEdgeAddedFromSubBuilder(branchSpec.id, stageId);\n  }\n\n  end(): FlowChartBuilder<TOut, TScope> {\n    return this.cursor.finish(this.defaultId);\n  }\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// SelectorFnList (scope-based selector — mirrors DeciderList)\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport class SelectorFnList<TOut = any, TScope = any> {\n  private readonly cursor: BranchCursor<TOut, TScope>;\n\n  constructor(\n    builder: FlowChartBuilder<TOut, TScope>,\n    curNode: StageNode<TOut, TScope>,\n    curSpec: SerializedPipelineStructure,\n    parentDescriptionParts: string[] = [],\n    parentStageDescriptions: Map<string, string> = new Map(),\n    reservedStepNumber = 0,\n    selectorDescription?: string,\n  ) {\n    this.cursor = new BranchCursor(\n      'selector',\n      builder,\n      curNode,\n      curSpec,\n      parentDescriptionParts,\n      parentStageDescriptions,\n      reservedStepNumber,\n      selectorDescription,\n    );\n  }\n\n  addFunctionBranch(\n    id: string,\n    name: string,\n    fn?: StageFunction<TOut, TScope>,\n    description?: string,\n    /** `{ retry }` gives THIS BRANCH's stage a declarative retry policy;\n     *  `{ tags }` puts declared tags on it (see `FlowChartBuilder.tag`). */\n    options?: { readonly retry?: RetryPolicy; readonly tags?: readonly string[] },\n  ): SelectorFnList<TOut, TScope> {\n    this.cursor.functionBranch(id, name, fn, description, options);\n    return this;\n  }\n\n  /**\n   * Add a pausable stage as a selector branch.\n   *\n   * When this branch is selected, the handler's `execute` runs. If it returns\n   * data, the pipeline pauses. On resume, `handler.resume` runs with the\n   * human's input. If `execute` returns void, the stage continues normally.\n   */\n  addPausableFunctionBranch(\n    id: string,\n    name: string,\n    handler: PausableHandler<TScope>,\n    description?: string,\n    /** `{ retry }` gives THIS BRANCH's `execute` half a retry policy (the\n     *  `resume` half runs without it — a different function, a different\n     *  contract); `{ tags }` puts declared tags on it. */\n    options?: { readonly retry?: RetryPolicy; readonly tags?: readonly string[] },\n  ): SelectorFnList<TOut, TScope> {\n    this.cursor.pausableBranch(id, name, handler, description, options);\n    return this;\n  }\n\n  addSubFlowChartBranch(\n    id: string,\n    subflow: FlowChart<any, any>,\n    mountName?: string,\n    options?: SubflowMountOptions,\n  ): SelectorFnList<TOut, TScope> {\n    this.cursor.subflowBranch(id, subflow, mountName, options);\n    return this;\n  }\n\n  addLazySubFlowChartBranch(\n    id: string,\n    resolver: () => FlowChart<any, any>,\n    mountName?: string,\n    options?: SubflowMountOptions,\n  ): SelectorFnList<TOut, TScope> {\n    this.cursor.lazySubflowBranch(id, resolver, mountName, options);\n    return this;\n  }\n\n  addBranchList(\n    branches: Array<{\n      id: string;\n      name: string;\n      fn?: StageFunction<TOut, TScope>;\n    }>,\n  ): SelectorFnList<TOut, TScope> {\n    for (const { id, name, fn } of branches) {\n      this.addFunctionBranch(id, name, fn);\n    }\n    return this;\n  }\n\n  end(): FlowChartBuilder<TOut, TScope> {\n    return this.cursor.finish();\n  }\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// FlowChartBuilder\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport class FlowChartBuilder<TOut = any, TScope = any> {\n  private _root?: StageNode<TOut, TScope>;\n  private _rootSpec?: SerializedPipelineStructure;\n  private _cursor?: StageNode<TOut, TScope>;\n  private _cursorSpec?: SerializedPipelineStructure;\n  private _stageMap = new Map<string, StageFunction<TOut, TScope>>();\n  _subflowDefs = new Map<string, { root: StageNode<TOut, TScope> }>();\n  private _streamHandlers: StreamHandlers = {};\n  /**\n   * L7.3 — Build-time observer fan-out. Owned by the builder so every\n   * `addX()` method can fire `StructureRecorder` events at the natural\n   * moment of the corresponding mutation. Dispatcher is allocated\n   * lazily on first attach to keep the zero-recorder path allocation-\n   * free.\n   */\n  private _structureDispatcher?: StructureRecorderDispatcher;\n  /**\n   * L7.3 — Sealed-after-build flag (Panel 2 phase invariant). Flips\n   * to `true` when `.build()` returns; subsequent `attachStructureRecorder`\n   * throws. Prevents the footgun where a consumer attaches a recorder\n   * mid-execution and gets partial structure data (missed every event\n   * already fired during construction).\n   */\n  private _sealed = false;\n  private _enableNarrative = false;\n  private _logger?: ILogger;\n  private _descriptionParts: string[] = [];\n  private _stepCounter = 0;\n  // NOTE: keyed by stage name (for human-readable descriptions), while stageMap\n  // and knownStageIds use id (stable identifier). These are intentionally different\n  // namespaces — descriptions are presentational, lookups are structural.\n  private _stageDescriptions = new Map<string, string>();\n  private _stageStepMap = new Map<string, number>();\n  private _knownStageIds = new Set<string>();\n  private _inputSchema?: unknown;\n  private _outputSchema?: unknown;\n  private _outputMapper?: (finalScope: Record<string, unknown>) => unknown;\n  private _scopeFactory?: ScopeFactory<TScope>;\n\n  // ── L7.3 — StructureRecorder attach + dispatch helpers ──────────────────\n\n  /**\n   * Attach a `StructureRecorder` for build-phase observation. Multiple\n   * recorders coexist (same id allowed; iteration order = attach\n   * order). Throws if called after `.build()` — the chart is sealed at\n   * that point and any recorder attached late would miss every event\n   * fired during construction.\n   *\n   * **Seed replay**: when this is called AFTER `start()` has already\n   * fired (i.e., after the `flowChart()` factory returns), the\n   * just-attached recorder receives a one-time `onStageAdded` for the\n   * root stage so it observes the seed. Only the new recorder sees\n   * the replay; already-attached recorders are not re-fired.\n   *\n   * **Mid-chain attach caveat**: a recorder attached AFTER one or more\n   * `addX()` calls receives the seed replay but MISSES every\n   * intermediate event. Attach BEFORE the first `addX()` for complete\n   * capture.\n   *\n   * Public for now to enable direct attach in tests + early consumers.\n   * L7.4 will wire `flowChart(..., { structureRecorders: [...] })` as\n   * an additional registration site; this method will remain.\n   */\n  attachStructureRecorder(recorder: StructureRecorder): this {\n    if (this._sealed) {\n      throw new Error(\n        `[FlowChartBuilder] attachStructureRecorder('${recorder.id}') called after .build() — chart is sealed; ` +\n          'the recorder would miss every structure event from construction. Attach BEFORE .build().',\n      );\n    }\n    if (!this._structureDispatcher) {\n      this._structureDispatcher = new StructureRecorderDispatcher();\n    }\n    this._structureDispatcher.attach(recorder);\n    // The seed fires inside `start()` — that runs BEFORE the consumer\n    // can post-construct attach. Replay the seed event ONLY into the\n    // just-attached recorder so other already-attached recorders don't\n    // see a duplicate. Errors are routed through the dispatcher's\n    // accumulator so the contract stays uniform.\n    if (this._rootSpec) {\n      try {\n        recorder.onStageAdded?.({\n          stageId: this._rootSpec.id,\n          name: this._rootSpec.name,\n          type: this._rootSpec.type ?? 'stage',\n          ...(this._rootSpec.isPausable === true && { isPausable: true }),\n          ...(this._rootSpec.tags !== undefined && { tags: [...this._rootSpec.tags] }),\n          spec: this._rootSpec as unknown as FlowChartSpec,\n        });\n      } catch (err) {\n        this._structureDispatcher.recordErrorForReplay(recorder.id, 'onStageAdded', err);\n      }\n    }\n    return this;\n  }\n\n  /**\n   * Inspect accumulated `StructureBuildError`s. Returns empty array\n   * when no recorders attached OR no errors occurred. Returns a\n   * defensive copy — caller mutations do not affect subsequent calls.\n   *\n   * **Call on the BUILDER, not the chart returned by `.build()`.**\n   * Capture the builder reference before `.build()` if you need\n   * post-build access:\n   * ```ts\n   * const builder = flowChart(...).attachStructureRecorder(rec);\n   * const chart = builder.build();\n   * const errors = builder.getStructureBuildErrors();\n   * ```\n   */\n  getStructureBuildErrors(): ReturnType<StructureRecorderDispatcher['getErrors']> {\n    return this._structureDispatcher?.getErrors() ?? [];\n  }\n\n  // Convenience fire helpers — no-op when no dispatcher attached. Keeps\n  // every call site a one-liner without the `if (this._structureDispatcher)`\n  // boilerplate everywhere.\n  private _fireStageAdded(spec: SerializedPipelineStructure): void {\n    if (!this._structureDispatcher) return;\n    // Read `isPausable` directly from the spec — single source of truth.\n    // The previous `extras` argument was a sub-builder footgun: branch\n    // helpers in DeciderList/SelectorFnList went through\n    // `_fireStageAddedFromSubBuilder` which dropped the extras, silently\n    // losing `isPausable: true` on pausable decider/selector branches.\n    const isPausable = spec.isPausable === true;\n    this._structureDispatcher.fireStageAdded({\n      stageId: spec.id,\n      name: spec.name,\n      type: spec.type ?? 'stage',\n      ...(isPausable && { isPausable: true }),\n      ...(spec.tags !== undefined && { tags: [...spec.tags] }),\n      spec: spec as unknown as FlowChartSpec,\n    });\n  }\n\n  private _fireStageTagged(spec: SerializedPipelineStructure): void {\n    if (!this._structureDispatcher || spec.tags === undefined) return;\n    this._structureDispatcher.fireStageTagged({\n      stageId: spec.id,\n      name: spec.name,\n      tags: [...spec.tags],\n      spec: spec as unknown as FlowChartSpec,\n    });\n  }\n\n  private _fireEdgeAdded(from: string, to: string, kind: StructureEdgeKind, label?: string): void {\n    if (!this._structureDispatcher) return;\n    this._structureDispatcher.fireEdgeAdded({\n      from,\n      to,\n      kind,\n      ...(label !== undefined && { label }),\n    });\n  }\n\n  private _fireLoopEdgeAdded(from: string, to: string): void {\n    if (!this._structureDispatcher) return;\n    this._structureDispatcher.fireLoopEdgeAdded({ from, to });\n  }\n\n  /**\n   * Fire the `next` edge(s) from a parent spec to a freshly-added\n   * node — with convergence expansion when the parent is a\n   * fork / decider / selector with branches.\n   *\n   * A fork at `parent` is semantically `parent ──fork-branch──► child[i]`\n   * for each child, and the chained `.addFunction(X)` continues\n   * AFTER the fork converges. The runtime semantics are that each\n   * child INDEPENDENTLY feeds `X` (parallel completion → join). The\n   * literal \"edge from parent to X\" would misrepresent this —\n   * visualizers and topological algorithms would see one edge where\n   * there should be N convergence edges.\n   *\n   * Fix: when `parentSpec` has branch children (fork or branched\n   * decider/selector), fire one `next` edge from EACH child to the\n   * target. Otherwise fire the single edge from `parentSpec` itself.\n   *\n   * Loop-reference children (synthetic spec nodes created by\n   * `.loopTo()`) are excluded — they're back-edge markers, not\n   * convergence sources. A branch that carries an OWN loop-back `next`\n   * (a branch-sourced `loopTo`) is likewise skipped — it loops, it does\n   * not converge at the linear next stage.\n   *\n   * A branch carrying `convergeAt` is REDIRECTED: its single convergence\n   * edge fires to its named target instead of `targetId` — expressing an\n   * unequal-depth merge (e.g. `tools → call-llm`, bypassing `message-api`).\n   * The named target is a forward stage, so it is NOT validated here.\n   *\n   * Call ORDER constraint: must be called BEFORE the cursor advances\n   * to the new target. The caller passes the PRE-ADVANCE parent spec.\n   */\n  private _fireNextEdgeFromParent(parentSpec: SerializedPipelineStructure, targetId: string, label?: string): void {\n    if (!this._structureDispatcher) return;\n    const childSpecs = parentSpec.children;\n    const isBranchingParent =\n      (parentSpec.type === 'fork' || parentSpec.type === 'decider' || parentSpec.type === 'selector') &&\n      Array.isArray(childSpecs) &&\n      childSpecs.length > 0;\n    if (!isBranchingParent) {\n      this._fireEdgeAdded(parentSpec.id, targetId, 'next', label);\n      return;\n    }\n    for (const child of childSpecs!) {\n      if (child.isLoopReference) continue;\n      // A branch with its own loop-back next (branch-sourced loopTo) loops —\n      // it does not converge at the linear next stage.\n      if (child.next?.isLoopReference) continue;\n      if (child.convergeAt) {\n        // Redirected convergence: this branch rejoins at its named target.\n        this._fireEdgeAdded(child.id, child.convergeAt, 'next');\n        continue;\n      }\n      this._fireEdgeAdded(child.id, targetId, 'next', label);\n    }\n  }\n\n  private _fireDeciderComplete(\n    decider: string,\n    type: 'decider' | 'selector',\n    branchIds: string[],\n    defaultBranch?: string,\n  ): void {\n    if (!this._structureDispatcher) return;\n    this._structureDispatcher.fireDeciderComplete({\n      decider,\n      type,\n      branchIds,\n      ...(defaultBranch !== undefined && { defaultBranch }),\n    });\n  }\n\n  private _fireSubflowMounted(\n    subflowId: string,\n    subflowName: string,\n    rootStageId: string,\n    isLazy?: boolean,\n    subflowSpec?: SerializedPipelineStructure,\n    subflowPath?: string,\n  ): void {\n    if (!this._structureDispatcher) return;\n    // subflowPath defaults to subflowId when the recorder is attached\n    // to the immediate parent (top-level mount); composed paths apply\n    // only when this builder is itself a nested subflow being\n    // observed by the grandparent's recorder.\n    const path = subflowPath ?? subflowId;\n    this._structureDispatcher.fireSubflowMounted({\n      subflowId,\n      subflowName,\n      rootStageId,\n      ...(isLazy === true && { isLazy }),\n      ...(subflowSpec !== undefined && { subflowSpec }),\n      subflowPath: path,\n    });\n  }\n\n  /** Sub-builder access (`.b._fireXxx`) is needed by DeciderList /\n   *  SelectorFnList; expose the dispatcher through internal helpers\n   *  that go through the same no-op-when-absent guard.\n   *\n   *  @internal — these methods are exposed because TypeScript `private`\n   *  doesn't traverse class boundaries. Consumer code MUST NOT call\n   *  them; calling them post-construction lets a hostile caller\n   *  fabricate structure events and corrupt downstream visualizations\n   *  or audit trails. The `_` prefix is intentional convention. */\n  _fireEdgeAddedFromSubBuilder(from: string, to: string, kind: StructureEdgeKind, label?: string): void {\n    this._fireEdgeAdded(from, to, kind, label);\n  }\n\n  /** @internal — see `_fireEdgeAddedFromSubBuilder`. */\n  _fireStageAddedFromSubBuilder(spec: SerializedPipelineStructure): void {\n    this._fireStageAdded(spec);\n  }\n\n  /** @internal — see `_fireEdgeAddedFromSubBuilder`. */\n  _fireDeciderCompleteFromSubBuilder(\n    decider: string,\n    type: 'decider' | 'selector',\n    branchIds: string[],\n    defaultBranch?: string,\n  ): void {\n    this._fireDeciderComplete(decider, type, branchIds, defaultBranch);\n  }\n\n  /** @internal — see `_fireEdgeAddedFromSubBuilder`. */\n  _fireSubflowMountedFromSubBuilder(\n    subflowId: string,\n    subflowName: string,\n    rootStageId: string,\n    isLazy?: boolean,\n    subflowSpec?: SerializedPipelineStructure,\n    subflowPath?: string,\n  ): void {\n    this._fireSubflowMounted(subflowId, subflowName, rootStageId, isLazy, subflowSpec, subflowPath);\n  }\n\n  /** @internal — see `_fireEdgeAddedFromSubBuilder`. Used by `DeciderList.loopTo`\n   *  to validate a branch-sourced loop target against the known stage ids\n   *  (mirrors `FlowChartBuilder.loopTo`'s `_knownStageIds.has` guard). */\n  _knownStageIdsHas(id: string): boolean {\n    return this._knownStageIds.has(id);\n  }\n\n  /** @internal — see `_fireEdgeAddedFromSubBuilder`. Used by `DeciderList.loopTo`\n   *  to fire a loop back-edge SOURCED FROM A BRANCH node (not the decider). */\n  _fireLoopEdgeAddedFromSubBuilder(from: string, to: string): void {\n    this._fireLoopEdgeAdded(from, to);\n  }\n\n  // ── Description helpers ──\n\n  private _appendDescriptionLine(name: string, description?: string): void {\n    this._stepCounter++;\n    this._stageStepMap.set(name, this._stepCounter);\n    const line = description ? `${this._stepCounter}. ${name} — ${description}` : `${this._stepCounter}. ${name}`;\n    this._descriptionParts.push(line);\n    if (description) {\n      this._stageDescriptions.set(name, description);\n    }\n  }\n\n  private _appendSubflowDescription(id: string, name: string, subflow: FlowChart<any, any>): void {\n    this._stepCounter++;\n    this._stageStepMap.set(id, this._stepCounter);\n    if (subflow.description) {\n      const lines = subflow.description.split('\\n');\n      const stepsIdx = lines.findIndex((l) => l.startsWith('Steps:'));\n      if (stepsIdx >= 0) {\n        // Builder-composed description (`FlowChart: X\\nSteps:\\n...`).\n        // Inline ONLY the summary above `Steps:` on the mount line, then\n        // re-list the step lines once, indented. Embedding the FULL inner\n        // description here AND re-listing its steps doubled the text per\n        // nesting level — exponential growth, RangeError (\"Invalid string\n        // length\") at ~22 nesting levels of nested build().\n        const summary = lines.slice(0, stepsIdx).join(' ').trim();\n        this._descriptionParts.push(\n          summary\n            ? `${this._stepCounter}. [Sub-Execution: ${name}] — ${summary}`\n            : `${this._stepCounter}. [Sub-Execution: ${name}]`,\n        );\n        for (let i = stepsIdx + 1; i < lines.length; i++) {\n          if (lines[i].trim()) this._descriptionParts.push(`   ${lines[i]}`);\n        }\n      } else {\n        // Free-form (single-block) description — inline it whole, unchanged.\n        this._descriptionParts.push(`${this._stepCounter}. [Sub-Execution: ${name}] — ${subflow.description}`);\n      }\n    } else {\n      this._descriptionParts.push(`${this._stepCounter}. [Sub-Execution: ${name}]`);\n    }\n  }\n\n  // ── Configuration ──\n\n  setLogger(logger: ILogger): this {\n    this._logger = logger;\n    return this;\n  }\n\n  /**\n   * Declare the API contract — input validation, output shape, and output mapper.\n   * Replaces setInputSchema() + setOutputSchema() + setOutputMapper() in a single call.\n   *\n   * If a contract with input schema is declared, chart.run() validates input automatically.\n   * Contract data is used by chart.toOpenAPI() and chart.toMCPTool().\n   */\n  contract(opts: {\n    input?: unknown;\n    output?: unknown;\n    mapper?: (finalScope: Record<string, unknown>) => unknown;\n  }): this {\n    if (opts.input) this._inputSchema = opts.input;\n    if (opts.output) this._outputSchema = opts.output;\n    if (opts.mapper) this._outputMapper = opts.mapper;\n    return this;\n  }\n\n  // ── Linear Chaining ──\n\n  start(\n    name: string,\n    fn: StageFunction<TOut, TScope> | PausableHandler<TScope>,\n    id: string,\n    description?: string,\n    options?: { retry?: RetryPolicy; tags?: readonly string[] },\n  ): this {\n    admitId('stage id', id, 'stage');\n    if (this._root) fail('root already defined; create a new builder');\n\n    // Detect PausableHandler by duck-typing (has .execute property)\n    // eslint-disable-next-line no-restricted-syntax\n    const isPausable = typeof fn === 'object' && fn !== null && 'execute' in fn;\n    const stageFn = isPausable\n      ? ((fn as PausableHandler<TScope>).execute as StageFunction<TOut, TScope>)\n      : (fn as StageFunction<TOut, TScope>);\n\n    const node: StageNode<TOut, TScope> = { name, id, fn: stageFn };\n    if (isPausable) {\n      node.isPausable = true;\n      node.resumeFn = (fn as PausableHandler<TScope>).resume;\n    }\n    if (description) node.description = description;\n    this._addToMap(id, stageFn);\n\n    const spec: SerializedPipelineStructure = { name, id, type: 'stage' };\n    if (isPausable) spec.isPausable = true;\n    if (description) spec.description = description;\n    applyRetryPolicy(node, spec, options?.retry, `start('${id}')`);\n    applyTags(node, spec, options?.tags, `start('${id}')`);\n\n    this._root = node;\n    this._rootSpec = spec;\n    this._cursor = node;\n    this._advanceCursorSpec(spec);\n    this._knownStageIds.add(id);\n\n    // L7.3 — Seed node fires `onStageAdded` (no edge — no predecessor).\n    // `isPausable` is read directly from the spec by `_fireStageAdded`.\n    this._fireStageAdded(spec);\n\n    this._appendDescriptionLine(name, description);\n    return this;\n  }\n\n  /**\n   * Start a chart whose ROOT stage IS a selector — it runs first (reading\n   * args, seeding state, returning the chosen branch ids via `select()`),\n   * and its branches attach directly to the root. Mirrors `start()` for the\n   * root-node setup, then returns a `SelectorFnList` bound to the root so\n   * `.addFunctionBranch()` / `.addSubFlowChartBranch()` / `.end()` work\n   * exactly as they do after `addSelectorFunction()`.\n   *\n   * Use when the first thing a chart does is choose among branches — e.g. a\n   * `Context` selector that inits + picks which context slots to engineer,\n   * with no separate seed stage before it.\n   */\n  startSelector(\n    name: string,\n    fn: StageFunction<any, TScope>,\n    id: string,\n    description?: string,\n    options?: { failFast?: boolean; retry?: RetryPolicy; tags?: readonly string[] },\n  ): SelectorFnList<TOut, TScope> {\n    admitId('stage id', id, 'stage');\n    if (this._root) fail('root already defined; create a new builder');\n\n    const node: StageNode<TOut, TScope> = { name, id, fn: fn as StageFunction<TOut, TScope> };\n    if (description) node.description = description;\n    // See `addSelectorFunction` — `failFast: true` makes a multi-branch\n    // selection fan out via `Promise.all` (first error aborts) instead of the\n    // default `Promise.allSettled` (best-effort).\n    if (options?.failFast) node.failFast = true;\n    this._addToMap(id, fn as StageFunction<TOut, TScope>);\n\n    const spec: SerializedPipelineStructure = { name, id, type: 'stage', hasSelector: true };\n    if (description) spec.description = description;\n    applyRetryPolicy(node, spec, options?.retry, `startSelector('${id}')`);\n    applyTags(node, spec, options?.tags, `startSelector('${id}')`);\n\n    this._root = node;\n    this._rootSpec = spec;\n    this._cursor = node;\n    this._advanceCursorSpec(spec);\n    this._knownStageIds.add(id);\n\n    // Root selector node fires onStageAdded with NO predecessor edge (it's\n    // the root). Branches + onDeciderComplete come from the SelectorFnList.\n    this._fireStageAdded(spec);\n\n    this._stepCounter++;\n    this._stageStepMap.set(name, this._stepCounter);\n    this._appendDescriptionLine(name, description);\n\n    return new SelectorFnList<TOut, TScope>(\n      this,\n      node,\n      spec,\n      this._descriptionParts,\n      this._stageDescriptions,\n      this._stepCounter,\n      description,\n    );\n  }\n\n  addFunction(name: string, fn: StageFunction<TOut, TScope>, id: string, description?: string): this {\n    admitId('stage id', id, 'stage');\n    const cur = this._needCursor();\n    const curSpec = this._needCursorSpec();\n    // Capture the parent SPEC reference (not just id) BEFORE the\n    // cursor advances — we need its `children` + `type` to decide\n    // whether the `next` edge is a fork convergence (N edges from\n    // each branch child) vs a plain linear chain (1 edge from parent).\n    const parentSpec = curSpec;\n\n    const node: StageNode<TOut, TScope> = { name, id, fn };\n    if (description) node.description = description;\n    this._addToMap(id, fn);\n\n    const spec: SerializedPipelineStructure = { name, id, type: 'stage' };\n    if (description) spec.description = description;\n\n    cur.next = node;\n    curSpec.next = spec;\n    this._cursor = node;\n    this._advanceCursorSpec(spec);\n    this._knownStageIds.add(id);\n\n    // L7.3 — Linear node: announce the node first, then the edge\n    // from the prior cursor. Order matters: endpoints announced\n    // before any edge referencing them (StructureRecorder contract).\n    this._fireStageAdded(spec);\n    this._fireNextEdgeFromParent(parentSpec, id);\n\n    this._appendDescriptionLine(name, description);\n    return this;\n  }\n\n  addStreamingFunction(\n    name: string,\n    fn: StageFunction<TOut, TScope>,\n    id: string,\n    streamId?: string,\n    description?: string,\n  ): this {\n    admitId('stage id', id, 'stage');\n    const cur = this._needCursor();\n    const curSpec = this._needCursorSpec();\n    const parentSpec = curSpec;\n\n    const node: StageNode<TOut, TScope> = {\n      name,\n      id,\n      fn,\n      isStreaming: true,\n      streamId: streamId ?? name,\n    };\n    if (description) node.description = description;\n    this._addToMap(id, fn);\n\n    const spec: SerializedPipelineStructure = {\n      name,\n      id,\n      type: 'streaming',\n      isStreaming: true,\n      streamId: streamId ?? name,\n    };\n    if (description) spec.description = description;\n\n    cur.next = node;\n    curSpec.next = spec;\n    this._cursor = node;\n    this._advanceCursorSpec(spec);\n    this._knownStageIds.add(id);\n\n    // L7.3 — Streaming stage: same shape as linear addFunction.\n    this._fireStageAdded(spec);\n    this._fireNextEdgeFromParent(parentSpec, id);\n\n    this._appendDescriptionLine(name, description);\n    return this;\n  }\n\n  /**\n   * Add a pausable stage — can pause execution and resume later with input.\n   *\n   * The handler has two phases:\n   * - `execute`: runs first time. Return any non-void value to pause (it becomes\n   *   the checkpoint's `pauseData`); return void/undefined to continue normally.\n   * - `resume`: runs when the flowchart is resumed with input.\n   *\n   * @example\n   * ```typescript\n   * .addPausableFunction('ApproveOrder', {\n   *   execute: async (scope) => {\n   *     scope.orderId = '123';\n   *     return { question: 'Approve?' };\n   *   },\n   *   resume: async (scope, input) => {\n   *     scope.approved = input.approved;\n   *   },\n   * }, 'approve-order', 'Manager approval gate')\n   * ```\n   */\n  addPausableFunction(name: string, handler: PausableHandler<TScope>, id: string, description?: string): this {\n    admitId('stage id', id, 'stage');\n    const cur = this._needCursor();\n    const curSpec = this._needCursorSpec();\n    const parentSpec = curSpec;\n\n    const node: StageNode<TOut, TScope> = {\n      name,\n      id,\n      fn: handler.execute as StageFunction<TOut, TScope>,\n      isPausable: true,\n      resumeFn: handler.resume,\n    };\n    if (description) node.description = description;\n    this._addToMap(id, handler.execute as StageFunction<TOut, TScope>);\n\n    const spec: SerializedPipelineStructure = {\n      name,\n      id,\n      type: 'stage',\n      isPausable: true,\n    };\n    if (description) spec.description = description;\n\n    cur.next = node;\n    curSpec.next = spec;\n    this._cursor = node;\n    this._advanceCursorSpec(spec);\n    this._knownStageIds.add(id);\n\n    // L7.3 — Pausable stage: `_fireStageAdded` reads `isPausable`\n    // directly from `spec.isPausable` (set above), so visualisers\n    // see it on the event payload without a separate threading arg.\n    this._fireStageAdded(spec);\n    this._fireNextEdgeFromParent(parentSpec, id);\n\n    this._appendDescriptionLine(name, description);\n    return this;\n  }\n\n  // ── Detach (builder-native composition) ──\n  //\n  // Sugar over `addFunction` that generates a stage which calls\n  // `scope.$detachAndForget(...)` or `scope.$detachAndJoinLater(...)`\n  // at runtime. ZERO engine changes — pure composition over the\n  // existing scope-method primitives.\n  //\n  // For `addDetachAndJoinLater`, the returned handle is stored in\n  // shared state via `$setValue` (which bypasses the typed-proxy\n  // unwrap that would otherwise strip the handle's class methods).\n  // Downstream stages read it via `scope[options.handleKey]` or\n  // `scope.$getValue(options.handleKey)` — both preserve methods\n  // because the value was stored raw.\n\n  /**\n   * Add a stage that fires a child flowchart on the given driver and\n   * DISCARDS the handle. Pure fire-and-forget — useful for telemetry\n   * exports, audit log shipping, cache warm-up.\n   *\n   * @param id Stable id for this stage (also the stageMap key).\n   * @param child The child flowchart to detach.\n   * @param options.driver The driver to schedule on (e.g. `microtaskBatchDriver`).\n   * @param options.inputMapper Maps the parent's scope to the child's input.\n   *   Defaults to passing `undefined`.\n   * @param options.mountName Display name; defaults to `id`.\n   * @param options.description Stage description for narrative + tools.\n   *\n   * @example\n   * ```ts\n   * import { microtaskBatchDriver } from 'footprintjs/detach';\n   *\n   * flowChart('process', processFn, 'process')\n   *   .addDetachAndForget('telemetry', telemetryChart, {\n   *     driver: microtaskBatchDriver,\n   *     inputMapper: (scope) => ({ event: 'processed', orderId: scope.orderId }),\n   *   })\n   *   .addFunction('next', nextFn, 'next')\n   *   .build();\n   * ```\n   */\n  addDetachAndForget(\n    id: string,\n    child: import('./types.js').FlowChart<any, any>,\n    options: {\n      driver: import('../detach/types.js').DetachDriver;\n      inputMapper?: (scope: TScope) => unknown;\n      mountName?: string;\n      description?: string;\n    },\n  ): this {\n    const name = options.mountName ?? id;\n    return this.addFunction(\n      name,\n      ((scope: any) => {\n        const input = options.inputMapper ? options.inputMapper(scope as TScope) : undefined;\n        scope.$detachAndForget(options.driver, child, input);\n      }) as StageFunction<TOut, TScope>,\n      id,\n      options.description,\n    );\n  }\n\n  /**\n   * Add a stage that fires a child flowchart on the given driver and\n   * delivers the resulting `DetachHandle` to a consumer-supplied\n   * `onHandle` callback. The handle CANNOT be stored in shared state\n   * — `StageContext.setValue` calls `structuredClone` which drops\n   * class prototypes (and therefore the handle's `.wait()` method).\n   *\n   * The callback pattern is the explicit alternative: keep handles in\n   * a closure-local array (or whatever shape suits) and have a\n   * downstream stage `await Promise.all(...)` over them.\n   *\n   * @example\n   * ```ts\n   * import { microtaskBatchDriver } from 'footprintjs/detach';\n   * import type { DetachHandle } from 'footprintjs/detach';\n   *\n   * const handles: DetachHandle[] = [];\n   *\n   * const chart = flowChart('seed', seedFn, 'seed')\n   *   .addDetachAndJoinLater('eval-a', evalChart, {\n   *     driver: microtaskBatchDriver,\n   *     inputMapper: (scope) => scope.configA,\n   *     onHandle: (h) => handles.push(h),\n   *   })\n   *   .addDetachAndJoinLater('eval-b', evalChart, {\n   *     driver: microtaskBatchDriver,\n   *     inputMapper: (scope) => scope.configB,\n   *     onHandle: (h) => handles.push(h),\n   *   })\n   *   .addFunction('join', async (scope) => {\n   *     const settled = await Promise.all(handles.map((h) => h.wait()));\n   *     scope.results = settled;\n   *   }, 'join')\n   *   .build();\n   * ```\n   *\n   * Note: putting `handles` in a module-level closure is fine for\n   * single-run scripts. For server code that runs the same chart\n   * concurrently across requests, allocate a new closure per run\n   * (e.g., wrap chart construction in a factory function) so handles\n   * from different runs don't bleed into each other.\n   */\n  addDetachAndJoinLater(\n    id: string,\n    child: import('./types.js').FlowChart<any, any>,\n    options: {\n      driver: import('../detach/types.js').DetachDriver;\n      onHandle: (handle: import('../detach/types.js').DetachHandle) => void;\n      inputMapper?: (scope: TScope) => unknown;\n      mountName?: string;\n      description?: string;\n    },\n  ): this {\n    const name = options.mountName ?? id;\n    return this.addFunction(\n      name,\n      ((scope: any) => {\n        const input = options.inputMapper ? options.inputMapper(scope as TScope) : undefined;\n        const handle = scope.$detachAndJoinLater(options.driver, child, input);\n        options.onHandle(handle);\n      }) as StageFunction<TOut, TScope>,\n      id,\n      options.description,\n    );\n  }\n\n  // ── Branching ──\n\n  addDeciderFunction(\n    name: string,\n    fn: StageFunction<any, TScope>,\n    id: string,\n    description?: string,\n    /** `{ retry }` gives the DECIDER STAGE a retry policy. Declared here rather\n     *  than via `.retry()` because this method returns a `DeciderList`, where a\n     *  chained modifier could mean the decider OR the branch just added;\n     *  `{ tags }` likewise. */\n    options?: { retry?: RetryPolicy; tags?: readonly string[] },\n  ): DeciderList<TOut, TScope> {\n    admitId('stage id', id, 'stage');\n    const cur = this._needCursor();\n    const curSpec = this._needCursorSpec();\n    const parentSpec = curSpec;\n\n    // No dispatcher guard on `cur`: after `.end()` the cursor IS the closed\n    // decider/selector, and this decider is a NEW node at its `next` (a chain\n    // of dispatchers). Re-opening the SAME dispatcher is `BranchCursor · assertOpen`'s refusal.\n    const node: StageNode<TOut, TScope> = { name, id, fn };\n    if (description) node.description = description;\n    this._addToMap(id, fn);\n\n    const spec: SerializedPipelineStructure = { name, id, type: 'stage', hasDecider: true };\n    if (description) spec.description = description;\n    applyRetryPolicy(node, spec, options?.retry, `addDeciderFunction('${id}')`);\n    applyTags(node, spec, options?.tags, `addDeciderFunction('${id}')`);\n\n    cur.next = node;\n    curSpec.next = spec;\n    this._cursor = node;\n    this._advanceCursorSpec(spec);\n    this._knownStageIds.add(id);\n\n    // L7.3 — Decider node is reached via a `next` edge from the prior\n    // cursor. Branches themselves fire via `addFunctionBranch` etc.\n    // `onDeciderComplete` fires from sub-builder `.end()`.\n    this._fireStageAdded(spec);\n    this._fireNextEdgeFromParent(parentSpec, id);\n\n    this._stepCounter++;\n    this._stageStepMap.set(name, this._stepCounter);\n\n    return new DeciderList<TOut, TScope>(\n      this,\n      node,\n      spec,\n      this._descriptionParts,\n      this._stageDescriptions,\n      this._stepCounter,\n      description,\n    );\n  }\n\n  addSelectorFunction(\n    name: string,\n    fn: StageFunction<any, TScope>,\n    id: string,\n    description?: string,\n    /** `{ retry }` gives the SELECTOR STAGE a retry policy — same reasoning as\n     *  `addDeciderFunction`: this method returns a sub-builder, so a chained\n     *  `.retry()` would be ambiguous; `{ tags }` likewise. */\n    options?: { failFast?: boolean; retry?: RetryPolicy; tags?: readonly string[] },\n  ): SelectorFnList<TOut, TScope> {\n    admitId('stage id', id, 'stage');\n    const cur = this._needCursor();\n    const curSpec = this._needCursorSpec();\n    const parentSpec = curSpec;\n\n    // No dispatcher guard on `cur` — see `addDeciderFunction`.\n    const node: StageNode<TOut, TScope> = { name, id, fn };\n    if (description) node.description = description;\n    // `failFast`: when the selector picks ≥2 branches they fan out in parallel\n    // via ChildrenExecutor. Default = `Promise.allSettled` (best-effort: every\n    // branch runs to completion even if some fail). `failFast: true` = `Promise.all`\n    // (the first branch error rejects + aborts) — use when ALL selected branches\n    // are REQUIRED (e.g. assembling a request from independent-but-required parts),\n    // not best-effort fan-out. Same flag `addListOfFunction` exposes.\n    if (options?.failFast) node.failFast = true;\n    this._addToMap(id, fn);\n\n    const spec: SerializedPipelineStructure = { name, id, type: 'stage', hasSelector: true };\n    if (description) spec.description = description;\n    applyRetryPolicy(node, spec, options?.retry, `addSelectorFunction('${id}')`);\n    applyTags(node, spec, options?.tags, `addSelectorFunction('${id}')`);\n\n    cur.next = node;\n    curSpec.next = spec;\n    this._cursor = node;\n    this._advanceCursorSpec(spec);\n    this._knownStageIds.add(id);\n\n    // L7.3 — Selector node: same as decider. Branches + complete event\n    // come from the SelectorFnList sub-builder.\n    this._fireStageAdded(spec);\n    this._fireNextEdgeFromParent(parentSpec, id);\n\n    this._stepCounter++;\n    this._stageStepMap.set(name, this._stepCounter);\n\n    return new SelectorFnList<TOut, TScope>(\n      this,\n      node,\n      spec,\n      this._descriptionParts,\n      this._stageDescriptions,\n      this._stepCounter,\n      description,\n    );\n  }\n\n  // ── Parallel (Fork) ──\n\n  addListOfFunction(children: SimplifiedParallelSpec<TOut, TScope>[], options?: { failFast?: boolean }): this {\n    const { cur, curSpec } = this._needForkParent();\n    const forkId = cur.id;\n\n    curSpec.type = 'fork';\n    if (options?.failFast) cur.failFast = true;\n\n    for (const { id, name, fn, retry, tags } of children) {\n      if (!id) fail(`child id required under '${cur.name}'`);\n      admitId('fork child id', id, 'stage');\n      if (cur.children?.some((c) => c.id === id)) {\n        fail(`duplicate child id '${id}' under '${cur.name}'`);\n      }\n\n      const node: StageNode<TOut, TScope> = { name: name ?? id, id };\n      if (fn) {\n        node.fn = fn;\n      }\n      this._registerStage(id, fn);\n\n      const spec: SerializedPipelineStructure = {\n        name: name ?? id,\n        id,\n        type: 'stage',\n        isParallelChild: true,\n        parallelGroupId: forkId,\n      };\n      applyRetryPolicy(node, spec, retry, `addListOfFunction child '${id}'`);\n      applyTags(node, spec, tags, `addListOfFunction child '${id}'`);\n\n      cur.children = cur.children || [];\n      cur.children.push(node);\n      curSpec.children = curSpec.children || [];\n      curSpec.children.push(spec);\n      // L7.3 — fire structure events for the child + the fork edge.\n      this._fireStageAdded(spec);\n      this._fireEdgeAdded(curSpec.id, spec.id, 'fork-branch');\n    }\n\n    const childNames = children.map((c) => c.name || c.id).join(', ');\n    this._stepCounter++;\n    this._descriptionParts.push(`${this._stepCounter}. Runs in parallel: ${childNames}`);\n\n    this._cursorTail = `the parallel children (${childNames})`;\n    return this;\n  }\n\n  /**\n   * Run ONE BRANCH PER ITEM, in parallel — with the number of branches decided\n   * at RUN time from the payload rather than at build time.\n   *\n   * `addListOfFunction` fans out a fixed set of branches you name in the chart.\n   * This fans out over data the chart has not seen yet: three chunks make three\n   * branches, ten make ten. Each branch runs as its own isolated subflow — its\n   * own memory, its own commit log, addressable in every trace query at\n   * `<stageId>~<index>` — so branches cannot corrupt each other's in-flight\n   * state, and a backward slice through a branch result works with no special\n   * handling. Design: docs/design/execution-control.md.\n   *\n   * @param name   Display label for the fan-out stage.\n   * @param id     Stable stage id. May not contain `~` (reserved — the branch\n   *               segments are built from this id).\n   * @param config `{ items, branch, maxBranches, into, failFast? }`:\n   *   - `items(scope)` picks what to fan out over (reads are tracked);\n   *   - `branch(item, index)` builds the chart for ONE item (each branch's\n   *     scope is also seeded with `item` and `index`, so the input is in the\n   *     trace rather than hidden in a closure);\n   *   - `maxBranches` is REQUIRED — an unbounded fan-out driven by model output\n   *     is a resource attack, so there is no default to forget. Extra items do\n   *     not run and the truncation is recorded;\n   *   - `into` is REQUIRED — the state key the ordered results array is written\n   *     to. `into[i]` is branch `i`'s result, in ITEMS order, whatever order\n   *     the branches finished in;\n   *   - `failFast` is the same policy the rest of the library's parallelism\n   *     uses: `true` rejects on the first failing branch, omitted runs them all\n   *     best-effort (a failed branch's slot is `undefined`).\n   *\n   * @example\n   * ```ts\n   * flowChart<State>('Split', splitFn, 'split')\n   *   .addParallelForEach('Review each chunk', 'review-chunks', {\n   *     items: (scope) => scope.chunks,\n   *     branch: (chunk, i) => buildReviewChart(chunk, i),\n   *     maxBranches: 8,\n   *     into: 'reviews',\n   *   })\n   *   .addFunction('Merge', mergeFn, 'merge')   // reads scope.reviews\n   *   .build();\n   * ```\n   */\n  addParallelForEach<TItem = any>(\n    name: string,\n    id: string,\n    config: ParallelForEachConfig<TItem, TScope>,\n    description?: string,\n  ): this {\n    const cur = this._needCursor();\n    const curSpec = this._needCursorSpec();\n    const parentSpec = curSpec;\n\n    // The generated branch segments embed this id verbatim\n    // (`<id>~<index>`), so a marker inside it would make the segment\n    // ambiguous to parse. Refusing it here — on a brand-new method, at zero\n    // back-compat cost — kills the ambiguity class outright and keeps\n    // `parseBranchSegment` a split at the last marker instead of a heuristic.\n    admitId('parallelForEach stage id', id, 'segment');\n    this._claimFreshId(id, `addParallelForEach('${id}')`);\n    if (!config || typeof config.items !== 'function' || typeof config.branch !== 'function') {\n      fail(`addParallelForEach('${id}') requires items(scope) and branch(item, index) functions.`);\n    }\n    // REQUIRED, both of them — see docs/design/execution-control.md (D2).\n    if (typeof config.maxBranches !== 'number' || !Number.isInteger(config.maxBranches) || config.maxBranches < 1) {\n      fail(\n        `addParallelForEach('${id}') requires maxBranches — a positive integer ceiling on how many ` +\n          'branches one execution may start. There is deliberately no default: an unbounded fan-out ' +\n          'driven by runtime data (model output, an upstream API) is a resource attack. Pick the ' +\n          'largest number this flow can afford. See docs/design/execution-control.md.',\n      );\n    }\n    if (typeof config.into !== 'string' || config.into === '') {\n      fail(\n        `addParallelForEach('${id}') requires into — the state key its ordered results array is ` +\n          'written to. There is deliberately no default derived from the stage id: a derived key ' +\n          'could silently overwrite state the chart already owns. See docs/design/execution-control.md.',\n      );\n    }\n\n    const node: StageNode<TOut, TScope> = {\n      name,\n      id,\n      isDynamicParallel: true,\n      parallelForEach: config as ParallelForEachConfig<any, TScope>,\n    };\n    if (description) node.description = description;\n    if (config.failFast !== undefined) node.failFast = config.failFast;\n\n    // `type: 'fork'` — a fan-out is what this is, and every existing consumer\n    // already knows how to draw one. The \"branches are decided at runtime\"\n    // detail rides `isDynamicParallel` rather than a new node type, so nothing\n    // downstream has to learn a new word to keep working.\n    const spec: SerializedPipelineStructure = { name, id, type: 'fork', isDynamicParallel: true };\n    if (description) spec.description = description;\n\n    cur.next = node;\n    curSpec.next = spec;\n    this._cursor = node;\n    this._advanceCursorSpec(spec);\n    this._knownStageIds.add(id);\n\n    this._fireStageAdded(spec);\n    this._fireNextEdgeFromParent(parentSpec, id);\n\n    this._appendDescriptionLine(name, description ?? `Runs one branch per item into '${config.into}'`);\n    return this;\n  }\n\n  // ── Subflow Mounting ──\n\n  addSubFlowChart(id: string, subflow: FlowChart<any, any>, mountName?: string, options?: SubflowMountOptions): this {\n    const { cur, curSpec } = this._needForkParent();\n\n    if (cur.children?.some((c) => c.id === id)) {\n      fail(`duplicate child id '${id}' under '${cur.name}'`);\n    }\n    assertSubflowIdAllowed(id);\n\n    const subflowName = mountName || id;\n    const forkId = cur.id;\n    this._mountSubflow(id, subflow, () => {\n      const node: StageNode<TOut, TScope> = {\n        name: subflowName,\n        id,\n        isSubflowRoot: true,\n        subflowId: id,\n        subflowName,\n      };\n      if (options) node.subflowMountOptions = options;\n\n      const spec: SerializedPipelineStructure = {\n        name: subflowName,\n        type: 'stage',\n        id,\n        isSubflowRoot: true,\n        subflowId: id,\n        subflowName,\n        isParallelChild: true,\n        parallelGroupId: forkId,\n        subflowStructure: subflow.buildTimeStructure,\n      };\n\n      // The mount's ONLY tag site: the cursor stays on the parent (see\n      // `_cursorTail`), so `.tag()` after this call refuses.\n      applyTags(node, spec, options?.tags, `addSubFlowChart('${id}')`);\n\n      curSpec.type = 'fork';\n      cur.children = cur.children || [];\n      cur.children.push(node);\n      curSpec.children = curSpec.children || [];\n      curSpec.children.push(spec);\n      this._knownStageIds.add(id);\n      // L7.3 — Subflow mount: stage event + fork edge + mount lifecycle\n      // event. Mount-only semantics: parent recorders do NOT replay the\n      // subflow's own internal structure events.\n      this._fireStageAdded(spec);\n      this._fireEdgeAdded(curSpec.id, id, 'fork-branch');\n      this._fireSubflowMounted(id, subflowName, id, false, subflow.buildTimeStructure);\n    });\n    this._appendSubflowDescription(id, subflowName, subflow);\n\n    this._cursorTail = `the subflow mount '${subflowName}'`;\n    return this;\n  }\n\n  addLazySubFlowChart(\n    id: string,\n    resolver: () => FlowChart<TOut, TScope>,\n    mountName?: string,\n    options?: SubflowMountOptions,\n  ): this {\n    const { cur, curSpec } = this._needForkParent();\n\n    if (cur.children?.some((c) => c.id === id)) {\n      fail(`duplicate child id '${id}' under '${cur.name}'`);\n    }\n    assertSubflowIdAllowed(id);\n    this._claimFreshId(id, `addLazySubFlowChart('${id}')`);\n\n    const subflowName = mountName || id;\n    const forkId = cur.id;\n\n    const node: StageNode<TOut, TScope> = {\n      name: subflowName,\n      id,\n      isSubflowRoot: true,\n      subflowId: id,\n      subflowName,\n      subflowResolver: resolver as any,\n    };\n    if (options) node.subflowMountOptions = options;\n\n    // Lazy mount stub. The lazy subflow's internals will be shaped at\n    // resolution time.\n    const spec: SerializedPipelineStructure = {\n      name: subflowName,\n      type: 'stage',\n      id,\n      isSubflowRoot: true,\n      subflowId: id,\n      subflowName,\n      isParallelChild: true,\n      parallelGroupId: forkId,\n      isLazy: true,\n    };\n\n    applyTags(node, spec, options?.tags, `addLazySubFlowChart('${id}')`);\n\n    curSpec.type = 'fork';\n    cur.children = cur.children || [];\n    cur.children.push(node);\n    curSpec.children = curSpec.children || [];\n    curSpec.children.push(spec);\n    // L7.3 — Lazy subflow parallel mount.\n    this._fireStageAdded(spec);\n    this._fireEdgeAdded(curSpec.id, id, 'fork-branch');\n    this._fireSubflowMounted(id, subflowName, id, true);\n\n    this._stepCounter++;\n    this._stageStepMap.set(id, this._stepCounter);\n    this._descriptionParts.push(`${this._stepCounter}. [Lazy Sub-Execution: ${subflowName}]`);\n\n    this._cursorTail = `the lazy subflow mount '${subflowName}'`;\n    return this;\n  }\n\n  addLazySubFlowChartNext(\n    id: string,\n    resolver: () => FlowChart<TOut, TScope>,\n    mountName?: string,\n    options?: SubflowMountOptions,\n  ): this {\n    const cur = this._needCursor();\n    const curSpec = this._needCursorSpec();\n\n    if (cur.next) {\n      fail(`cannot add subflow as next when next is already defined at '${cur.name}'`);\n    }\n    assertSubflowIdAllowed(id);\n    this._claimFreshId(id, `addLazySubFlowChartNext('${id}')`);\n\n    const subflowName = mountName || id;\n\n    const node: StageNode<TOut, TScope> = {\n      name: subflowName,\n      id,\n      isSubflowRoot: true,\n      subflowId: id,\n      subflowName,\n      subflowResolver: resolver as any,\n    };\n    if (options) node.subflowMountOptions = options;\n\n    // Lazy mount stub. The lazy subflow's internals will be shaped at\n    // resolution time.\n    const spec: SerializedPipelineStructure = {\n      name: subflowName,\n      type: 'stage',\n      id,\n      isSubflowRoot: true,\n      subflowId: id,\n      subflowName,\n      isLazy: true,\n    };\n\n    applyTags(node, spec, options?.tags, `addLazySubFlowChartNext('${id}')`);\n\n    const parentSpec = curSpec;\n    cur.next = node;\n    curSpec.next = spec;\n    this._cursor = node;\n    this._advanceCursorSpec(spec);\n    // L7.3 — Lazy linear-mount subflow.\n    this._fireStageAdded(spec);\n    this._fireNextEdgeFromParent(parentSpec, id);\n    this._fireSubflowMounted(id, subflowName, id, true);\n\n    this._stepCounter++;\n    this._stageStepMap.set(id, this._stepCounter);\n    this._descriptionParts.push(`${this._stepCounter}. [Lazy Sub-Execution: ${subflowName}]`);\n\n    return this;\n  }\n\n  addSubFlowChartNext(\n    id: string,\n    subflow: FlowChart<any, any>,\n    mountName?: string,\n    options?: SubflowMountOptions,\n  ): this {\n    const cur = this._needCursor();\n    const curSpec = this._needCursorSpec();\n\n    if (cur.next) {\n      fail(`cannot add subflow as next when next is already defined at '${cur.name}'`);\n    }\n    assertSubflowIdAllowed(id);\n\n    const subflowName = mountName || id;\n    this._mountSubflow(id, subflow, () => {\n      const node: StageNode<TOut, TScope> = {\n        name: subflowName,\n        id,\n        isSubflowRoot: true,\n        subflowId: id,\n        subflowName,\n      };\n      if (options) node.subflowMountOptions = options;\n\n      const attachedSpec: SerializedPipelineStructure = {\n        name: subflowName,\n        type: 'stage',\n        id,\n        isSubflowRoot: true,\n        subflowId: id,\n        subflowName,\n        subflowStructure: subflow.buildTimeStructure,\n      };\n\n      // A linear mount moves the cursor, so `.tag()` after it also works —\n      // `applyTags` refuses a second declaration if both sites are used.\n      applyTags(node, attachedSpec, options?.tags, `addSubFlowChartNext('${id}')`);\n\n      const parentSpec = curSpec;\n      cur.next = node;\n      curSpec.next = attachedSpec;\n      this._cursor = node;\n      this._advanceCursorSpec(attachedSpec);\n      this._knownStageIds.add(id);\n      // L7.3 — Linear-mount subflow.\n      this._fireStageAdded(attachedSpec);\n      this._fireNextEdgeFromParent(parentSpec, id);\n      this._fireSubflowMounted(id, subflowName, id, false, subflow.buildTimeStructure);\n    });\n    this._appendSubflowDescription(id, subflowName, subflow);\n\n    return this;\n  }\n\n  // ── Retry ──\n\n  /**\n   * Give the stage you JUST added a declarative retry policy.\n   *\n   * ## Why declare it instead of writing a loop inside the stage\n   *\n   * A retry hand-rolled inside a stage function is invisible to the trace. The\n   * narrative shows one stage, the commit log shows one entry, and the two\n   * failed calls that came before the successful one left no mark anywhere —\n   * an unexplained behaviour in a library whose whole point is that nothing\n   * invisible happens. Declared here, every attempt is part of the record: each\n   * failed attempt fires `FlowRecorder.onStageRetry` and appears in the\n   * narrative, in order, between the attempts' own reads and writes.\n   *\n   * ## What an attempt is\n   *\n   * A failed attempt's staged writes are DISCARDED — the next attempt starts\n   * from committed state, never from the wreckage of the last try. The final\n   * attempt behaves exactly as a stage with no policy does: on success it\n   * commits; on failure it commits what it wrote and rethrows (footprint has\n   * never had rollback, and retry does not introduce one).\n   *\n   * A pause is not a failure: neither `addPausableFunction`'s pause nor\n   * `interrupt()` is ever retried. Nor is a cancelled run.\n   *\n   * @example\n   * ```ts\n   * flowChart<State>('Fetch user', fetchFn, 'fetch-user')\n   *   .addFunction('Charge card', chargeFn, 'charge')\n   *   .retry({ attempts: 3, backoffMs: (n) => 100 * 2 ** (n - 1) })\n   *   .addFunction('Confirm', confirmFn, 'confirm')\n   * ```\n   *\n   * Applies to the CURRENT cursor — the stage added by the immediately\n   * preceding `start()` / `addFunction()` / `addStreamingFunction()` /\n   * `addPausableFunction()`. Where the cursor would be ambiguous (a decider,\n   * selector, branch, or fork child), declare the policy in that method's own\n   * `retry` option instead.\n   */\n  retry(policy: RetryPolicy): this {\n    const cur = this._needCursor();\n    const curSpec = this._needCursorSpec();\n\n    // A subflow mount / parallel fork hangs CHILDREN off the current stage and\n    // leaves the cursor on that stage. Attaching the policy to the cursor here\n    // would silently retry the stage BEFORE the thing you just wrote.\n    if (this._cursorTail) {\n      fail(\n        `retry() cannot follow ${this._cursorTail} — that attaches to '${cur.name}' without moving the cursor, so ` +\n          `the policy would land on '${cur.name}' rather than on what you just added. Declare the policy at its own ` +\n          'site instead: on the stages INSIDE a subflow chart, or via the `retry` field on an addListOfFunction child.',\n      );\n    }\n    if (cur.retry) fail(`retry already defined at '${cur.name}'`);\n    if (cur.isSubflowRoot) {\n      fail(\n        `retry() cannot be applied to the subflow mount '${cur.name}' — a mount has no stage function of its own. ` +\n          'Declare the policy on the stages INSIDE the subflow chart instead.',\n      );\n    }\n    if (cur.isDynamicParallel) {\n      fail(\n        `retry() cannot be applied to the parallel-for-each stage '${cur.name}' — it has no stage function of its ` +\n          'own. Declare the policy on the stages inside the branch chart its `branch` factory returns.',\n      );\n    }\n    if (cur.isLoopRef) fail(`retry() cannot be applied to the loop reference '${cur.name}'`);\n\n    applyRetryPolicy(cur, curSpec, policy, `retry() at '${cur.name}'`);\n    return this;\n  }\n\n  // ── Declared tags ──\n\n  /**\n   * Put NAMES on the stage you JUST added. The first commit bundle of each\n   * execution of that stage carries them (`CommitBundle.tags` — the bundle\n   * `commitStops` keys on), and the built spec advertises them\n   * (`SerializedPipelineStructure.tags`).\n   *\n   * ## Why declare it instead of deriving it from ids\n   *\n   * A reader that wants \"the LLM turns\" of a stored recording had to classify\n   * stages from their ids — a switch over `runtimeStageId` that parses `#` and\n   * `/`, lives in the consumer, and silently goes stale when a stage is\n   * renamed. Declared here, the name travels WITH the commit: a recording from\n   * any chart carries its own milestones, and `tagStops` (foottrace)\n   * scrubs them with no id conventions at all.\n   *\n   * ## What a tag is, and is not\n   *\n   * A tag is a NAME declared at build time — never a value. There is no\n   * run-time `$tag()`: a runtime string could carry data (`'user:' + email`)\n   * past every redaction point. Data-dependent marks are a keep rule over\n   * the fold at read time, or telemetry via `$emit`. Free strings: footprintjs\n   * owns no vocabulary; a consumer declares its own (`'milestone:<kind>'`).\n   *\n   * Stamped ONCE per execution of the stage: retry attempts share one stamp,\n   * a failed stage keeps its tag (the error path commits before it rethrows),\n   * a stage that `interrupt()`s and is resumed is two tagged stops on a chain\n   * because it ran twice, and an EMPTY commit is a tagged stop too. A subflow\n   * mount or a parallel-for-each stage can be tagged; the tag lands on the\n   * bundle that records its result — for a mount, its FIRST bundle in the\n   * parent log (the exit bundle carries none), while the subflow's own log\n   * is untouched: its inner stages declare their own.\n   *\n   * @example\n   * ```ts\n   * flowChart<State>('Seed', seedFn, 'seed')\n   *   .addFunction('Call model', callFn, 'call-llm')\n   *   .tag('milestone:llm-turn')\n   *   .addFunction('Route', routeFn, 'route')\n   *   .tag('milestone:decision', 'audit')\n   * ```\n   *\n   * Applies to the CURRENT cursor — the stage added by the immediately\n   * preceding `start()` / `addFunction()` / `addStreamingFunction()` /\n   * `addPausableFunction()` / `addSubFlowChartNext()` / `addParallelForEach()`.\n   * Where the cursor would be ambiguous (a decider, selector, branch, or fork\n   * child), declare the tags in that method's own `tags` option instead. A\n   * subflow MOUNT has that option too (`SubflowMountOptions.tags`, 9.21.1)\n   * — and for a fork-child mount (`addSubFlowChart`) or a branch mount\n   * (`addSubFlowChartBranch`) it is the ONLY site: those leave the cursor on\n   * the parent, so `.tag()` after them refuses rather than mis-attribute.\n   *\n   * Refused at build time: an empty name, a non-string, the reserved\n   * branch-segment marker `~` inside a name, a name declared twice, and a\n   * second declaration on the same stage.\n   */\n  tag(...names: readonly string[]): this {\n    const cur = this._needCursor();\n    const curSpec = this._needCursorSpec();\n\n    // Same mis-attribution guard as `.retry()`: after a mount or a fork the\n    // cursor still points at the stage BEFORE what you just wrote.\n    if (this._cursorTail) {\n      fail(\n        `tag() cannot follow ${this._cursorTail} — that attaches to '${cur.name}' without moving the cursor, so ` +\n          `the names would land on '${cur.name}' rather than on what you just added. Declare the tags at their own ` +\n          \"site instead: via the `tags` field in the mount's own options (`SubflowMountOptions.tags`, 9.21.1), or \" +\n          'via the `tags` field on an addListOfFunction child. The stages INSIDE a subflow chart declare their own.',\n      );\n    }\n    if (cur.isLoopRef) fail(`tag() cannot be applied to the loop reference '${cur.name}'`);\n    if (names.length === 0) fail(`tag() at '${cur.name}': at least one name is required`);\n\n    applyTags(cur, curSpec, names, `tag() at '${cur.name}'`);\n    // The stage's `onStageAdded` has already fired (the door comes after\n    // the add), so the names go out as their own event — a recorder that\n    // copied fields at add time would otherwise never see them (9.24.0).\n    this._fireStageTagged(curSpec);\n    return this;\n  }\n\n  // ── Loop ──\n\n  loopTo(stageId: string): this {\n    const cur = this._needCursor();\n    const curSpec = this._needCursorSpec();\n\n    if (curSpec.loopTarget) fail(`loopTo already defined at '${cur.name}'`);\n    if (cur.next) fail(`cannot set loopTo when next is already defined at '${cur.name}'`);\n\n    if (!this._knownStageIds.has(stageId)) {\n      fail(`loopTo('${stageId}') target not found — did you pass a stage name instead of id?`);\n    }\n\n    cur.next = { name: stageId, id: stageId, isLoopRef: true };\n    curSpec.loopTarget = stageId;\n    curSpec.next = { name: stageId, id: stageId, type: 'loop', isLoopReference: true };\n\n    const targetStep = this._stageStepMap.get(stageId);\n    if (targetStep !== undefined) {\n      this._descriptionParts.push(`→ loops back to step ${targetStep}`);\n    } else {\n      this._descriptionParts.push(`→ loops back to ${stageId}`);\n    }\n\n    // L7.3 — Fire the loop back-edge event. Distinct from `onEdgeAdded`\n    // because runtime `onLoop` carries `iteration: number` which has no\n    // build meaning — separate event keeps payloads honest.\n    this._fireLoopEdgeAdded(cur.id, stageId);\n    return this;\n  }\n\n  // ── Streaming ──\n\n  onStream(handler: StreamTokenHandler): this {\n    this._streamHandlers.onToken = handler;\n    return this;\n  }\n\n  onStreamStart(handler: StreamLifecycleHandler): this {\n    this._streamHandlers.onStart = handler;\n    return this;\n  }\n\n  onStreamEnd(handler: StreamLifecycleHandler): this {\n    this._streamHandlers.onEnd = handler;\n    return this;\n  }\n\n  // ── Output ──\n\n  build(): RunnableFlowChart<TOut, TScope> {\n    // L7.3 — seal the chart so post-build attaches throw. Prevents\n    // recorders attached mid-execution from getting partial data.\n    this._sealed = true;\n\n    const root = this._root ?? fail('empty tree; call start() first');\n    const rootSpec = this._rootSpec ?? fail('empty spec; call start() first');\n\n    const subflows: Record<string, { root: StageNode<TOut, TScope> }> = {};\n    for (const [key, def] of this._subflowDefs) {\n      subflows[key] = def;\n    }\n\n    const rootName = this._root?.name ?? 'FlowChart';\n    const description =\n      this._descriptionParts.length > 0 ? `FlowChart: ${rootName}\\nSteps:\\n${this._descriptionParts.join('\\n')}` : '';\n\n    const chart: FlowChart<TOut, TScope> = {\n      root,\n      stageMap: this._stageMap,\n      buildTimeStructure: rootSpec,\n      ...(Object.keys(subflows).length > 0 ? { subflows } : {}),\n      ...(this._enableNarrative ? { enableNarrative: true } : {}),\n      ...(this._logger ? { logger: this._logger } : {}),\n      description,\n      stageDescriptions: new Map(this._stageDescriptions),\n      ...(this._inputSchema ? { inputSchema: this._inputSchema } : {}),\n      ...(this._outputSchema ? { outputSchema: this._outputSchema } : {}),\n      ...(this._outputMapper ? { outputMapper: this._outputMapper } : {}),\n      // Auto-embed TypedScope factory if none was explicitly set.\n      // This means ANY way of creating a FlowChartBuilder (flowChart(), new FlowChartBuilder(),\n      // or any subclass) automatically gets TypedScope — no manual setScopeFactory needed.\n      scopeFactory: this._scopeFactory ?? (createTypedScopeFactory() as unknown as ScopeFactory<TScope>),\n    };\n\n    return makeRunnable(chart);\n  }\n\n  /** Override the scope factory. Rarely needed — auto-embeds TypedScope by default. */\n  setScopeFactory(factory: ScopeFactory<TScope>): this {\n    this._scopeFactory = factory;\n    return this;\n  }\n\n  toSpec<TResult = SerializedPipelineStructure>(): TResult {\n    const rootSpec = this._rootSpec ?? fail('empty tree; call start() first');\n    return rootSpec as TResult;\n  }\n\n  toMermaid(): string {\n    const lines: string[] = ['flowchart TD'];\n    const idOf = (k: string) => (k || '').replace(/[^a-zA-Z0-9_]/g, '_') || '_';\n    const root = this._root ?? fail('empty tree; call start() first');\n\n    const walk = (n: StageNode<TOut, TScope>) => {\n      const nid = idOf(n.id);\n      lines.push(`${nid}[\"${n.name}\"]`);\n      for (const c of n.children || []) {\n        const cid = idOf(c.id);\n        lines.push(`${nid} --> ${cid}`);\n        walk(c);\n      }\n      if (n.next) {\n        const mid = idOf(n.next.id);\n        lines.push(`${nid} --> ${mid}`);\n        walk(n.next);\n      }\n    };\n    walk(root);\n    return lines.join('\\n');\n  }\n\n  // ── Internals (exposed for helper classes) ──\n\n  private _needCursor(): StageNode<TOut, TScope> {\n    return this._cursor ?? fail('cursor undefined; call start() first');\n  }\n\n  private _needCursorSpec(): SerializedPipelineStructure {\n    return this._cursorSpec ?? fail('cursor undefined; call start() first');\n  }\n\n  /**\n   * The node a fan-out (`addListOfFunction`, `addSubFlowChart`,\n   * `addLazySubFlowChart`) hangs its children on — the cursor, unless the\n   * cursor's `children` already MEAN something else:\n   *\n   * - a subflow MOUNT — the engine reads a mount that carries children as the\n   *   mounted chart's OWN content (`NodeResolver · resolveSubflowReference`),\n   *   so a fork hung there ran INSIDE the subflow: the subflow's real chart\n   *   never ran, everything after the fork ran twice, and a pause after it was\n   *   checkpointed under the wrong subflow path (and refused on resume);\n   * - a DECIDER or a SELECTOR (the cursor after `.end()`) — its children are\n   *   its branches, so a fork child became a branch nobody picks;\n   * - a `parallelForEach` — its branches come from `items` at run time and\n   *   built children are never dispatched, so the fork never ran.\n   *\n   * Through 9.37.0 the builder hung the fork there anyway. So after such a\n   * node the fork continues AFTER it: a function-less fork node\n   * `<nodeId>-fork` becomes the node's `next` and the new cursor — the shape\n   * `addFunction(...).addListOfFunction(...)` already builds, which every\n   * reader (engine, resume, structure, spec) handles. A second fan-out call\n   * reuses that node, as it would any cursor. The id is reserved both ways:\n   * refused here when a stage already has it, and by stage admission /\n   * `_registerSubflowDef` when a later stage or mount asks for it.\n   */\n  private _needForkParent(): { cur: StageNode<TOut, TScope>; curSpec: SerializedPipelineStructure } {\n    const owner = this._needCursor();\n    const ownerSpec = this._needCursorSpec();\n    const childrenMeanSomethingElse =\n      owner.isSubflowRoot || owner.isDynamicParallel || owner.deciderFn || owner.selectorFn;\n    if (!childrenMeanSomethingElse) return { cur: owner, curSpec: ownerSpec };\n\n    const id = `${owner.id}-fork`;\n    if (this._idTaken(id)) {\n      fail(\n        `cannot fan out after '${owner.name}': the fork node it needs, '${id}', ` +\n          `is already a stage id. Add a stage after '${owner.name}' and fan out from it.`,\n      );\n    }\n    const node: StageNode<TOut, TScope> = { name: id, id };\n    const spec: SerializedPipelineStructure = { name: id, id, type: 'fork' };\n    owner.next = node;\n    ownerSpec.next = spec;\n    this._cursor = node;\n    this._advanceCursorSpec(spec);\n    this._knownStageIds.add(id);\n    this._forkNodeIds.add(id);\n    this._fireStageAdded(spec);\n    this._fireNextEdgeFromParent(ownerSpec, id);\n    return { cur: node, curSpec: spec };\n  }\n\n  /** Ids `_needForkParent` generated — no later stage or mount may take one. */\n  private _forkNodeIds = new Set<string>();\n\n  /** Shared by stage admission and subflow registration: reserved structural ids cannot be reused. */\n  private _refuseForkNodeId(id: string): void {\n    if (this._claimedIds.has(id)) {\n      fail(`id '${id}' is already used by a lazy subflow mount or a parallelForEach in this chart. Rename the stage.`);\n    }\n    if (!this._forkNodeIds.has(id)) return;\n    fail(\n      `id '${id}' is taken: it is the fork node the builder placed after '${id.slice(0, -'-fork'.length)}' ` +\n        '(a fan-out right after a subflow mount, decider, selector or parallelForEach continues on it). ' +\n        'Rename the stage.',\n    );\n  }\n\n  /** Ids the lazy-mount and parallelForEach doors claimed (they register in no map). */\n  private _claimedIds = new Set<string>();\n\n  /** Structural declarations without an embedded function; not function entries or loop targets. */\n  private _functionlessStageIds = new Set<string>();\n\n  /** True when an earlier stage, branch, fork child, mount or generated fork node holds `id`. */\n  private _idTaken(id: string): boolean {\n    return (\n      this._knownStageIds.has(id) ||\n      this._stageMap.has(id) ||\n      this._functionlessStageIds.has(id) ||\n      this._subflowDefs.has(id) ||\n      this._claimedIds.has(id) ||\n      this._forkNodeIds.has(id)\n    );\n  }\n\n  /**\n   * @internal The lazy-mount doors and `addParallelForEach` register their id\n   * in no map, so through 9.37.0 they accepted an id another stage or mount\n   * already had (and a later stage could take theirs). They claim it here:\n   * refused when taken, recorded when fresh. Loop-ref stubs reference an\n   * existing stage rather than claiming a new id. Reusable function stages\n   * retain their separate `_addToMap` rule.\n   */\n  _claimFreshId(id: string, door: string): void {\n    if (this._idTaken(id)) {\n      fail(`${door}: id '${id}' is already used by another stage or mount in this chart. Give it its own id.`);\n    }\n    this._claimedIds.add(id);\n  }\n\n  /**\n   * Advance the spec cursor. Retained as a method so call sites stay\n   * one-liners and future cursor-related side effects have a hook.\n   */\n  /**\n   * What was attached to the CURSOR without advancing it — a subflow mount, a\n   * parallel fork's children. Cleared by {@link _advanceCursorSpec}, the single\n   * choke point every cursor-advancing method already goes through, so this\n   * marker cannot drift as new builder methods are added.\n   *\n   * Exists for `.retry()`. Those methods hang children off the current stage\n   * and leave the cursor pointing at that stage, so a chained `.retry()` would\n   * silently attach the policy to the stage BEFORE the thing you just wrote —\n   * exactly the silent mis-attribution this codebase refuses elsewhere (see\n   * the branch-segment marker rules). Naming what was last added lets the\n   * refusal say something useful.\n   */\n  private _cursorTail?: string;\n\n  private _advanceCursorSpec(newSpec: SerializedPipelineStructure | undefined): void {\n    this._cursorTail = undefined;\n    this._cursorSpec = newSpec;\n  }\n\n  _stageMapHas(key: string): boolean {\n    return this._stageMap.has(key);\n  }\n\n  /**\n   * @internal Register a mounted subflow's definition — first mount wins,\n   * at every eager mount site (linear, fork child, decider and selector\n   * branch). A SECOND mount under the same id is allowed (existing charts do\n   * it) and shares the first one's definition — but a pause inside either\n   * cannot be resumed: a checkpoint's `subflowPath` names the subflow id, not\n   * the mount, so `resume()` refuses the ambiguous path. Dev mode says so\n   * here, at build time, where the id can still be changed.\n   */\n  _registerSubflowDef(id: string, root: StageNode<TOut, TScope>): void {\n    this._refuseForkNodeId(id);\n    if (!this._subflowDefs.has(id)) {\n      this._subflowDefs.set(id, { root });\n      return;\n    }\n    if (isDevMode()) {\n      // eslint-disable-next-line no-console\n      console.warn(\n        `[footprint] subflow id '${id}' is mounted more than once in this chart. The mounts share one ` +\n          'definition, and a pause inside either cannot be resumed — the checkpoint cannot say which mount ' +\n          'paused. Give each mount its own id.',\n      );\n    }\n  }\n\n  /**\n   * @internal One admission path for optional-function children and branches.\n   * A missing function does not erase the graph identity: check reservations\n   * and record it for future fresh-id claims, without adding a function or a\n   * loop target. Existing function references by id/name remain legal.\n   */\n  _registerStage(id: string, fn: StageFunction<TOut, TScope> | undefined): void {\n    if (fn) {\n      this._addToMap(id, fn);\n      return;\n    }\n    this._refuseForkNodeId(id);\n    this._functionlessStageIds.add(id);\n  }\n\n  _addToMap(id: string, fn: StageFunction<TOut, TScope>) {\n    this._refuseForkNodeId(id);\n    if (this._stageMap.has(id)) {\n      const existing = this._stageMap.get(id);\n      if (existing !== fn) fail(`stageMap collision for id '${id}'`);\n    }\n    this._stageMap.set(id, fn);\n  }\n\n  _mergeStageMap(other: Map<string, StageFunction<TOut, TScope>>, prefix?: string) {\n    for (const [k, v] of other) {\n      const key = prefix ? joinPath(prefix, k) : k;\n      if (this._stageMap.has(key)) {\n        const existing = this._stageMap.get(key);\n        if (existing !== v) fail(`stageMap collision while mounting flowchart at '${key}'`);\n      } else {\n        this._stageMap.set(key, v);\n      }\n    }\n  }\n\n  /**\n   * Prefix a node tree with a subflow path segment at MOUNT time — the one\n   * prefixer, `engine/graph/prefixNodeTree.ts` (the traverser calls the same\n   * function at RUN time). Kept as the builder's door for its mount sites.\n   */\n  _prefixNodeTree(node: StageNode<TOut, TScope>, prefix: string): StageNode<TOut, TScope> {\n    return prefixNodeTree(node, prefix);\n  }\n\n  /**\n   * THE mount of a subflow chart under `id` (F10) — every eager mount site\n   * (`addSubFlowChart`, `addSubFlowChartNext`, a decider/selector\n   * `addSubFlowChartBranch`) goes through it, and it is the one caller of the\n   * prefixer. In order: register the chart's prefixed root under `id`;\n   * `place` the mount's own node + spec and fire its structure events; merge\n   * the chart's stage map under `id`; register its nested subflows under\n   * `id/<key>` (a key already registered is kept).\n   */\n  _mountSubflow(id: string, subflow: FlowChart<any, any>, place: () => void): void {\n    const prefixed = (root: StageNode<TOut, TScope>) => this._prefixNodeTree(root, id);\n    this._registerSubflowDef(id, prefixed(subflow.root));\n    place();\n    this._mergeStageMap(subflow.stageMap, id);\n    if (!subflow.subflows) return;\n    for (const [key, def] of Object.entries(subflow.subflows)) {\n      const prefixedKey = joinPath(id, key);\n      if (!this._subflowDefs.has(prefixedKey)) {\n        this._subflowDefs.set(prefixedKey, { root: prefixed(def.root as StageNode<TOut, TScope>) });\n      }\n    }\n  }\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Factory Function\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Start a flowchart with its first stage; returns a fluent builder.\n *\n * Chain `.addFunction()` / `.addDeciderFunction()` / `.addSelectorFunction()` /\n * `.addSubFlowChart()` etc. to add more stages, then finish with `.build()`.\n *\n * @param name    Human-readable display label for the stage (shown in the narrative/trace).\n * @param fn      The stage's work — a `(scope) => …` function, or a `PausableHandler` for human-in-the-loop pauses.\n * @param id      Stable stage id used in traces, the commit log, and `runtimeStageId`. Keep it unique within the chart.\n * @param options Optional `{ description?, structureRecorders? }`.\n *\n * @example\n * const chart = flowChart<State>('FetchUser', async (scope) => {\n *   scope.user = await getUser();\n * }, 'fetch-user')\n *   .addFunction('Process', processFn, 'process')\n *   .build();\n *\n * const trace = narrative();\n * const result = await chart.recorder(trace).run();\n * console.log(trace.getEntries().map((e) => e.text).join('\\n'));\n */\n// Overload 1: typed state with options object.\nexport function flowChart<TState extends object>(\n  name: string,\n  fn: TypedStageFunction<TState> | PausableHandler<TypedScope<TState>>,\n  id: string,\n  options?: FlowChartOptions,\n): FlowChartBuilder<any, TypedScope<TState>>;\n\n// Overload 2: explicit generics with options object.\nexport function flowChart<TOut = any, TScope = any>(\n  name: string,\n  fn: StageFunction<TOut, TScope> | PausableHandler<TScope>,\n  id: string,\n  options?: FlowChartOptions,\n): FlowChartBuilder<TOut, TScope>;\n\n// Single implementation — accepts the options bag (or undefined).\nexport function flowChart<TOut = any, TScope = any>(\n  name: string,\n  fn: StageFunction<TOut, TScope> | PausableHandler<TScope>,\n  id: string,\n  options?: FlowChartOptions,\n): FlowChartBuilder<TOut, TScope> {\n  const builder = new FlowChartBuilder<TOut, TScope>();\n  // Attach StructureRecorders BEFORE start() so the seed event fires through\n  // the normal dispatcher path (no replay needed). Iteration order matches\n  // array order, matching the fluent `.attachStructureRecorder()` chain\n  // semantics.\n  if (options?.structureRecorders) {\n    for (const rec of options.structureRecorders) {\n      builder.attachStructureRecorder(rec);\n    }\n  }\n  return builder.start(name, fn as any, id, options?.description, {\n    ...(options?.retry && { retry: options.retry }),\n    ...(options?.tags && { tags: options.tags }),\n  });\n}\n\n/**\n * Like `flowChart()`, but the ROOT stage is a SELECTOR — it runs first and\n * its branches attach directly to it (no separate seed stage). Returns a\n * `SelectorFnList`; declare branches then call `.end()` to get the builder\n * back for any subsequent stages.\n *\n * @example\n *   flowChartSelector<MyState>('Context', contextSelectorFn, 'context')\n *     .addSubFlowChartBranch('sf-system-prompt', sysSlot, 'System Prompt', {...})\n *     .addSubFlowChartBranch('sf-messages', msgSlot, 'Messages', {...})\n *     .end()\n *     .addFunction('messageAPI', assembleFn, 'message-api')\n *     .build();\n */\nexport function flowChartSelector<TOut = any, TScope = any>(\n  name: string,\n  fn: StageFunction<any, TScope>,\n  id: string,\n  options?: FlowChartOptions,\n): SelectorFnList<TOut, TScope> {\n  const builder = new FlowChartBuilder<TOut, TScope>();\n  if (options?.structureRecorders) {\n    for (const rec of options.structureRecorders) {\n      builder.attachStructureRecorder(rec);\n    }\n  }\n  return builder.startSelector(name, fn, id, options?.description, {\n    ...(options?.failFast !== undefined && { failFast: options.failFast }),\n    ...(options?.retry && { retry: options.retry }),\n    ...(options?.tags && { tags: options.tags }),\n  });\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Spec to StageNode Converter\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport function specToStageNode(spec: FlowChartSpec): StageNode<any, any> {\n  const inflate = (s: FlowChartSpec): StageNode<any, any> => ({\n    name: s.name,\n    id: s.id,\n    children: s.children?.length ? s.children.map(inflate) : undefined,\n    next: s.next ? inflate(s.next) : undefined,\n  });\n  return inflate(spec);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FlowChartBuilder.js","sourceRoot":"","sources":["../../../../src/lib/builder/FlowChartBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * FlowChartBuilder — Fluent API for constructing flowchart execution graphs.\n *\n * Builds StageNode trees and SerializedPipelineStructure (JSON) in tandem.\n * Zero dependencies on old code — only imports from local types.\n *\n * The builder creates two parallel structures:\n * 1. StageNode tree — runtime graph with embedded functions\n * 2. SerializedPipelineStructure — JSON-safe structure for visualization\n *\n * The execute() convenience method is intentionally omitted —\n * it belongs in the runner layer (Phase 5).\n */\n\nimport { joinPath } from 'foottrace';\n\nimport { touchesProblem } from '../attempt/effect.js';\nimport { retryPolicyProblem } from '../attempt/policy.js';\nimport { declareRetryLoopBudget } from '../attempt/retryLoopContext.js';\nimport { budgetRefusal, budgetWarning, timeBudget } from '../budget/index.js';\nimport { isDevMode } from '../devMode.js';\nimport { prefixNodeTree } from '../engine/graph/prefixNodeTree.js';\nimport type { ParallelForEachConfig, RetryPolicy, ScopeFactory, StageTouches } from '../engine/types.js';\nimport { BRANCH_SEGMENT_MARKER, hasBranchSegmentMarker } from '../ids/branchSegment.js';\nimport { type IdPosition, refuseReservedId } from '../ids/reservedIds.js';\nimport type { PausableHandler } from '../pause/types.js';\nimport type { TypedScope } from '../reactive/types.js';\nimport { type RunnableFlowChart, makeRunnable } from '../runner/RunnableChart.js';\nimport type { RetryLoopOptions } from './retryLoop.js';\nimport { appendRetryLoop } from './retryLoop.js';\nimport type { StructureEdgeKind, StructureRecorder } from './structure/StructureRecorder.js';\nimport { StructureRecorderDispatcher } from './structure/StructureRecorderDispatcher.js';\nimport { type TypedStageFunction, createTypedScopeFactory } from './typedFlowChart.js';\nimport type {\n  FlowChart,\n  FlowChartOptions,\n  FlowChartSpec,\n  ILogger,\n  SerializedPipelineStructure,\n  SimplifiedParallelSpec,\n  StageFunction,\n  StageNode,\n  StreamHandlers,\n  StreamLifecycleHandler,\n  StreamTokenHandler,\n  SubflowMountOptions,\n} from './types.js';\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Internal helpers\n// ─────────────────────────────────────────────────────────────────────────────\n\nconst fail = (msg: string): never => {\n  throw new Error(`[FlowChartBuilder] ${msg}`);\n};\n\n/**\n * Attach a declarative retry policy to a stage node + its spec node.\n *\n * The ONE place a policy lands on a node, shared by the `.retry()` cursor\n * modifier and by every `options.retry` declaration site, so validation and the\n * spec's `retryAttempts` mirror can never drift between them.\n *\n * `attempts` is validated at BUILD time rather than defended at runtime: a\n * typo'd `attempts: 0` should fail while you are writing the chart, not\n * silently turn a stage into a no-op run three months later. `attempts: 1` is\n * accepted on purpose — it means \"policy declared, currently off\", so a policy\n * can be dialled down without deleting the declaration. The rule is\n * `attempt/policy.ts · retryPolicyProblem`, which the traverser also applies to\n * a StageNode a stage returns at run time.\n */\nfunction applyRetryPolicy(\n  node: StageNode<any, any>,\n  spec: SerializedPipelineStructure,\n  retry: RetryPolicy | undefined,\n  where: string,\n): void {\n  if (!retry) return;\n  const problem = retryPolicyProblem(retry);\n  if (problem !== undefined) fail(`${where}: ${problem}`);\n  // A touching stage declared first: the policy must not make it retry without a key (P3 — either order refuses).\n  if (node.touches) {\n    const touching = touchesProblem(node.touches, retry);\n    if (touching !== undefined) fail(`${where}: stage '${node.name}' ${touching}`);\n  }\n  node.retry = retry;\n  spec.retryAttempts = retry.attempts;\n  // The cap rides the spec beside the count (P5): a JSON-safe fact, so a reader of the spec sees what bounds the stage.\n  if (retry.timeoutMs !== undefined) spec.timeoutMs = retry.timeoutMs;\n}\n\n/**\n * Attach a side-effect declaration to a stage node + its spec node (10.1, design §3.3) — the twin of\n * {@link applyRetryPolicy}: the ONE place `touches` lands, shared by the `.touches()` cursor modifier and every\n * `options.touches` site.\n *\n * The law is `attempt/effect.ts · touchesProblem`, which the traverser also applies to a StageNode returned at run\n * time and to every stage it runs: `system` a name, the key rule a function, and a stage that may retry must declare\n * the key rule — a retry of an outside effect without one can apply it twice. Checked here against the policy\n * already on the node; `applyRetryPolicy` checks a policy that lands after. The spec carries the system NAME only.\n */\nfunction applyTouches(\n  node: StageNode<any, any>,\n  spec: SerializedPipelineStructure,\n  touches: StageTouches | undefined,\n  where: string,\n): void {\n  if (touches === undefined) return;\n  if (node.touches) fail(`${where}: touches already declared at '${node.name}' (${node.touches.system})`);\n  // Each field read ONCE, then checked and frozen: what is checked is exactly what lands (a getter cannot differ).\n  const read = (touches !== null && typeof touches === 'object' ? touches : {}) as Partial<StageTouches>;\n  const { system, idempotencyKey } = read;\n  const copy = { system, ...(idempotencyKey !== undefined && { idempotencyKey }) };\n  const problem = touchesProblem(touches === null || typeof touches !== 'object' ? touches : copy, node.retry);\n  if (problem !== undefined) fail(`${where}: stage '${node.name}' ${problem}`);\n  // The node's copy is frozen and holds only the two named fields: nothing else on the caller's object rides along.\n  node.touches = Object.freeze(copy as StageTouches);\n  spec.touches = system as string;\n}\n\n/**\n * Attach declared tags to a stage node + its spec node.\n *\n * The ONE place tags land on a node — the twin of {@link applyRetryPolicy} —\n * shared by the `.tag()` cursor modifier and every `options.tags` declaration\n * site, so the refusals and the spec's mirror can never drift between them.\n *\n * A tag is a NAME declared at build time, never a value, so every refusal is\n * about the name's shape: an empty string names nothing; a non-string is a\n * value, and a value on a stage would ride the commit log past every\n * redaction point; the branch-segment marker is the runtimeStageId grammar's\n * one reserved byte, and a consumer that puts a tag into a path (a URL, a\n * store key) would inherit exactly the ambiguity the reservation exists to\n * prevent; a name declared twice is the typo it usually is. Refused at BUILD\n * time, like `retry.attempts`, so the mistake fails while the chart is being\n * written. An EMPTY list lands nothing: \"absent when empty\" is the law the\n * commit bundle keeps, and the spec keeps it too.\n */\nfunction applyTags(\n  node: StageNode<any, any>,\n  spec: SerializedPipelineStructure,\n  tags: readonly string[] | undefined,\n  where: string,\n): void {\n  if (tags === undefined) return;\n  if (!Array.isArray(tags)) fail(`${where}: tags must be an array of names (got ${typeof tags})`);\n  if (tags.length === 0) return;\n  const seen = new Set<string>();\n  for (const tag of tags) {\n    if (typeof tag !== 'string') {\n      fail(\n        `${where}: a tag must be a string name (got ${tag === null ? 'null' : typeof tag}). A tag is a NAME ` +\n          'declared at build time — a value belongs in state or in $emit, never on the stage.',\n      );\n    }\n    if (tag.trim().length === 0) fail(`${where}: a tag cannot be an empty string`);\n    if (hasBranchSegmentMarker(tag)) {\n      fail(\n        `${where}: tag '${tag}' contains the reserved character '${BRANCH_SEGMENT_MARKER}'. ` +\n          `'${BRANCH_SEGMENT_MARKER}' is reserved for the subflow path segments addParallelForEach() generates, ` +\n          'and a tag that a consumer puts into a path or a key would inherit that ambiguity. Rename the tag ' +\n          '(a dash or a colon reads the same). See docs/design/2026-09-declared-tags.md.',\n      );\n    }\n    if (seen.has(tag)) fail(`${where}: tag '${tag}' is declared twice`);\n    seen.add(tag);\n  }\n  if (node.tags) {\n    fail(\n      `${where}: tags already declared at '${node.name}' (${node.tags.join(', ')}) — declare every tag for a ` +\n        'stage in ONE place, so the Map advertises the whole vocabulary from a single site.',\n    );\n  }\n  // The node's copy is frozen: commit bundles share it by reference and the\n  // library's reads are borrowed, never mutated. The spec's copy is its own\n  // plain array, JSON-safe like the rest of the spec.\n  node.tags = Object.freeze([...tags]);\n  spec.tags = [...tags];\n}\n\n/**\n * The builder's ONE id refusal (F7, R5): every id door calls it once, before\n * the id lands anywhere. The rule lives beside the grammar —\n * `ids/reservedIds.ts · refuseReservedId`: `#` and `/` are refused in\n * every id (they are the runtimeStageId grammar's delimiters), `~` in a\n * `'segment'` id (a subflow id or a `parallelForEach` id — see below).\n *\n * Doors (one call each): `start`, `startSelector`, `addFunction`,\n * `addStreamingFunction`, `addPausableFunction`, `addDeciderFunction`,\n * `addSelectorFunction`, `addListOfFunction` (each child), `addParallelForEach`,\n * every subflow mount (`assertSubflowIdAllowed`) and every decider/selector\n * branch (`BranchCursor · admit`). `addDetachAndForget` /\n * `addDetachAndJoinLater` and `addBranchList` delegate to one of these.\n * Never called by the prefixer or a store — those hold ids that carry the\n * delimiters on purpose.\n */\nconst admitId = (what: string, id: string, position: IdPosition): void => {\n  const refusal = refuseReservedId(what, id, position);\n  if (refusal !== undefined) fail(refusal);\n};\n\n/**\n * Refuse the reserved characters in a user-authored SUBFLOW id.\n *\n * A subflow id IS a path segment in `runtimeStageId`, which is the same\n * position `addParallelForEach` generates its branch segments into. A\n * hand-authored id carrying the marker could therefore collide with a\n * generated branch — and, because this codebase deliberately tolerates\n * id-collision classes (loop-ref stubs), such a collision would not crash. It\n * would silently mis-attribute a trace, which is worse. So the marker is\n * refused at BUILD time, on NEW charts only: a chart that was legal before\n * 9.14.0 and does not use the marker behaves byte-identically.\n *\n * Called at every user-authored subflow-id entry point. Stage ids elsewhere\n * keep `~` (they occupy the `stageId` position, never the `subflowPath`\n * position, so they cannot collide with a segment) but, since 9.37.0, not `#`\n * or `/` — see `admitId`. (`addParallelForEach`'s own id is the one other\n * `'segment'` id, refused at that method.) Design: docs/design/execution-control.md.\n */\nconst assertSubflowIdAllowed = (id: string): void => admitId('subflow id', id, 'segment');\n\n// ─────────────────────────────────────────────────────────────────────────────\n// BranchCursor — what DeciderList and SelectorFnList share (F7)\n// ─────────────────────────────────────────────────────────────────────────────\n\n/** Which dispatcher a {@link BranchCursor} adds branches under. */\ntype BranchKind = 'decider' | 'selector';\n\n/**\n * The branch-adding mechanics of a decider or a selector — ONE implementation,\n * composed by {@link DeciderList} and {@link SelectorFnList} (until 9.36.0 each\n * list carried its own copy of all four branch kinds and `end()`).\n *\n * Owns: the branch-id ledger (duplicate + reserved-character refusal in one\n * `admit`), the node/spec pair each branch kind builds, the structure events,\n * and the closing `finish`. The lists keep only what differs: a decider's\n * `{ loopTo }` / `loopTo()` / `setDefault`, and the type each method returns.\n */\nclass BranchCursor<TOut, TScope> {\n  readonly branchIds = new Set<string>();\n  private readonly branchDescInfo: Array<{ id: string; description?: string }> = [];\n\n  constructor(\n    private readonly kind: BranchKind,\n    readonly b: FlowChartBuilder<TOut, TScope>,\n    readonly curNode: StageNode<TOut, TScope>,\n    readonly curSpec: SerializedPipelineStructure,\n    readonly parentDescriptionParts: string[],\n    private readonly parentStageDescriptions: Map<string, string>,\n    private readonly reservedStepNumber: number,\n    private readonly description?: string,\n  ) {}\n\n  /**\n   * A dispatcher is defined ONCE. `finish` flags its node, and from then on\n   * the node's branches, its `branchIds` and its `onDeciderComplete` are\n   * final. A list held past `.end()` could re-open it — a second `end()`\n   * appended another `'default'` clone, fired a second completion and wrote a\n   * second description line; a late branch or `loopTo` changed a node whose\n   * `branchIds` were already published. This is the one same-node refusal.\n   * The guard that `addDeciderFunction` / `addSelectorFunction` carried until\n   * 10.0.1 read the PREVIOUS node's flags instead, and so refused a dispatcher\n   * that follows a dispatcher — a chain, which is a new node at its `next`.\n   */\n  assertOpen(action: string): void {\n    if (this.curNode.deciderFn || this.curNode.selectorFn) {\n      fail(`cannot ${action}: ${this.kind} '${this.curNode.name}' was already closed by end()`);\n    }\n  }\n\n  /** The one branch-id door: a closed dispatcher, a duplicate, then the reserved characters (R5). */\n  private admit(id: string, position: IdPosition): void {\n    this.assertOpen(`add branch '${id}'`);\n    if (this.branchIds.has(id)) fail(`duplicate ${this.kind} branch id '${id}' under '${this.curNode.name}'`);\n    if (position === 'segment') assertSubflowIdAllowed(id);\n    else admitId('branch id', id, 'stage');\n    this.branchIds.add(id);\n  }\n\n  /** Append the branch's node + spec and fire its stage and decision-branch edge. */\n  private attach(node: StageNode<TOut, TScope>, spec: SerializedPipelineStructure, id: string): void {\n    this.curNode.children = this.curNode.children || [];\n    this.curNode.children.push(node);\n    this.curSpec.children = this.curSpec.children || [];\n    this.curSpec.children.push(spec);\n    // L7.3 — branch: stage + decision-branch edge keyed by id.\n    this.b._fireStageAddedFromSubBuilder(spec);\n    this.b._fireEdgeAddedFromSubBuilder(this.curSpec.id, spec.id, 'decision-branch', id);\n  }\n\n  functionBranch(\n    id: string,\n    name: string,\n    fn: StageFunction<TOut, TScope> | undefined,\n    description: string | undefined,\n    options:\n      | { readonly retry?: RetryPolicy; readonly touches?: StageTouches; readonly tags?: readonly string[] }\n      | undefined,\n  ): { node: StageNode<TOut, TScope>; spec: SerializedPipelineStructure } {\n    this.admit(id, 'stage');\n\n    const node: StageNode<TOut, TScope> = { name: name ?? id, id, branchId: id };\n    if (description) node.description = description;\n    if (fn) {\n      node.fn = fn;\n    }\n    this.b._registerStage(id, fn);\n\n    const spec: SerializedPipelineStructure = { name: name ?? id, id, type: 'stage' };\n    if (description) spec.description = description;\n    applyRetryPolicy(node, spec, options?.retry, `addFunctionBranch('${id}')`);\n    applyTouches(node, spec, options?.touches, `addFunctionBranch('${id}')`);\n    applyTags(node, spec, options?.tags, `addFunctionBranch('${id}')`);\n\n    this.attach(node, spec, id);\n    this.branchDescInfo.push({ id, description });\n    return { node, spec };\n  }\n\n  pausableBranch(\n    id: string,\n    name: string,\n    handler: PausableHandler<TScope>,\n    description: string | undefined,\n    options:\n      | { readonly retry?: RetryPolicy; readonly touches?: StageTouches; readonly tags?: readonly string[] }\n      | undefined,\n  ): { node: StageNode<TOut, TScope>; spec: SerializedPipelineStructure } {\n    this.admit(id, 'stage');\n\n    const node: StageNode<TOut, TScope> = {\n      name: name ?? id,\n      id,\n      branchId: id,\n      fn: handler.execute as StageFunction<TOut, TScope>,\n      isPausable: true,\n      resumeFn: handler.resume,\n    };\n    if (description) node.description = description;\n    this.b._addToMap(id, handler.execute as StageFunction<TOut, TScope>);\n\n    const spec: SerializedPipelineStructure = { name: name ?? id, id, type: 'stage', isPausable: true };\n    if (description) spec.description = description;\n    applyRetryPolicy(node, spec, options?.retry, `addPausableFunctionBranch('${id}')`);\n    applyTouches(node, spec, options?.touches, `addPausableFunctionBranch('${id}')`);\n    applyTags(node, spec, options?.tags, `addPausableFunctionBranch('${id}')`);\n\n    this.attach(node, spec, id);\n    this.branchDescInfo.push({ id, description });\n    return { node, spec };\n  }\n\n  subflowBranch(\n    id: string,\n    subflow: FlowChart<any, any>,\n    mountName: string | undefined,\n    options: SubflowMountOptions | undefined,\n  ): void {\n    this.admit(id, 'segment');\n\n    const subflowName = mountName || id;\n    this.b._mountSubflow(id, subflow, () => this.placeSubflowBranch(id, subflow, subflowName, options));\n  }\n\n  /** The branch mount's own node + spec, placed under the decider/selector (see `_mountSubflow`). */\n  private placeSubflowBranch(\n    id: string,\n    subflow: FlowChart<any, any>,\n    subflowName: string,\n    options: SubflowMountOptions | undefined,\n  ): void {\n    const node: StageNode<TOut, TScope> = {\n      name: subflowName,\n      id,\n      branchId: id,\n      isSubflowRoot: true,\n      subflowId: id,\n      subflowName,\n    };\n    if (options) node.subflowMountOptions = options;\n\n    const spec: SerializedPipelineStructure = {\n      name: subflowName,\n      type: 'stage',\n      id,\n      isSubflowRoot: true,\n      subflowId: id,\n      subflowName,\n      subflowStructure: subflow.buildTimeStructure,\n    };\n    // STRUCTURE-ONLY convergence override (see `_fireNextEdgeFromParent` +\n    // `SubflowMountOptions.convergeAt`): this branch's convergence edge points at\n    // `convergeAt` (a DOWNSTREAM stage) instead of the shared next stage — e.g. a\n    // `tools` slot that bypasses `messageAPI` to pair with its output at\n    // `call-llm`. Visualization-only: NO runtime join barrier (data rides scope).\n    // Carried on the spec so the edge-firing chokepoint can read it.\n    if (options?.convergeAt) spec.convergeAt = options.convergeAt;\n\n    applyTags(node, spec, options?.tags, `addSubFlowChartBranch('${id}')`);\n\n    this.attach(node, spec, id);\n    this.b._fireSubflowMountedFromSubBuilder(id, subflowName, id, false, subflow.buildTimeStructure);\n  }\n\n  lazySubflowBranch(\n    id: string,\n    resolver: () => FlowChart<any, any>,\n    mountName: string | undefined,\n    options: SubflowMountOptions | undefined,\n  ): void {\n    this.admit(id, 'segment');\n    this.b._claimFreshId(id, `addLazySubFlowChartBranch('${id}')`);\n\n    const subflowName = mountName || id;\n\n    // Store resolver on the node — NO eager tree cloning\n    const node: StageNode<TOut, TScope> = {\n      name: subflowName,\n      id,\n      branchId: id,\n      isSubflowRoot: true,\n      subflowId: id,\n      subflowName,\n      subflowResolver: resolver as any,\n    };\n    if (options) node.subflowMountOptions = options;\n\n    // Spec stub — no subflowStructure (lazy). The lazy subflow's\n    // internals will be shaped at resolution time.\n    const spec: SerializedPipelineStructure = {\n      name: subflowName,\n      type: 'stage',\n      id,\n      isSubflowRoot: true,\n      subflowId: id,\n      subflowName,\n      isLazy: true,\n    };\n\n    applyTags(node, spec, options?.tags, `addLazySubFlowChartBranch('${id}')`);\n\n    this.attach(node, spec, id);\n    this.b._fireSubflowMountedFromSubBuilder(id, subflowName, id, true);\n  }\n\n  /**\n   * Close the dispatcher: validate the branches, flag the node, describe it,\n   * and fire `onDeciderComplete`. A decider passes its `setDefault` id (the\n   * synthetic `'default'` clone is appended AFTER `branchIds` is taken, so only\n   * user-specified branches are listed); a selector has no default.\n   */\n  finish(defaultId?: string): FlowChartBuilder<TOut, TScope> {\n    this.assertOpen('call end() again');\n    const kind = this.kind;\n    const children = this.curNode.children;\n    if (!children || children.length === 0) {\n      throw new Error(`[FlowChartBuilder] ${kind} at '${this.curNode.name}' requires at least one branch`);\n    }\n\n    // Validate that every branch with no embedded fn is resolvable from the stageMap\n    for (const child of children) {\n      if (!child.fn && child.id && !child.isSubflowRoot && !child.subflowResolver) {\n        const hasInMap = this.b._stageMapHas(child.id) || this.b._stageMapHas(child.name);\n        if (!hasInMap) {\n          throw new Error(\n            `[FlowChartBuilder] ${kind} branch '${child.id}' under '${this.curNode.name}' has no function — ` +\n              `provide a fn argument to addFunctionBranch('${child.id}', ...)`,\n          );\n        }\n      }\n    }\n\n    if (kind === 'decider') this.curNode.deciderFn = true;\n    else this.curNode.selectorFn = true;\n\n    this.curSpec.branchIds = children\n      .map((c) => c.id)\n      .filter((id): id is string => typeof id === 'string' && id.length > 0);\n    this.curSpec.type = kind;\n    if (kind === 'selector') this.curSpec.hasSelector = true;\n\n    if (defaultId) {\n      const defaultChild = children.find((c) => c.id === defaultId);\n      if (defaultChild) {\n        children.push({ ...defaultChild, id: 'default', branchId: 'default' });\n      }\n    }\n\n    if (this.reservedStepNumber > 0) {\n      const label = this.curNode.name;\n      const branchIdList = this.branchDescInfo.map((b) => b.id).join(', ');\n      const mainLine =\n        kind === 'decider'\n          ? this.description\n            ? `${this.reservedStepNumber}. ${label} — ${this.description} (branches: ${branchIdList})`\n            : `${this.reservedStepNumber}. ${label} — Decides between: ${branchIdList}`\n          : this.description\n          ? `${this.reservedStepNumber}. ${label} — ${this.description}`\n          : `${this.reservedStepNumber}. ${label} — Selects from: ${branchIdList}`;\n      this.parentDescriptionParts.push(mainLine);\n\n      if (this.description) {\n        this.parentStageDescriptions.set(this.curNode.name, this.description);\n      }\n\n      for (const branch of this.branchDescInfo) {\n        if (branch.description) this.parentDescriptionParts.push(`   → ${branch.id}: ${branch.description}`);\n        if (branch.description) this.parentStageDescriptions.set(branch.id, branch.description);\n      }\n    }\n\n    // L7.3 — fire `onDeciderComplete` so consumers can trust no more\n    // branches will arrive. Branch iteration order = addition order = Set\n    // insertion order. Selectors have no default branch.\n    if (kind === 'decider') {\n      this.b._fireDeciderCompleteFromSubBuilder(this.curSpec.id, 'decider', [...this.branchIds], defaultId);\n    } else {\n      this.b._fireDeciderCompleteFromSubBuilder(this.curSpec.id, 'selector', [...this.branchIds]);\n    }\n    return this.b;\n  }\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// DeciderList\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Fluent helper returned by addDeciderFunction to add branches.\n * `end()` sets `deciderFn = true` — the fn IS the decider.\n */\nexport class DeciderList<TOut = any, TScope = any> {\n  private readonly cursor: BranchCursor<TOut, TScope>;\n  private defaultId?: string;\n\n  constructor(\n    builder: FlowChartBuilder<TOut, TScope>,\n    curNode: StageNode<TOut, TScope>,\n    curSpec: SerializedPipelineStructure,\n    parentDescriptionParts: string[] = [],\n    parentStageDescriptions: Map<string, string> = new Map(),\n    reservedStepNumber = 0,\n    deciderDescription?: string,\n  ) {\n    this.cursor = new BranchCursor(\n      'decider',\n      builder,\n      curNode,\n      curSpec,\n      parentDescriptionParts,\n      parentStageDescriptions,\n      reservedStepNumber,\n      deciderDescription,\n    );\n  }\n\n  addFunctionBranch(\n    id: string,\n    name: string,\n    fn?: StageFunction<TOut, TScope>,\n    description?: string,\n    /** `{ loopTo }` declares this branch loops back to an already-declared\n     *  stage — the loop is SOURCED FROM THIS BRANCH (not the decider).\n     *  `{ retry }` gives THIS BRANCH's stage a declarative retry policy;\n     *  `{ tags }` puts declared tags on it (see `FlowChartBuilder.tag`). */\n    options?: {\n      readonly loopTo?: string;\n      readonly retry?: RetryPolicy;\n      readonly touches?: StageTouches;\n      readonly tags?: readonly string[];\n    },\n  ): DeciderList<TOut, TScope> {\n    const { node, spec } = this.cursor.functionBranch(id, name, fn, description, options);\n    if (options?.loopTo) this._applyBranchLoop(node, spec, options.loopTo);\n    return this;\n  }\n\n  /**\n   * Add a pausable stage as a decider branch.\n   *\n   * When this branch is chosen, the handler's `execute` runs. If it returns\n   * data, the pipeline pauses. On resume, `handler.resume` runs with the\n   * human's input. If `execute` returns void, the stage continues normally\n   * (conditional pause).\n   */\n  addPausableFunctionBranch(\n    id: string,\n    name: string,\n    handler: PausableHandler<TScope>,\n    description?: string,\n    /** `{ loopTo }` declares this branch loops back to an already-declared\n     *  stage — the loop is SOURCED FROM THIS BRANCH (not the decider).\n     *  `{ retry }` gives THIS BRANCH's `execute` half a retry policy (the\n     *  `resume` half runs without it — a different function, a different\n     *  contract); `{ tags }` puts declared tags on it. */\n    options?: {\n      readonly loopTo?: string;\n      readonly retry?: RetryPolicy;\n      readonly touches?: StageTouches;\n      readonly tags?: readonly string[];\n    },\n  ): DeciderList<TOut, TScope> {\n    const { node, spec } = this.cursor.pausableBranch(id, name, handler, description, options);\n    if (options?.loopTo) this._applyBranchLoop(node, spec, options.loopTo);\n    return this;\n  }\n\n  addSubFlowChartBranch(\n    id: string,\n    subflow: FlowChart<any, any>,\n    mountName?: string,\n    options?: SubflowMountOptions,\n  ): DeciderList<TOut, TScope> {\n    this.cursor.subflowBranch(id, subflow, mountName, options);\n    return this;\n  }\n\n  addLazySubFlowChartBranch(\n    id: string,\n    resolver: () => FlowChart<any, any>,\n    mountName?: string,\n    options?: SubflowMountOptions,\n  ): DeciderList<TOut, TScope> {\n    this.cursor.lazySubflowBranch(id, resolver, mountName, options);\n    return this;\n  }\n\n  addBranchList(\n    branches: Array<{\n      id: string;\n      name: string;\n      fn?: StageFunction<TOut, TScope>;\n    }>,\n  ): DeciderList<TOut, TScope> {\n    for (const { id, name, fn } of branches) {\n      this.addFunctionBranch(id, name, fn);\n    }\n    return this;\n  }\n\n  setDefault(id: string): DeciderList<TOut, TScope> {\n    this.cursor.assertOpen(`setDefault('${id}')`);\n    this.defaultId = id;\n    return this;\n  }\n\n  /**\n   * Attach a loop-back edge to the LAST-added branch, so the loop is sourced\n   * from THAT branch node (e.g. `'tool-calls' → loopTo('context')`) rather than\n   * from the decider. The chart then reads honestly: the decider splits into a\n   * looping branch `[ToolCalls → back to Context]` and a terminating branch\n   * `[Final → end]`, instead of a single loop hanging off the decider.\n   *\n   * No engine change is needed: the runtime runs the chosen branch and then\n   * follows that branch node's OWN `next` — and a `next` flagged `isLoopRef`\n   * routes back to the target exactly like the decider's own loop does. This\n   * method just lets the builder express what the engine already supports.\n   *\n   * Targets the branch added immediately before this call (chain it right after\n   * the branch's `addFunctionBranch`/`addPausableFunctionBranch`/\n   * `addSubFlowChartBranch`). Mirrors `FlowChartBuilder.loopTo` validation.\n   *\n   * Works on a SUBFLOW branch too: the branch node carries both its subflow\n   * resolver AND the loop-back `next` — they coexist safely (the runtime runs\n   * the subflow, then follows the loop ref). The target must be a stage already\n   * declared BEFORE the decider (e.g. an upstream `context`); branch ids and the\n   * synthetic `'default'` clone are NOT valid loop targets.\n   */\n  loopTo(stageId: string): DeciderList<TOut, TScope> {\n    this.cursor.assertOpen(`loopTo('${stageId}')`);\n    const children = this.cursor.curNode.children;\n    const specChildren = this.cursor.curSpec.children;\n    if (!children || children.length === 0 || !specChildren || specChildren.length === 0) {\n      fail(`loopTo('${stageId}') called before any branch was added under '${this.cursor.curNode.name}'`);\n    }\n    // fail() throws, so children/specChildren are non-empty here.\n    this._applyBranchLoop(children![children!.length - 1]!, specChildren![specChildren!.length - 1]!, stageId);\n    return this;\n  }\n\n  /**\n   * Decorate ONE branch node/spec with a loop-back edge to `stageId`. Shared by\n   * the positional `loopTo()` (which targets the last-added branch) AND the\n   * per-branch `{ loopTo }` option on `addFunctionBranch` /\n   * `addPausableFunctionBranch` / `addSubFlowChartBranch`. Either way the loop\n   * SOURCE is the branch — so visualizers read `tool-calls → context`, never\n   * `Route → context`. Validates the target is a stage declared BEFORE the\n   * decider (branch ids / the synthetic 'default' clone are not valid targets).\n   */\n  private _applyBranchLoop(\n    branchNode: StageNode<TOut, TScope>,\n    branchSpec: SerializedPipelineStructure,\n    stageId: string,\n  ): void {\n    if (branchSpec.loopTarget) fail(`loopTo already defined on branch '${branchSpec.id}'`);\n    if (branchNode.next) {\n      fail(`cannot set loopTo on branch '${branchSpec.id}' — it already has a continuation`);\n    }\n    if (!this.cursor.b._knownStageIdsHas(stageId)) {\n      fail(\n        `loopTo('${stageId}') target not found — a branch loop must target a stage ` +\n          \"declared BEFORE the decider (branch ids and the synthetic 'default' branch \" +\n          'are not valid loop targets; did you pass a stage name instead of an id?)',\n      );\n    }\n\n    branchNode.next = { name: stageId, id: stageId, isLoopRef: true };\n    branchSpec.loopTarget = stageId;\n    branchSpec.next = { name: stageId, id: stageId, type: 'loop', isLoopReference: true };\n\n    // Branch-scoped description — attribute the loop to the branch, not the\n    // decider (parentDescriptionParts is the decider's description context).\n    this.cursor.parentDescriptionParts.push(`   → branch '${branchSpec.id}' loops back to ${stageId}`);\n\n    // Fire the loop back-edge SOURCED FROM THE BRANCH so visualizers read\n    // `tool-calls → context`, not `Route → context`.\n    this.cursor.b._fireLoopEdgeAddedFromSubBuilder(branchSpec.id, stageId);\n  }\n\n  end(): FlowChartBuilder<TOut, TScope> {\n    return this.cursor.finish(this.defaultId);\n  }\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// SelectorFnList (scope-based selector — mirrors DeciderList)\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport class SelectorFnList<TOut = any, TScope = any> {\n  private readonly cursor: BranchCursor<TOut, TScope>;\n\n  constructor(\n    builder: FlowChartBuilder<TOut, TScope>,\n    curNode: StageNode<TOut, TScope>,\n    curSpec: SerializedPipelineStructure,\n    parentDescriptionParts: string[] = [],\n    parentStageDescriptions: Map<string, string> = new Map(),\n    reservedStepNumber = 0,\n    selectorDescription?: string,\n  ) {\n    this.cursor = new BranchCursor(\n      'selector',\n      builder,\n      curNode,\n      curSpec,\n      parentDescriptionParts,\n      parentStageDescriptions,\n      reservedStepNumber,\n      selectorDescription,\n    );\n  }\n\n  addFunctionBranch(\n    id: string,\n    name: string,\n    fn?: StageFunction<TOut, TScope>,\n    description?: string,\n    /** `{ retry }` gives THIS BRANCH's stage a declarative retry policy;\n     *  `{ tags }` puts declared tags on it (see `FlowChartBuilder.tag`). */\n    options?: { readonly retry?: RetryPolicy; readonly touches?: StageTouches; readonly tags?: readonly string[] },\n  ): SelectorFnList<TOut, TScope> {\n    this.cursor.functionBranch(id, name, fn, description, options);\n    return this;\n  }\n\n  /**\n   * Add a pausable stage as a selector branch.\n   *\n   * When this branch is selected, the handler's `execute` runs. If it returns\n   * data, the pipeline pauses. On resume, `handler.resume` runs with the\n   * human's input. If `execute` returns void, the stage continues normally.\n   */\n  addPausableFunctionBranch(\n    id: string,\n    name: string,\n    handler: PausableHandler<TScope>,\n    description?: string,\n    /** `{ retry }` gives THIS BRANCH's `execute` half a retry policy (the\n     *  `resume` half runs without it — a different function, a different\n     *  contract); `{ tags }` puts declared tags on it. */\n    options?: { readonly retry?: RetryPolicy; readonly touches?: StageTouches; readonly tags?: readonly string[] },\n  ): SelectorFnList<TOut, TScope> {\n    this.cursor.pausableBranch(id, name, handler, description, options);\n    return this;\n  }\n\n  addSubFlowChartBranch(\n    id: string,\n    subflow: FlowChart<any, any>,\n    mountName?: string,\n    options?: SubflowMountOptions,\n  ): SelectorFnList<TOut, TScope> {\n    this.cursor.subflowBranch(id, subflow, mountName, options);\n    return this;\n  }\n\n  addLazySubFlowChartBranch(\n    id: string,\n    resolver: () => FlowChart<any, any>,\n    mountName?: string,\n    options?: SubflowMountOptions,\n  ): SelectorFnList<TOut, TScope> {\n    this.cursor.lazySubflowBranch(id, resolver, mountName, options);\n    return this;\n  }\n\n  addBranchList(\n    branches: Array<{\n      id: string;\n      name: string;\n      fn?: StageFunction<TOut, TScope>;\n    }>,\n  ): SelectorFnList<TOut, TScope> {\n    for (const { id, name, fn } of branches) {\n      this.addFunctionBranch(id, name, fn);\n    }\n    return this;\n  }\n\n  end(): FlowChartBuilder<TOut, TScope> {\n    return this.cursor.finish();\n  }\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// FlowChartBuilder\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport class FlowChartBuilder<TOut = any, TScope = any> {\n  private _root?: StageNode<TOut, TScope>;\n  private _rootSpec?: SerializedPipelineStructure;\n  private _cursor?: StageNode<TOut, TScope>;\n  private _cursorSpec?: SerializedPipelineStructure;\n  private _stageMap = new Map<string, StageFunction<TOut, TScope>>();\n  _subflowDefs = new Map<string, { root: StageNode<TOut, TScope> }>();\n  private _streamHandlers: StreamHandlers = {};\n  /**\n   * L7.3 — Build-time observer fan-out. Owned by the builder so every\n   * `addX()` method can fire `StructureRecorder` events at the natural\n   * moment of the corresponding mutation. Dispatcher is allocated\n   * lazily on first attach to keep the zero-recorder path allocation-\n   * free.\n   */\n  private _structureDispatcher?: StructureRecorderDispatcher;\n  /**\n   * L7.3 — Sealed-after-build flag (Panel 2 phase invariant). Flips\n   * to `true` when `.build()` returns; subsequent `attachStructureRecorder`\n   * throws. Prevents the footgun where a consumer attaches a recorder\n   * mid-execution and gets partial structure data (missed every event\n   * already fired during construction).\n   */\n  private _sealed = false;\n  private _enableNarrative = false;\n  private _logger?: ILogger;\n  private _descriptionParts: string[] = [];\n  private _stepCounter = 0;\n  // NOTE: keyed by stage name (for human-readable descriptions), while stageMap\n  // and knownStageIds use id (stable identifier). These are intentionally different\n  // namespaces — descriptions are presentational, lookups are structural.\n  private _stageDescriptions = new Map<string, string>();\n  private _stageStepMap = new Map<string, number>();\n  private _knownStageIds = new Set<string>();\n  private _inputSchema?: unknown;\n  private _outputSchema?: unknown;\n  private _outputMapper?: (finalScope: Record<string, unknown>) => unknown;\n  private _scopeFactory?: ScopeFactory<TScope>;\n\n  // ── L7.3 — StructureRecorder attach + dispatch helpers ──────────────────\n\n  /**\n   * Attach a `StructureRecorder` for build-phase observation. Multiple\n   * recorders coexist (same id allowed; iteration order = attach\n   * order). Throws if called after `.build()` — the chart is sealed at\n   * that point and any recorder attached late would miss every event\n   * fired during construction.\n   *\n   * **Seed replay**: when this is called AFTER `start()` has already\n   * fired (i.e., after the `flowChart()` factory returns), the\n   * just-attached recorder receives a one-time `onStageAdded` for the\n   * root stage so it observes the seed. Only the new recorder sees\n   * the replay; already-attached recorders are not re-fired.\n   *\n   * **Mid-chain attach caveat**: a recorder attached AFTER one or more\n   * `addX()` calls receives the seed replay but MISSES every\n   * intermediate event. Attach BEFORE the first `addX()` for complete\n   * capture.\n   *\n   * Public for now to enable direct attach in tests + early consumers.\n   * L7.4 will wire `flowChart(..., { structureRecorders: [...] })` as\n   * an additional registration site; this method will remain.\n   */\n  attachStructureRecorder(recorder: StructureRecorder): this {\n    if (this._sealed) {\n      throw new Error(\n        `[FlowChartBuilder] attachStructureRecorder('${recorder.id}') called after .build() — chart is sealed; ` +\n          'the recorder would miss every structure event from construction. Attach BEFORE .build().',\n      );\n    }\n    if (!this._structureDispatcher) {\n      this._structureDispatcher = new StructureRecorderDispatcher();\n    }\n    this._structureDispatcher.attach(recorder);\n    // The seed fires inside `start()` — that runs BEFORE the consumer\n    // can post-construct attach. Replay the seed event ONLY into the\n    // just-attached recorder so other already-attached recorders don't\n    // see a duplicate. Errors are routed through the dispatcher's\n    // accumulator so the contract stays uniform.\n    if (this._rootSpec) {\n      try {\n        recorder.onStageAdded?.({\n          stageId: this._rootSpec.id,\n          name: this._rootSpec.name,\n          type: this._rootSpec.type ?? 'stage',\n          ...(this._rootSpec.isPausable === true && { isPausable: true }),\n          ...(this._rootSpec.tags !== undefined && { tags: [...this._rootSpec.tags] }),\n          spec: this._rootSpec as unknown as FlowChartSpec,\n        });\n      } catch (err) {\n        this._structureDispatcher.recordErrorForReplay(recorder.id, 'onStageAdded', err);\n      }\n    }\n    return this;\n  }\n\n  /**\n   * Inspect accumulated `StructureBuildError`s. Returns empty array\n   * when no recorders attached OR no errors occurred. Returns a\n   * defensive copy — caller mutations do not affect subsequent calls.\n   *\n   * **Call on the BUILDER, not the chart returned by `.build()`.**\n   * Capture the builder reference before `.build()` if you need\n   * post-build access:\n   * ```ts\n   * const builder = flowChart(...).attachStructureRecorder(rec);\n   * const chart = builder.build();\n   * const errors = builder.getStructureBuildErrors();\n   * ```\n   */\n  getStructureBuildErrors(): ReturnType<StructureRecorderDispatcher['getErrors']> {\n    return this._structureDispatcher?.getErrors() ?? [];\n  }\n\n  // Convenience fire helpers — no-op when no dispatcher attached. Keeps\n  // every call site a one-liner without the `if (this._structureDispatcher)`\n  // boilerplate everywhere.\n  private _fireStageAdded(spec: SerializedPipelineStructure): void {\n    if (!this._structureDispatcher) return;\n    // Read `isPausable` directly from the spec — single source of truth.\n    // The previous `extras` argument was a sub-builder footgun: branch\n    // helpers in DeciderList/SelectorFnList went through\n    // `_fireStageAddedFromSubBuilder` which dropped the extras, silently\n    // losing `isPausable: true` on pausable decider/selector branches.\n    const isPausable = spec.isPausable === true;\n    this._structureDispatcher.fireStageAdded({\n      stageId: spec.id,\n      name: spec.name,\n      type: spec.type ?? 'stage',\n      ...(isPausable && { isPausable: true }),\n      ...(spec.tags !== undefined && { tags: [...spec.tags] }),\n      spec: spec as unknown as FlowChartSpec,\n    });\n  }\n\n  private _fireStageTagged(spec: SerializedPipelineStructure): void {\n    if (!this._structureDispatcher || spec.tags === undefined) return;\n    this._structureDispatcher.fireStageTagged({\n      stageId: spec.id,\n      name: spec.name,\n      tags: [...spec.tags],\n      spec: spec as unknown as FlowChartSpec,\n    });\n  }\n\n  private _fireEdgeAdded(from: string, to: string, kind: StructureEdgeKind, label?: string): void {\n    if (!this._structureDispatcher) return;\n    this._structureDispatcher.fireEdgeAdded({\n      from,\n      to,\n      kind,\n      ...(label !== undefined && { label }),\n    });\n  }\n\n  private _fireLoopEdgeAdded(from: string, to: string): void {\n    if (!this._structureDispatcher) return;\n    this._structureDispatcher.fireLoopEdgeAdded({ from, to });\n  }\n\n  /**\n   * Fire the `next` edge(s) from a parent spec to a freshly-added\n   * node — with convergence expansion when the parent is a\n   * fork / decider / selector with branches.\n   *\n   * A fork at `parent` is semantically `parent ──fork-branch──► child[i]`\n   * for each child, and the chained `.addFunction(X)` continues\n   * AFTER the fork converges. The runtime semantics are that each\n   * child INDEPENDENTLY feeds `X` (parallel completion → join). The\n   * literal \"edge from parent to X\" would misrepresent this —\n   * visualizers and topological algorithms would see one edge where\n   * there should be N convergence edges.\n   *\n   * Fix: when `parentSpec` has branch children (fork or branched\n   * decider/selector), fire one `next` edge from EACH child to the\n   * target. Otherwise fire the single edge from `parentSpec` itself.\n   *\n   * Loop-reference children (synthetic spec nodes created by\n   * `.loopTo()`) are excluded — they're back-edge markers, not\n   * convergence sources. A branch that carries an OWN loop-back `next`\n   * (a branch-sourced `loopTo`) is likewise skipped — it loops, it does\n   * not converge at the linear next stage.\n   *\n   * A branch carrying `convergeAt` is REDIRECTED: its single convergence\n   * edge fires to its named target instead of `targetId` — expressing an\n   * unequal-depth merge (e.g. `tools → call-llm`, bypassing `message-api`).\n   * The named target is a forward stage, so it is NOT validated here.\n   *\n   * Call ORDER constraint: must be called BEFORE the cursor advances\n   * to the new target. The caller passes the PRE-ADVANCE parent spec.\n   */\n  private _fireNextEdgeFromParent(parentSpec: SerializedPipelineStructure, targetId: string, label?: string): void {\n    if (!this._structureDispatcher) return;\n    const childSpecs = parentSpec.children;\n    const isBranchingParent =\n      (parentSpec.type === 'fork' || parentSpec.type === 'decider' || parentSpec.type === 'selector') &&\n      Array.isArray(childSpecs) &&\n      childSpecs.length > 0;\n    if (!isBranchingParent) {\n      this._fireEdgeAdded(parentSpec.id, targetId, 'next', label);\n      return;\n    }\n    for (const child of childSpecs!) {\n      if (child.isLoopReference) continue;\n      // A branch with its own loop-back next (branch-sourced loopTo) loops —\n      // it does not converge at the linear next stage.\n      if (child.next?.isLoopReference) continue;\n      if (child.convergeAt) {\n        // Redirected convergence: this branch rejoins at its named target.\n        this._fireEdgeAdded(child.id, child.convergeAt, 'next');\n        continue;\n      }\n      this._fireEdgeAdded(child.id, targetId, 'next', label);\n    }\n  }\n\n  private _fireDeciderComplete(\n    decider: string,\n    type: 'decider' | 'selector',\n    branchIds: string[],\n    defaultBranch?: string,\n  ): void {\n    if (!this._structureDispatcher) return;\n    this._structureDispatcher.fireDeciderComplete({\n      decider,\n      type,\n      branchIds,\n      ...(defaultBranch !== undefined && { defaultBranch }),\n    });\n  }\n\n  private _fireSubflowMounted(\n    subflowId: string,\n    subflowName: string,\n    rootStageId: string,\n    isLazy?: boolean,\n    subflowSpec?: SerializedPipelineStructure,\n    subflowPath?: string,\n  ): void {\n    if (!this._structureDispatcher) return;\n    // subflowPath defaults to subflowId when the recorder is attached\n    // to the immediate parent (top-level mount); composed paths apply\n    // only when this builder is itself a nested subflow being\n    // observed by the grandparent's recorder.\n    const path = subflowPath ?? subflowId;\n    this._structureDispatcher.fireSubflowMounted({\n      subflowId,\n      subflowName,\n      rootStageId,\n      ...(isLazy === true && { isLazy }),\n      ...(subflowSpec !== undefined && { subflowSpec }),\n      subflowPath: path,\n    });\n  }\n\n  /** Sub-builder access (`.b._fireXxx`) is needed by DeciderList /\n   *  SelectorFnList; expose the dispatcher through internal helpers\n   *  that go through the same no-op-when-absent guard.\n   *\n   *  @internal — these methods are exposed because TypeScript `private`\n   *  doesn't traverse class boundaries. Consumer code MUST NOT call\n   *  them; calling them post-construction lets a hostile caller\n   *  fabricate structure events and corrupt downstream visualizations\n   *  or audit trails. The `_` prefix is intentional convention. */\n  _fireEdgeAddedFromSubBuilder(from: string, to: string, kind: StructureEdgeKind, label?: string): void {\n    this._fireEdgeAdded(from, to, kind, label);\n  }\n\n  /** @internal — see `_fireEdgeAddedFromSubBuilder`. */\n  _fireStageAddedFromSubBuilder(spec: SerializedPipelineStructure): void {\n    this._fireStageAdded(spec);\n  }\n\n  /** @internal — see `_fireEdgeAddedFromSubBuilder`. */\n  _fireDeciderCompleteFromSubBuilder(\n    decider: string,\n    type: 'decider' | 'selector',\n    branchIds: string[],\n    defaultBranch?: string,\n  ): void {\n    this._fireDeciderComplete(decider, type, branchIds, defaultBranch);\n  }\n\n  /** @internal — see `_fireEdgeAddedFromSubBuilder`. */\n  _fireSubflowMountedFromSubBuilder(\n    subflowId: string,\n    subflowName: string,\n    rootStageId: string,\n    isLazy?: boolean,\n    subflowSpec?: SerializedPipelineStructure,\n    subflowPath?: string,\n  ): void {\n    this._fireSubflowMounted(subflowId, subflowName, rootStageId, isLazy, subflowSpec, subflowPath);\n  }\n\n  /** @internal — see `_fireEdgeAddedFromSubBuilder`. Used by `DeciderList.loopTo`\n   *  to validate a branch-sourced loop target against the known stage ids\n   *  (mirrors `FlowChartBuilder.loopTo`'s `_knownStageIds.has` guard). */\n  _knownStageIdsHas(id: string): boolean {\n    return this._knownStageIds.has(id);\n  }\n\n  /** @internal — see `_fireEdgeAddedFromSubBuilder`. Used by `DeciderList.loopTo`\n   *  to fire a loop back-edge SOURCED FROM A BRANCH node (not the decider). */\n  _fireLoopEdgeAddedFromSubBuilder(from: string, to: string): void {\n    this._fireLoopEdgeAdded(from, to);\n  }\n\n  // ── Description helpers ──\n\n  private _appendDescriptionLine(name: string, description?: string): void {\n    this._stepCounter++;\n    this._stageStepMap.set(name, this._stepCounter);\n    const line = description ? `${this._stepCounter}. ${name} — ${description}` : `${this._stepCounter}. ${name}`;\n    this._descriptionParts.push(line);\n    if (description) {\n      this._stageDescriptions.set(name, description);\n    }\n  }\n\n  private _appendSubflowDescription(id: string, name: string, subflow: FlowChart<any, any>): void {\n    this._stepCounter++;\n    this._stageStepMap.set(id, this._stepCounter);\n    if (subflow.description) {\n      const lines = subflow.description.split('\\n');\n      const stepsIdx = lines.findIndex((l) => l.startsWith('Steps:'));\n      if (stepsIdx >= 0) {\n        // Builder-composed description (`FlowChart: X\\nSteps:\\n...`).\n        // Inline ONLY the summary above `Steps:` on the mount line, then\n        // re-list the step lines once, indented. Embedding the FULL inner\n        // description here AND re-listing its steps doubled the text per\n        // nesting level — exponential growth, RangeError (\"Invalid string\n        // length\") at ~22 nesting levels of nested build().\n        const summary = lines.slice(0, stepsIdx).join(' ').trim();\n        this._descriptionParts.push(\n          summary\n            ? `${this._stepCounter}. [Sub-Execution: ${name}] — ${summary}`\n            : `${this._stepCounter}. [Sub-Execution: ${name}]`,\n        );\n        for (let i = stepsIdx + 1; i < lines.length; i++) {\n          if (lines[i].trim()) this._descriptionParts.push(`   ${lines[i]}`);\n        }\n      } else {\n        // Free-form (single-block) description — inline it whole, unchanged.\n        this._descriptionParts.push(`${this._stepCounter}. [Sub-Execution: ${name}] — ${subflow.description}`);\n      }\n    } else {\n      this._descriptionParts.push(`${this._stepCounter}. [Sub-Execution: ${name}]`);\n    }\n  }\n\n  // ── Configuration ──\n\n  setLogger(logger: ILogger): this {\n    this._logger = logger;\n    return this;\n  }\n\n  /**\n   * Declare the API contract — input validation, output shape, and output mapper.\n   * Replaces setInputSchema() + setOutputSchema() + setOutputMapper() in a single call.\n   *\n   * If a contract with input schema is declared, chart.run() validates input automatically.\n   * Contract data is used by chart.toOpenAPI() and chart.toMCPTool().\n   */\n  contract(opts: {\n    input?: unknown;\n    output?: unknown;\n    mapper?: (finalScope: Record<string, unknown>) => unknown;\n  }): this {\n    if (opts.input) this._inputSchema = opts.input;\n    if (opts.output) this._outputSchema = opts.output;\n    if (opts.mapper) this._outputMapper = opts.mapper;\n    return this;\n  }\n\n  // ── Linear Chaining ──\n\n  start(\n    name: string,\n    fn: StageFunction<TOut, TScope> | PausableHandler<TScope>,\n    id: string,\n    description?: string,\n    options?: { retry?: RetryPolicy; touches?: StageTouches; tags?: readonly string[] },\n  ): this {\n    admitId('stage id', id, 'stage');\n    if (this._root) fail('root already defined; create a new builder');\n\n    // Detect PausableHandler by duck-typing (has .execute property)\n    // eslint-disable-next-line no-restricted-syntax\n    const isPausable = typeof fn === 'object' && fn !== null && 'execute' in fn;\n    const stageFn = isPausable\n      ? ((fn as PausableHandler<TScope>).execute as StageFunction<TOut, TScope>)\n      : (fn as StageFunction<TOut, TScope>);\n\n    const node: StageNode<TOut, TScope> = { name, id, fn: stageFn };\n    if (isPausable) {\n      node.isPausable = true;\n      node.resumeFn = (fn as PausableHandler<TScope>).resume;\n    }\n    if (description) node.description = description;\n    this._addToMap(id, stageFn);\n\n    const spec: SerializedPipelineStructure = { name, id, type: 'stage' };\n    if (isPausable) spec.isPausable = true;\n    if (description) spec.description = description;\n    applyRetryPolicy(node, spec, options?.retry, `start('${id}')`);\n    applyTouches(node, spec, options?.touches, `start('${id}')`);\n    applyTags(node, spec, options?.tags, `start('${id}')`);\n\n    this._root = node;\n    this._rootSpec = spec;\n    this._cursor = node;\n    this._advanceCursorSpec(spec);\n    this._knownStageIds.add(id);\n\n    // L7.3 — Seed node fires `onStageAdded` (no edge — no predecessor).\n    // `isPausable` is read directly from the spec by `_fireStageAdded`.\n    this._fireStageAdded(spec);\n\n    this._appendDescriptionLine(name, description);\n    return this;\n  }\n\n  /**\n   * Start a chart whose ROOT stage IS a selector — it runs first (reading\n   * args, seeding state, returning the chosen branch ids via `select()`),\n   * and its branches attach directly to the root. Mirrors `start()` for the\n   * root-node setup, then returns a `SelectorFnList` bound to the root so\n   * `.addFunctionBranch()` / `.addSubFlowChartBranch()` / `.end()` work\n   * exactly as they do after `addSelectorFunction()`.\n   *\n   * Use when the first thing a chart does is choose among branches — e.g. a\n   * `Context` selector that inits + picks which context slots to engineer,\n   * with no separate seed stage before it.\n   */\n  startSelector(\n    name: string,\n    fn: StageFunction<any, TScope>,\n    id: string,\n    description?: string,\n    options?: { failFast?: boolean; retry?: RetryPolicy; touches?: StageTouches; tags?: readonly string[] },\n  ): SelectorFnList<TOut, TScope> {\n    admitId('stage id', id, 'stage');\n    if (this._root) fail('root already defined; create a new builder');\n\n    const node: StageNode<TOut, TScope> = { name, id, fn: fn as StageFunction<TOut, TScope> };\n    if (description) node.description = description;\n    // See `addSelectorFunction` — `failFast: true` makes a multi-branch\n    // selection fan out via `Promise.all` (first error aborts) instead of the\n    // default `Promise.allSettled` (best-effort).\n    if (options?.failFast) node.failFast = true;\n    this._addToMap(id, fn as StageFunction<TOut, TScope>);\n\n    const spec: SerializedPipelineStructure = { name, id, type: 'stage', hasSelector: true };\n    if (description) spec.description = description;\n    applyRetryPolicy(node, spec, options?.retry, `startSelector('${id}')`);\n    applyTouches(node, spec, options?.touches, `startSelector('${id}')`);\n    applyTags(node, spec, options?.tags, `startSelector('${id}')`);\n\n    this._root = node;\n    this._rootSpec = spec;\n    this._cursor = node;\n    this._advanceCursorSpec(spec);\n    this._knownStageIds.add(id);\n\n    // Root selector node fires onStageAdded with NO predecessor edge (it's\n    // the root). Branches + onDeciderComplete come from the SelectorFnList.\n    this._fireStageAdded(spec);\n\n    this._stepCounter++;\n    this._stageStepMap.set(name, this._stepCounter);\n    this._appendDescriptionLine(name, description);\n\n    return new SelectorFnList<TOut, TScope>(\n      this,\n      node,\n      spec,\n      this._descriptionParts,\n      this._stageDescriptions,\n      this._stepCounter,\n      description,\n    );\n  }\n\n  addFunction(name: string, fn: StageFunction<TOut, TScope>, id: string, description?: string): this {\n    admitId('stage id', id, 'stage');\n    const cur = this._needCursor();\n    const curSpec = this._needCursorSpec();\n    // Capture the parent SPEC reference (not just id) BEFORE the\n    // cursor advances — we need its `children` + `type` to decide\n    // whether the `next` edge is a fork convergence (N edges from\n    // each branch child) vs a plain linear chain (1 edge from parent).\n    const parentSpec = curSpec;\n\n    const node: StageNode<TOut, TScope> = { name, id, fn };\n    if (description) node.description = description;\n    this._addToMap(id, fn);\n\n    const spec: SerializedPipelineStructure = { name, id, type: 'stage' };\n    if (description) spec.description = description;\n\n    cur.next = node;\n    curSpec.next = spec;\n    this._cursor = node;\n    this._advanceCursorSpec(spec);\n    this._knownStageIds.add(id);\n\n    // L7.3 — Linear node: announce the node first, then the edge\n    // from the prior cursor. Order matters: endpoints announced\n    // before any edge referencing them (StructureRecorder contract).\n    this._fireStageAdded(spec);\n    this._fireNextEdgeFromParent(parentSpec, id);\n\n    this._appendDescriptionLine(name, description);\n    return this;\n  }\n\n  /** Compose a keyed outside operation, reconciliation, shared retry decision and wait as ordinary chart nodes. */\n  addRetryLoop<TValue = unknown>(id: string, options: RetryLoopOptions<TScope, TValue>): this {\n    this._needCursor();\n    for (const stageId of [id, `${id}-reconcile`, `${id}-decide`, `${id}-retry`, `${id}-done`, `${id}-stop`]) {\n      admitId('retry loop stage id', stageId, 'stage');\n      if (this._idTaken(stageId)) fail(`retry loop stage id '${stageId}' already exists`);\n    }\n    appendRetryLoop(this, id, options, (budget, branch) => {\n      const cursor = this._needCursor();\n      const node = branch === undefined ? cursor : cursor.children?.find((child) => child.id === branch);\n      const spec =\n        branch === undefined\n          ? this._needCursorSpec()\n          : this._needCursorSpec().children?.find((child) => child.id === branch);\n      if (node === undefined || spec === undefined) fail('retry loop budget node missing');\n      declareRetryLoopBudget(node!, budget);\n      if (budget.timeoutMs !== undefined) spec!.timeoutMs = budget.timeoutMs;\n    });\n    return this;\n  }\n\n  addStreamingFunction(\n    name: string,\n    fn: StageFunction<TOut, TScope>,\n    id: string,\n    streamId?: string,\n    description?: string,\n  ): this {\n    admitId('stage id', id, 'stage');\n    const cur = this._needCursor();\n    const curSpec = this._needCursorSpec();\n    const parentSpec = curSpec;\n\n    const node: StageNode<TOut, TScope> = {\n      name,\n      id,\n      fn,\n      isStreaming: true,\n      streamId: streamId ?? name,\n    };\n    if (description) node.description = description;\n    this._addToMap(id, fn);\n\n    const spec: SerializedPipelineStructure = {\n      name,\n      id,\n      type: 'streaming',\n      isStreaming: true,\n      streamId: streamId ?? name,\n    };\n    if (description) spec.description = description;\n\n    cur.next = node;\n    curSpec.next = spec;\n    this._cursor = node;\n    this._advanceCursorSpec(spec);\n    this._knownStageIds.add(id);\n\n    // L7.3 — Streaming stage: same shape as linear addFunction.\n    this._fireStageAdded(spec);\n    this._fireNextEdgeFromParent(parentSpec, id);\n\n    this._appendDescriptionLine(name, description);\n    return this;\n  }\n\n  /**\n   * Add a pausable stage — can pause execution and resume later with input.\n   *\n   * The handler has two phases:\n   * - `execute`: runs first time. Return any non-void value to pause (it becomes\n   *   the checkpoint's `pauseData`); return void/undefined to continue normally.\n   * - `resume`: runs when the flowchart is resumed with input.\n   *\n   * @example\n   * ```typescript\n   * .addPausableFunction('ApproveOrder', {\n   *   execute: async (scope) => {\n   *     scope.orderId = '123';\n   *     return { question: 'Approve?' };\n   *   },\n   *   resume: async (scope, input) => {\n   *     scope.approved = input.approved;\n   *   },\n   * }, 'approve-order', 'Manager approval gate')\n   * ```\n   */\n  addPausableFunction(name: string, handler: PausableHandler<TScope>, id: string, description?: string): this {\n    admitId('stage id', id, 'stage');\n    const cur = this._needCursor();\n    const curSpec = this._needCursorSpec();\n    const parentSpec = curSpec;\n\n    const node: StageNode<TOut, TScope> = {\n      name,\n      id,\n      fn: handler.execute as StageFunction<TOut, TScope>,\n      isPausable: true,\n      resumeFn: handler.resume,\n    };\n    if (description) node.description = description;\n    this._addToMap(id, handler.execute as StageFunction<TOut, TScope>);\n\n    const spec: SerializedPipelineStructure = {\n      name,\n      id,\n      type: 'stage',\n      isPausable: true,\n    };\n    if (description) spec.description = description;\n\n    cur.next = node;\n    curSpec.next = spec;\n    this._cursor = node;\n    this._advanceCursorSpec(spec);\n    this._knownStageIds.add(id);\n\n    // L7.3 — Pausable stage: `_fireStageAdded` reads `isPausable`\n    // directly from `spec.isPausable` (set above), so visualisers\n    // see it on the event payload without a separate threading arg.\n    this._fireStageAdded(spec);\n    this._fireNextEdgeFromParent(parentSpec, id);\n\n    this._appendDescriptionLine(name, description);\n    return this;\n  }\n\n  // ── Detach (builder-native composition) ──\n  //\n  // Sugar over `addFunction` that generates a stage which calls\n  // `scope.$detachAndForget(...)` or `scope.$detachAndJoinLater(...)`\n  // at runtime. ZERO engine changes — pure composition over the\n  // existing scope-method primitives.\n  //\n  // For `addDetachAndJoinLater`, the returned handle is stored in\n  // shared state via `$setValue` (which bypasses the typed-proxy\n  // unwrap that would otherwise strip the handle's class methods).\n  // Downstream stages read it via `scope[options.handleKey]` or\n  // `scope.$getValue(options.handleKey)` — both preserve methods\n  // because the value was stored raw.\n\n  /**\n   * Add a stage that fires a child flowchart on the given driver and\n   * DISCARDS the handle. Pure fire-and-forget — useful for telemetry\n   * exports, audit log shipping, cache warm-up.\n   *\n   * @param id Stable id for this stage (also the stageMap key).\n   * @param child The child flowchart to detach.\n   * @param options.driver The driver to schedule on (e.g. `microtaskBatchDriver`).\n   * @param options.inputMapper Maps the parent's scope to the child's input.\n   *   Defaults to passing `undefined`.\n   * @param options.mountName Display name; defaults to `id`.\n   * @param options.description Stage description for narrative + tools.\n   *\n   * @example\n   * ```ts\n   * import { microtaskBatchDriver } from 'footprintjs/detach';\n   *\n   * flowChart('process', processFn, 'process')\n   *   .addDetachAndForget('telemetry', telemetryChart, {\n   *     driver: microtaskBatchDriver,\n   *     inputMapper: (scope) => ({ event: 'processed', orderId: scope.orderId }),\n   *   })\n   *   .addFunction('next', nextFn, 'next')\n   *   .build();\n   * ```\n   */\n  addDetachAndForget(\n    id: string,\n    child: import('./types.js').FlowChart<any, any>,\n    options: {\n      driver: import('../detach/types.js').DetachDriver;\n      inputMapper?: (scope: TScope) => unknown;\n      mountName?: string;\n      description?: string;\n    },\n  ): this {\n    const name = options.mountName ?? id;\n    return this.addFunction(\n      name,\n      ((scope: any) => {\n        const input = options.inputMapper ? options.inputMapper(scope as TScope) : undefined;\n        scope.$detachAndForget(options.driver, child, input);\n      }) as StageFunction<TOut, TScope>,\n      id,\n      options.description,\n    );\n  }\n\n  /**\n   * Add a stage that fires a child flowchart on the given driver and\n   * delivers the resulting `DetachHandle` to a consumer-supplied\n   * `onHandle` callback. The handle CANNOT be stored in shared state\n   * — `StageContext.setValue` calls `structuredClone` which drops\n   * class prototypes (and therefore the handle's `.wait()` method).\n   *\n   * The callback pattern is the explicit alternative: keep handles in\n   * a closure-local array (or whatever shape suits) and have a\n   * downstream stage `await Promise.all(...)` over them.\n   *\n   * @example\n   * ```ts\n   * import { microtaskBatchDriver } from 'footprintjs/detach';\n   * import type { DetachHandle } from 'footprintjs/detach';\n   *\n   * const handles: DetachHandle[] = [];\n   *\n   * const chart = flowChart('seed', seedFn, 'seed')\n   *   .addDetachAndJoinLater('eval-a', evalChart, {\n   *     driver: microtaskBatchDriver,\n   *     inputMapper: (scope) => scope.configA,\n   *     onHandle: (h) => handles.push(h),\n   *   })\n   *   .addDetachAndJoinLater('eval-b', evalChart, {\n   *     driver: microtaskBatchDriver,\n   *     inputMapper: (scope) => scope.configB,\n   *     onHandle: (h) => handles.push(h),\n   *   })\n   *   .addFunction('join', async (scope) => {\n   *     const settled = await Promise.all(handles.map((h) => h.wait()));\n   *     scope.results = settled;\n   *   }, 'join')\n   *   .build();\n   * ```\n   *\n   * Note: putting `handles` in a module-level closure is fine for\n   * single-run scripts. For server code that runs the same chart\n   * concurrently across requests, allocate a new closure per run\n   * (e.g., wrap chart construction in a factory function) so handles\n   * from different runs don't bleed into each other.\n   */\n  addDetachAndJoinLater(\n    id: string,\n    child: import('./types.js').FlowChart<any, any>,\n    options: {\n      driver: import('../detach/types.js').DetachDriver;\n      onHandle: (handle: import('../detach/types.js').DetachHandle) => void;\n      inputMapper?: (scope: TScope) => unknown;\n      mountName?: string;\n      description?: string;\n    },\n  ): this {\n    const name = options.mountName ?? id;\n    return this.addFunction(\n      name,\n      ((scope: any) => {\n        const input = options.inputMapper ? options.inputMapper(scope as TScope) : undefined;\n        const handle = scope.$detachAndJoinLater(options.driver, child, input);\n        options.onHandle(handle);\n      }) as StageFunction<TOut, TScope>,\n      id,\n      options.description,\n    );\n  }\n\n  // ── Branching ──\n\n  addDeciderFunction(\n    name: string,\n    fn: StageFunction<any, TScope>,\n    id: string,\n    description?: string,\n    /** `{ retry }` gives the DECIDER STAGE a retry policy. Declared here rather\n     *  than via `.retry()` because this method returns a `DeciderList`, where a\n     *  chained modifier could mean the decider OR the branch just added;\n     *  `{ tags }` likewise. */\n    options?: { retry?: RetryPolicy; touches?: StageTouches; tags?: readonly string[] },\n  ): DeciderList<TOut, TScope> {\n    admitId('stage id', id, 'stage');\n    const cur = this._needCursor();\n    const curSpec = this._needCursorSpec();\n    const parentSpec = curSpec;\n\n    // No dispatcher guard on `cur`: after `.end()` the cursor IS the closed\n    // decider/selector, and this decider is a NEW node at its `next` (a chain\n    // of dispatchers). Re-opening the SAME dispatcher is `BranchCursor · assertOpen`'s refusal.\n    const node: StageNode<TOut, TScope> = { name, id, fn };\n    if (description) node.description = description;\n    this._addToMap(id, fn);\n\n    const spec: SerializedPipelineStructure = { name, id, type: 'stage', hasDecider: true };\n    if (description) spec.description = description;\n    applyRetryPolicy(node, spec, options?.retry, `addDeciderFunction('${id}')`);\n    applyTouches(node, spec, options?.touches, `addDeciderFunction('${id}')`);\n    applyTags(node, spec, options?.tags, `addDeciderFunction('${id}')`);\n\n    cur.next = node;\n    curSpec.next = spec;\n    this._cursor = node;\n    this._advanceCursorSpec(spec);\n    this._knownStageIds.add(id);\n\n    // L7.3 — Decider node is reached via a `next` edge from the prior\n    // cursor. Branches themselves fire via `addFunctionBranch` etc.\n    // `onDeciderComplete` fires from sub-builder `.end()`.\n    this._fireStageAdded(spec);\n    this._fireNextEdgeFromParent(parentSpec, id);\n\n    this._stepCounter++;\n    this._stageStepMap.set(name, this._stepCounter);\n\n    return new DeciderList<TOut, TScope>(\n      this,\n      node,\n      spec,\n      this._descriptionParts,\n      this._stageDescriptions,\n      this._stepCounter,\n      description,\n    );\n  }\n\n  addSelectorFunction(\n    name: string,\n    fn: StageFunction<any, TScope>,\n    id: string,\n    description?: string,\n    /** `{ retry }` gives the SELECTOR STAGE a retry policy — same reasoning as\n     *  `addDeciderFunction`: this method returns a sub-builder, so a chained\n     *  `.retry()` would be ambiguous; `{ tags }` likewise. */\n    options?: { failFast?: boolean; retry?: RetryPolicy; touches?: StageTouches; tags?: readonly string[] },\n  ): SelectorFnList<TOut, TScope> {\n    admitId('stage id', id, 'stage');\n    const cur = this._needCursor();\n    const curSpec = this._needCursorSpec();\n    const parentSpec = curSpec;\n\n    // No dispatcher guard on `cur` — see `addDeciderFunction`.\n    const node: StageNode<TOut, TScope> = { name, id, fn };\n    if (description) node.description = description;\n    // `failFast`: when the selector picks ≥2 branches they fan out in parallel\n    // via ChildrenExecutor. Default = `Promise.allSettled` (best-effort: every\n    // branch runs to completion even if some fail). `failFast: true` = `Promise.all`\n    // (the first branch error rejects + aborts) — use when ALL selected branches\n    // are REQUIRED (e.g. assembling a request from independent-but-required parts),\n    // not best-effort fan-out. Same flag `addListOfFunction` exposes.\n    if (options?.failFast) node.failFast = true;\n    this._addToMap(id, fn);\n\n    const spec: SerializedPipelineStructure = { name, id, type: 'stage', hasSelector: true };\n    if (description) spec.description = description;\n    applyRetryPolicy(node, spec, options?.retry, `addSelectorFunction('${id}')`);\n    applyTouches(node, spec, options?.touches, `addSelectorFunction('${id}')`);\n    applyTags(node, spec, options?.tags, `addSelectorFunction('${id}')`);\n\n    cur.next = node;\n    curSpec.next = spec;\n    this._cursor = node;\n    this._advanceCursorSpec(spec);\n    this._knownStageIds.add(id);\n\n    // L7.3 — Selector node: same as decider. Branches + complete event\n    // come from the SelectorFnList sub-builder.\n    this._fireStageAdded(spec);\n    this._fireNextEdgeFromParent(parentSpec, id);\n\n    this._stepCounter++;\n    this._stageStepMap.set(name, this._stepCounter);\n\n    return new SelectorFnList<TOut, TScope>(\n      this,\n      node,\n      spec,\n      this._descriptionParts,\n      this._stageDescriptions,\n      this._stepCounter,\n      description,\n    );\n  }\n\n  // ── Parallel (Fork) ──\n\n  addListOfFunction(children: SimplifiedParallelSpec<TOut, TScope>[], options?: { failFast?: boolean }): this {\n    const { cur, curSpec } = this._needForkParent();\n    const forkId = cur.id;\n\n    curSpec.type = 'fork';\n    if (options?.failFast) cur.failFast = true;\n\n    for (const { id, name, fn, retry, touches, tags } of children) {\n      if (!id) fail(`child id required under '${cur.name}'`);\n      admitId('fork child id', id, 'stage');\n      if (cur.children?.some((c) => c.id === id)) {\n        fail(`duplicate child id '${id}' under '${cur.name}'`);\n      }\n\n      const node: StageNode<TOut, TScope> = { name: name ?? id, id };\n      if (fn) {\n        node.fn = fn;\n      }\n      this._registerStage(id, fn);\n\n      const spec: SerializedPipelineStructure = {\n        name: name ?? id,\n        id,\n        type: 'stage',\n        isParallelChild: true,\n        parallelGroupId: forkId,\n      };\n      applyRetryPolicy(node, spec, retry, `addListOfFunction child '${id}'`);\n      applyTouches(node, spec, touches, `addListOfFunction child '${id}'`);\n      applyTags(node, spec, tags, `addListOfFunction child '${id}'`);\n\n      cur.children = cur.children || [];\n      cur.children.push(node);\n      curSpec.children = curSpec.children || [];\n      curSpec.children.push(spec);\n      // L7.3 — fire structure events for the child + the fork edge.\n      this._fireStageAdded(spec);\n      this._fireEdgeAdded(curSpec.id, spec.id, 'fork-branch');\n    }\n\n    const childNames = children.map((c) => c.name || c.id).join(', ');\n    this._stepCounter++;\n    this._descriptionParts.push(`${this._stepCounter}. Runs in parallel: ${childNames}`);\n\n    this._cursorTail = `the parallel children (${childNames})`;\n    return this;\n  }\n\n  /**\n   * Run ONE BRANCH PER ITEM, in parallel — with the number of branches decided\n   * at RUN time from the payload rather than at build time.\n   *\n   * `addListOfFunction` fans out a fixed set of branches you name in the chart.\n   * This fans out over data the chart has not seen yet: three chunks make three\n   * branches, ten make ten. Each branch runs as its own isolated subflow — its\n   * own memory, its own commit log, addressable in every trace query at\n   * `<stageId>~<index>` — so branches cannot corrupt each other's in-flight\n   * state, and a backward slice through a branch result works with no special\n   * handling. Design: docs/design/execution-control.md.\n   *\n   * @param name   Display label for the fan-out stage.\n   * @param id     Stable stage id. May not contain `~` (reserved — the branch\n   *               segments are built from this id).\n   * @param config `{ items, branch, maxBranches, into, failFast? }`:\n   *   - `items(scope)` picks what to fan out over (reads are tracked);\n   *   - `branch(item, index)` builds the chart for ONE item (each branch's\n   *     scope is also seeded with `item` and `index`, so the input is in the\n   *     trace rather than hidden in a closure);\n   *   - `maxBranches` is REQUIRED — an unbounded fan-out driven by model output\n   *     is a resource attack, so there is no default to forget. Extra items do\n   *     not run and the truncation is recorded;\n   *   - `into` is REQUIRED — the state key the ordered results array is written\n   *     to. `into[i]` is branch `i`'s result, in ITEMS order, whatever order\n   *     the branches finished in;\n   *   - `failFast` is the same policy the rest of the library's parallelism\n   *     uses: `true` rejects on the first failing branch, omitted runs them all\n   *     best-effort (a failed branch's slot is `undefined`).\n   *\n   * @example\n   * ```ts\n   * flowChart<State>('Split', splitFn, 'split')\n   *   .addParallelForEach('Review each chunk', 'review-chunks', {\n   *     items: (scope) => scope.chunks,\n   *     branch: (chunk, i) => buildReviewChart(chunk, i),\n   *     maxBranches: 8,\n   *     into: 'reviews',\n   *   })\n   *   .addFunction('Merge', mergeFn, 'merge')   // reads scope.reviews\n   *   .build();\n   * ```\n   */\n  addParallelForEach<TItem = any>(\n    name: string,\n    id: string,\n    config: ParallelForEachConfig<TItem, TScope>,\n    description?: string,\n  ): this {\n    const cur = this._needCursor();\n    const curSpec = this._needCursorSpec();\n    const parentSpec = curSpec;\n\n    // The generated branch segments embed this id verbatim\n    // (`<id>~<index>`), so a marker inside it would make the segment\n    // ambiguous to parse. Refusing it here — on a brand-new method, at zero\n    // back-compat cost — kills the ambiguity class outright and keeps\n    // `parseBranchSegment` a split at the last marker instead of a heuristic.\n    admitId('parallelForEach stage id', id, 'segment');\n    this._claimFreshId(id, `addParallelForEach('${id}')`);\n    if (!config || typeof config.items !== 'function' || typeof config.branch !== 'function') {\n      fail(`addParallelForEach('${id}') requires items(scope) and branch(item, index) functions.`);\n    }\n    // REQUIRED, both of them — see docs/design/execution-control.md (D2).\n    if (typeof config.maxBranches !== 'number' || !Number.isInteger(config.maxBranches) || config.maxBranches < 1) {\n      fail(\n        `addParallelForEach('${id}') requires maxBranches — a positive integer ceiling on how many ` +\n          'branches one execution may start. There is deliberately no default: an unbounded fan-out ' +\n          'driven by runtime data (model output, an upstream API) is a resource attack. Pick the ' +\n          'largest number this flow can afford. See docs/design/execution-control.md.',\n      );\n    }\n    if (typeof config.into !== 'string' || config.into === '') {\n      fail(\n        `addParallelForEach('${id}') requires into — the state key its ordered results array is ` +\n          'written to. There is deliberately no default derived from the stage id: a derived key ' +\n          'could silently overwrite state the chart already owns. See docs/design/execution-control.md.',\n      );\n    }\n\n    const node: StageNode<TOut, TScope> = {\n      name,\n      id,\n      isDynamicParallel: true,\n      parallelForEach: config as ParallelForEachConfig<any, TScope>,\n    };\n    if (description) node.description = description;\n    if (config.failFast !== undefined) node.failFast = config.failFast;\n\n    // `type: 'fork'` — a fan-out is what this is, and every existing consumer\n    // already knows how to draw one. The \"branches are decided at runtime\"\n    // detail rides `isDynamicParallel` rather than a new node type, so nothing\n    // downstream has to learn a new word to keep working.\n    const spec: SerializedPipelineStructure = { name, id, type: 'fork', isDynamicParallel: true };\n    if (description) spec.description = description;\n\n    cur.next = node;\n    curSpec.next = spec;\n    this._cursor = node;\n    this._advanceCursorSpec(spec);\n    this._knownStageIds.add(id);\n\n    this._fireStageAdded(spec);\n    this._fireNextEdgeFromParent(parentSpec, id);\n\n    this._appendDescriptionLine(name, description ?? `Runs one branch per item into '${config.into}'`);\n    return this;\n  }\n\n  // ── Subflow Mounting ──\n\n  addSubFlowChart(id: string, subflow: FlowChart<any, any>, mountName?: string, options?: SubflowMountOptions): this {\n    const { cur, curSpec } = this._needForkParent();\n\n    if (cur.children?.some((c) => c.id === id)) {\n      fail(`duplicate child id '${id}' under '${cur.name}'`);\n    }\n    assertSubflowIdAllowed(id);\n\n    const subflowName = mountName || id;\n    const forkId = cur.id;\n    this._mountSubflow(id, subflow, () => {\n      const node: StageNode<TOut, TScope> = {\n        name: subflowName,\n        id,\n        isSubflowRoot: true,\n        subflowId: id,\n        subflowName,\n      };\n      if (options) node.subflowMountOptions = options;\n\n      const spec: SerializedPipelineStructure = {\n        name: subflowName,\n        type: 'stage',\n        id,\n        isSubflowRoot: true,\n        subflowId: id,\n        subflowName,\n        isParallelChild: true,\n        parallelGroupId: forkId,\n        subflowStructure: subflow.buildTimeStructure,\n      };\n\n      // The mount's ONLY tag site: the cursor stays on the parent (see\n      // `_cursorTail`), so `.tag()` after this call refuses.\n      applyTags(node, spec, options?.tags, `addSubFlowChart('${id}')`);\n\n      curSpec.type = 'fork';\n      cur.children = cur.children || [];\n      cur.children.push(node);\n      curSpec.children = curSpec.children || [];\n      curSpec.children.push(spec);\n      this._knownStageIds.add(id);\n      // L7.3 — Subflow mount: stage event + fork edge + mount lifecycle\n      // event. Mount-only semantics: parent recorders do NOT replay the\n      // subflow's own internal structure events.\n      this._fireStageAdded(spec);\n      this._fireEdgeAdded(curSpec.id, id, 'fork-branch');\n      this._fireSubflowMounted(id, subflowName, id, false, subflow.buildTimeStructure);\n    });\n    this._appendSubflowDescription(id, subflowName, subflow);\n\n    this._cursorTail = `the subflow mount '${subflowName}'`;\n    return this;\n  }\n\n  addLazySubFlowChart(\n    id: string,\n    resolver: () => FlowChart<TOut, TScope>,\n    mountName?: string,\n    options?: SubflowMountOptions,\n  ): this {\n    const { cur, curSpec } = this._needForkParent();\n\n    if (cur.children?.some((c) => c.id === id)) {\n      fail(`duplicate child id '${id}' under '${cur.name}'`);\n    }\n    assertSubflowIdAllowed(id);\n    this._claimFreshId(id, `addLazySubFlowChart('${id}')`);\n\n    const subflowName = mountName || id;\n    const forkId = cur.id;\n\n    const node: StageNode<TOut, TScope> = {\n      name: subflowName,\n      id,\n      isSubflowRoot: true,\n      subflowId: id,\n      subflowName,\n      subflowResolver: resolver as any,\n    };\n    if (options) node.subflowMountOptions = options;\n\n    // Lazy mount stub. The lazy subflow's internals will be shaped at\n    // resolution time.\n    const spec: SerializedPipelineStructure = {\n      name: subflowName,\n      type: 'stage',\n      id,\n      isSubflowRoot: true,\n      subflowId: id,\n      subflowName,\n      isParallelChild: true,\n      parallelGroupId: forkId,\n      isLazy: true,\n    };\n\n    applyTags(node, spec, options?.tags, `addLazySubFlowChart('${id}')`);\n\n    curSpec.type = 'fork';\n    cur.children = cur.children || [];\n    cur.children.push(node);\n    curSpec.children = curSpec.children || [];\n    curSpec.children.push(spec);\n    // L7.3 — Lazy subflow parallel mount.\n    this._fireStageAdded(spec);\n    this._fireEdgeAdded(curSpec.id, id, 'fork-branch');\n    this._fireSubflowMounted(id, subflowName, id, true);\n\n    this._stepCounter++;\n    this._stageStepMap.set(id, this._stepCounter);\n    this._descriptionParts.push(`${this._stepCounter}. [Lazy Sub-Execution: ${subflowName}]`);\n\n    this._cursorTail = `the lazy subflow mount '${subflowName}'`;\n    return this;\n  }\n\n  addLazySubFlowChartNext(\n    id: string,\n    resolver: () => FlowChart<TOut, TScope>,\n    mountName?: string,\n    options?: SubflowMountOptions,\n  ): this {\n    const cur = this._needCursor();\n    const curSpec = this._needCursorSpec();\n\n    if (cur.next) {\n      fail(`cannot add subflow as next when next is already defined at '${cur.name}'`);\n    }\n    assertSubflowIdAllowed(id);\n    this._claimFreshId(id, `addLazySubFlowChartNext('${id}')`);\n\n    const subflowName = mountName || id;\n\n    const node: StageNode<TOut, TScope> = {\n      name: subflowName,\n      id,\n      isSubflowRoot: true,\n      subflowId: id,\n      subflowName,\n      subflowResolver: resolver as any,\n    };\n    if (options) node.subflowMountOptions = options;\n\n    // Lazy mount stub. The lazy subflow's internals will be shaped at\n    // resolution time.\n    const spec: SerializedPipelineStructure = {\n      name: subflowName,\n      type: 'stage',\n      id,\n      isSubflowRoot: true,\n      subflowId: id,\n      subflowName,\n      isLazy: true,\n    };\n\n    applyTags(node, spec, options?.tags, `addLazySubFlowChartNext('${id}')`);\n\n    const parentSpec = curSpec;\n    cur.next = node;\n    curSpec.next = spec;\n    this._cursor = node;\n    this._advanceCursorSpec(spec);\n    // L7.3 — Lazy linear-mount subflow.\n    this._fireStageAdded(spec);\n    this._fireNextEdgeFromParent(parentSpec, id);\n    this._fireSubflowMounted(id, subflowName, id, true);\n\n    this._stepCounter++;\n    this._stageStepMap.set(id, this._stepCounter);\n    this._descriptionParts.push(`${this._stepCounter}. [Lazy Sub-Execution: ${subflowName}]`);\n\n    return this;\n  }\n\n  addSubFlowChartNext(\n    id: string,\n    subflow: FlowChart<any, any>,\n    mountName?: string,\n    options?: SubflowMountOptions,\n  ): this {\n    const cur = this._needCursor();\n    const curSpec = this._needCursorSpec();\n\n    if (cur.next) {\n      fail(`cannot add subflow as next when next is already defined at '${cur.name}'`);\n    }\n    assertSubflowIdAllowed(id);\n\n    const subflowName = mountName || id;\n    this._mountSubflow(id, subflow, () => {\n      const node: StageNode<TOut, TScope> = {\n        name: subflowName,\n        id,\n        isSubflowRoot: true,\n        subflowId: id,\n        subflowName,\n      };\n      if (options) node.subflowMountOptions = options;\n\n      const attachedSpec: SerializedPipelineStructure = {\n        name: subflowName,\n        type: 'stage',\n        id,\n        isSubflowRoot: true,\n        subflowId: id,\n        subflowName,\n        subflowStructure: subflow.buildTimeStructure,\n      };\n\n      // A linear mount moves the cursor, so `.tag()` after it also works —\n      // `applyTags` refuses a second declaration if both sites are used.\n      applyTags(node, attachedSpec, options?.tags, `addSubFlowChartNext('${id}')`);\n\n      const parentSpec = curSpec;\n      cur.next = node;\n      curSpec.next = attachedSpec;\n      this._cursor = node;\n      this._advanceCursorSpec(attachedSpec);\n      this._knownStageIds.add(id);\n      // L7.3 — Linear-mount subflow.\n      this._fireStageAdded(attachedSpec);\n      this._fireNextEdgeFromParent(parentSpec, id);\n      this._fireSubflowMounted(id, subflowName, id, false, subflow.buildTimeStructure);\n    });\n    this._appendSubflowDescription(id, subflowName, subflow);\n\n    return this;\n  }\n\n  // ── Retry ──\n\n  /**\n   * Give the stage you JUST added a declarative retry policy.\n   *\n   * ## Why declare it instead of writing a loop inside the stage\n   *\n   * A retry hand-rolled inside a stage function is invisible to the trace. The\n   * narrative shows one stage, the commit log shows one entry, and the two\n   * failed calls that came before the successful one left no mark anywhere —\n   * an unexplained behaviour in a library whose whole point is that nothing\n   * invisible happens. Declared here, every attempt is part of the record: each\n   * attempt fires `FlowRecorder.onAttempt` with its `AttemptRecord` (outcome,\n   * duration, failure category, the retry-or-stop decision), which is what\n   * feeds the narrative — one line per attempt, in order, between the\n   * attempts' own reads and writes. The stage's execution-tree node keeps the\n   * records (`attempts`, `attemptSummary`). A failed attempt that is retried\n   * also fires `FlowRecorder.onStageRetry`, which the narrative does not tell\n   * twice.\n   *\n   * ## What an attempt is\n   *\n   * A failed attempt's staged writes are DISCARDED — the next attempt starts\n   * from committed state, never from the wreckage of the last try. The final\n   * attempt behaves exactly as a stage with no policy does: on success it\n   * commits; on failure it commits what it wrote and rethrows (footprint has\n   * never had rollback, and retry does not introduce one).\n   *\n   * A pause is not a failure: neither `addPausableFunction`'s pause nor\n   * `interrupt()` is ever retried. Nor is a cancelled run.\n   *\n   * @example\n   * ```ts\n   * flowChart<State>('Fetch user', fetchFn, 'fetch-user')\n   *   .addFunction('Charge card', chargeFn, 'charge')\n   *   .retry({ attempts: 3, backoffMs: (n) => 100 * 2 ** (n - 1) })\n   *   .addFunction('Confirm', confirmFn, 'confirm')\n   * ```\n   *\n   * Applies to the CURRENT cursor — the stage added by the immediately\n   * preceding `start()` / `addFunction()` / `addStreamingFunction()` /\n   * `addPausableFunction()`. Where the cursor would be ambiguous (a decider,\n   * selector, branch, or fork child), declare the policy in that method's own\n   * `retry` option instead.\n   */\n  retry(policy: RetryPolicy): this {\n    const cur = this._needCursor();\n    const curSpec = this._needCursorSpec();\n\n    // A subflow mount / parallel fork hangs CHILDREN off the current stage and\n    // leaves the cursor on that stage. Attaching the policy to the cursor here\n    // would silently retry the stage BEFORE the thing you just wrote.\n    if (this._cursorTail) {\n      fail(\n        `retry() cannot follow ${this._cursorTail} — that attaches to '${cur.name}' without moving the cursor, so ` +\n          `the policy would land on '${cur.name}' rather than on what you just added. Declare the policy at its own ` +\n          'site instead: on the stages INSIDE a subflow chart, or via the `retry` field on an addListOfFunction child.',\n      );\n    }\n    if (cur.retry) fail(`retry already defined at '${cur.name}'`);\n    if (cur.isSubflowRoot) {\n      fail(\n        `retry() cannot be applied to the subflow mount '${cur.name}' — a mount has no stage function of its own. ` +\n          'Declare the policy on the stages INSIDE the subflow chart instead.',\n      );\n    }\n    if (cur.isDynamicParallel) {\n      fail(\n        `retry() cannot be applied to the parallel-for-each stage '${cur.name}' — it has no stage function of its ` +\n          'own. Declare the policy on the stages inside the branch chart its `branch` factory returns.',\n      );\n    }\n    if (cur.isLoopRef) fail(`retry() cannot be applied to the loop reference '${cur.name}'`);\n\n    applyRetryPolicy(cur, curSpec, policy, `retry() at '${cur.name}'`);\n    return this;\n  }\n\n  // ── Side effects ──\n\n  /**\n   * Declare that the stage you JUST added changes an outside system — a charge, an email, a write to another\n   * service (10.1, design §3.3) — and give the rule for its idempotency key.\n   *\n   * ## Why declare it\n   *\n   * A retry is safe for a read. For a charge it is safe only when the outside system can tell a retry from a new\n   * request — by an idempotency key. So the builder refuses a touching stage that may retry (`.retry({ attempts >\n   * 1 })`, in either order) without a key rule: a double charge must be impossible to write by accident. A default\n   * key made by the library was rejected — the run id changes across a resume and a caller's whole-run retry, the\n   * two places a double charge actually happens. The key must name the OPERATION: derive it from the input the rule\n   * is handed, never from model output (`({ getState }) => …` reads it from state). A\n   * keyless touching stage may not `interrupt()`: a resume re-runs it from its top. In a chart that pauses, derive\n   * keys from state (`({ getState }) => …`): the run's input does not cross a resume.\n   *\n   * ## What it changes at run time\n   *\n   * The stage always runs on the attempt runner. The key rule runs ONCE per execution, before attempt 1, and every\n   * attempt gets the key as `scope.$attempt().idempotencyKey` — pass it to the system. Every attempt record says\n   * what it did there (`effect`: `'applied'`, `'none'` when the error itself declares `effect: 'none'`, else\n   * `'unknown'`). When ANY attempt left the effect unknown — it timed out, was cut, or failed without the adapter\n   * saying nothing was sent — the stage fails with `UnknownEffectError`: reconcile with the system by the key, do\n   * not retry blindly. The spec carries the system's name (`touches`).\n   *\n   * @example\n   * ```ts\n   * flowChart<Order>('Load order', loadFn, 'load')\n   *   .addFunction('Charge card', chargeFn, 'charge')\n   *   .touches('stripe', { idempotencyKey: ({ args }) => `order-${(args as { orderId: string }).orderId}` })\n   *   .retry({ attempts: 3, timeoutMs: 20_000 })\n   * ```\n   *\n   * Applies to the CURRENT cursor, like `.retry()`; where the cursor would be ambiguous (a decider, selector,\n   * branch, or fork child), declare it in that method's own `touches` option. Refused: on a subflow mount, a\n   * parallel-for-each stage or a loop reference (no function of their own), after a mount or a fork (the cursor did\n   * not move), twice, with a system that is not a name, and with a key that is not a function.\n   */\n  touches(system: string, options?: { readonly idempotencyKey?: StageTouches['idempotencyKey'] }): this {\n    const cur = this._needCursor();\n    const curSpec = this._needCursorSpec();\n    if (this._cursorTail) {\n      fail(\n        `touches() cannot follow ${this._cursorTail} — that attaches to '${cur.name}' without moving the cursor. ` +\n          'Declare it at its own site: on the stages INSIDE a subflow chart, or via the `touches` field on an ' +\n          'addListOfFunction child.',\n      );\n    }\n    if (cur.isSubflowRoot) {\n      fail(`touches() cannot be applied to the subflow mount '${cur.name}' — declare it on the stages INSIDE it.`);\n    }\n    if (cur.isDynamicParallel) {\n      fail(\n        `touches() cannot be applied to the parallel-for-each stage '${cur.name}' — declare it on the stages of ` +\n          'the branch chart.',\n      );\n    }\n    if (cur.isLoopRef) fail(`touches() cannot be applied to the loop reference '${cur.name}'`);\n    applyTouches(\n      cur,\n      curSpec,\n      { system, ...(options?.idempotencyKey !== undefined && { idempotencyKey: options.idempotencyKey }) },\n      `touches() at '${cur.name}'`,\n    );\n    return this;\n  }\n\n  // ── Declared tags ──\n\n  /**\n   * Put NAMES on the stage you JUST added. The first commit bundle of each\n   * execution of that stage carries them (`CommitBundle.tags` — the bundle\n   * `commitStops` keys on), and the built spec advertises them\n   * (`SerializedPipelineStructure.tags`).\n   *\n   * ## Why declare it instead of deriving it from ids\n   *\n   * A reader that wants \"the LLM turns\" of a stored recording had to classify\n   * stages from their ids — a switch over `runtimeStageId` that parses `#` and\n   * `/`, lives in the consumer, and silently goes stale when a stage is\n   * renamed. Declared here, the name travels WITH the commit: a recording from\n   * any chart carries its own milestones, and `tagStops` (foottrace)\n   * scrubs them with no id conventions at all.\n   *\n   * ## What a tag is, and is not\n   *\n   * A tag is a NAME declared at build time — never a value. There is no\n   * run-time `$tag()`: a runtime string could carry data (`'user:' + email`)\n   * past every redaction point. Data-dependent marks are a keep rule over\n   * the fold at read time, or telemetry via `$emit`. Free strings: footprintjs\n   * owns no vocabulary; a consumer declares its own (`'milestone:<kind>'`).\n   *\n   * Stamped ONCE per execution of the stage: retry attempts share one stamp,\n   * a failed stage keeps its tag (the error path commits before it rethrows),\n   * a stage that `interrupt()`s and is resumed is two tagged stops on a chain\n   * because it ran twice, and an EMPTY commit is a tagged stop too. A subflow\n   * mount or a parallel-for-each stage can be tagged; the tag lands on the\n   * bundle that records its result — for a mount, its FIRST bundle in the\n   * parent log (the exit bundle carries none), while the subflow's own log\n   * is untouched: its inner stages declare their own.\n   *\n   * @example\n   * ```ts\n   * flowChart<State>('Seed', seedFn, 'seed')\n   *   .addFunction('Call model', callFn, 'call-llm')\n   *   .tag('milestone:llm-turn')\n   *   .addFunction('Route', routeFn, 'route')\n   *   .tag('milestone:decision', 'audit')\n   * ```\n   *\n   * Applies to the CURRENT cursor — the stage added by the immediately\n   * preceding `start()` / `addFunction()` / `addStreamingFunction()` /\n   * `addPausableFunction()` / `addSubFlowChartNext()` / `addParallelForEach()`.\n   * Where the cursor would be ambiguous (a decider, selector, branch, or fork\n   * child), declare the tags in that method's own `tags` option instead. A\n   * subflow MOUNT has that option too (`SubflowMountOptions.tags`, 9.21.1)\n   * — and for a fork-child mount (`addSubFlowChart`) or a branch mount\n   * (`addSubFlowChartBranch`) it is the ONLY site: those leave the cursor on\n   * the parent, so `.tag()` after them refuses rather than mis-attribute.\n   *\n   * Refused at build time: an empty name, a non-string, the reserved\n   * branch-segment marker `~` inside a name, a name declared twice, and a\n   * second declaration on the same stage.\n   */\n  tag(...names: readonly string[]): this {\n    const cur = this._needCursor();\n    const curSpec = this._needCursorSpec();\n\n    // Same mis-attribution guard as `.retry()`: after a mount or a fork the\n    // cursor still points at the stage BEFORE what you just wrote.\n    if (this._cursorTail) {\n      fail(\n        `tag() cannot follow ${this._cursorTail} — that attaches to '${cur.name}' without moving the cursor, so ` +\n          `the names would land on '${cur.name}' rather than on what you just added. Declare the tags at their own ` +\n          \"site instead: via the `tags` field in the mount's own options (`SubflowMountOptions.tags`, 9.21.1), or \" +\n          'via the `tags` field on an addListOfFunction child. The stages INSIDE a subflow chart declare their own.',\n      );\n    }\n    if (cur.isLoopRef) fail(`tag() cannot be applied to the loop reference '${cur.name}'`);\n    if (names.length === 0) fail(`tag() at '${cur.name}': at least one name is required`);\n\n    applyTags(cur, curSpec, names, `tag() at '${cur.name}'`);\n    // The stage's `onStageAdded` has already fired (the door comes after\n    // the add), so the names go out as their own event — a recorder that\n    // copied fields at add time would otherwise never see them (9.24.0).\n    this._fireStageTagged(curSpec);\n    return this;\n  }\n\n  // ── Time budget ──\n\n  /**\n   * Declare the chart's time budget: the most milliseconds a caller gives one run (design §3.2).\n   *\n   * WHY: the incident behind it — a stage retried an SDK call four times, 40 s each, past a caller's 120 s, and the\n   * record said \"one stage, one error\". Both numbers were declared: the policy on the stage, the budget of the\n   * caller. So `build()` checks one against the other: it REFUSES the chart when its declared policies already allow\n   * longer (`attempts × timeoutMs` plus the waits, summed along the slowest path — see `timeBudget`), and in dev mode\n   * names every stage it cannot bound (no `timeoutMs`, a function backoff with no `maxBackoffMs`, a loop, a lazy\n   * subflow, a `parallelForEach`). The spec root carries it (`budgetMs`); at run start, a deadline shorter than it is\n   * a dev-mode warning.\n   *\n   * Chart-level, so it may be declared anywhere before `build()`, once.\n   *\n   * @example\n   * ```ts\n   * flowChart<State>('Read', readFn, 'read', { retry: { attempts: 1, timeoutMs: 5_000 } })\n   *   .addFunction('Charge', chargeFn, 'charge')\n   *   .retry({ attempts: 4, timeoutMs: 40_000, backoffMs: 1_000 })\n   *   .budget(120_000)\n   *   .build(); // throws: its declared policies allow 168000 ms, over its budget by 48000 ms\n   * ```\n   */\n  budget(ms: number): this {\n    if (this._sealed) fail('budget() after build() — declare the budget before building the chart');\n    const rootSpec = this._rootSpec ?? fail('budget() before start() — start the chart first');\n    // At most Number.MAX_SAFE_INTEGER: the worst case saturates there, so a larger budget could never be exceeded.\n    if (!(typeof ms === 'number' && ms > 0 && ms <= Number.MAX_SAFE_INTEGER)) {\n      fail(\n        'budget(ms) must be a finite number of milliseconds > 0, at most Number.MAX_SAFE_INTEGER ' +\n          `(got ${typeof ms === 'number' ? ms : typeof ms})`,\n      );\n    }\n    if (rootSpec.budgetMs !== undefined) fail(`budget already declared (${rootSpec.budgetMs} ms) — declare it once`);\n    rootSpec.budgetMs = ms;\n    return this;\n  }\n\n  // ── Loop ──\n\n  loopTo(stageId: string): this {\n    const cur = this._needCursor();\n    const curSpec = this._needCursorSpec();\n\n    if (curSpec.loopTarget) fail(`loopTo already defined at '${cur.name}'`);\n    if (cur.next) fail(`cannot set loopTo when next is already defined at '${cur.name}'`);\n\n    if (!this._knownStageIds.has(stageId)) {\n      fail(`loopTo('${stageId}') target not found — did you pass a stage name instead of id?`);\n    }\n\n    cur.next = { name: stageId, id: stageId, isLoopRef: true };\n    curSpec.loopTarget = stageId;\n    curSpec.next = { name: stageId, id: stageId, type: 'loop', isLoopReference: true };\n\n    const targetStep = this._stageStepMap.get(stageId);\n    if (targetStep !== undefined) {\n      this._descriptionParts.push(`→ loops back to step ${targetStep}`);\n    } else {\n      this._descriptionParts.push(`→ loops back to ${stageId}`);\n    }\n\n    // L7.3 — Fire the loop back-edge event. Distinct from `onEdgeAdded`\n    // because runtime `onLoop` carries `iteration: number` which has no\n    // build meaning — separate event keeps payloads honest.\n    this._fireLoopEdgeAdded(cur.id, stageId);\n    return this;\n  }\n\n  // ── Streaming ──\n\n  onStream(handler: StreamTokenHandler): this {\n    this._streamHandlers.onToken = handler;\n    return this;\n  }\n\n  onStreamStart(handler: StreamLifecycleHandler): this {\n    this._streamHandlers.onStart = handler;\n    return this;\n  }\n\n  onStreamEnd(handler: StreamLifecycleHandler): this {\n    this._streamHandlers.onEnd = handler;\n    return this;\n  }\n\n  // ── Output ──\n\n  build(): RunnableFlowChart<TOut, TScope> {\n    // L7.3 — seal the chart so post-build attaches throw. Prevents\n    // recorders attached mid-execution from getting partial data.\n    this._sealed = true;\n\n    const root = this._root ?? fail('empty tree; call start() first');\n    const rootSpec = this._rootSpec ?? fail('empty spec; call start() first');\n\n    const subflows: Record<string, { root: StageNode<TOut, TScope> }> = {};\n    for (const [key, def] of this._subflowDefs) {\n      subflows[key] = def;\n    }\n\n    const rootName = this._root?.name ?? 'FlowChart';\n    const description =\n      this._descriptionParts.length > 0 ? `FlowChart: ${rootName}\\nSteps:\\n${this._descriptionParts.join('\\n')}` : '';\n\n    const chart: FlowChart<TOut, TScope> = {\n      root,\n      stageMap: this._stageMap,\n      buildTimeStructure: rootSpec,\n      ...(Object.keys(subflows).length > 0 ? { subflows } : {}),\n      ...(this._enableNarrative ? { enableNarrative: true } : {}),\n      ...(this._logger ? { logger: this._logger } : {}),\n      description,\n      stageDescriptions: new Map(this._stageDescriptions),\n      ...(this._inputSchema ? { inputSchema: this._inputSchema } : {}),\n      ...(this._outputSchema ? { outputSchema: this._outputSchema } : {}),\n      ...(this._outputMapper ? { outputMapper: this._outputMapper } : {}),\n      // Auto-embed TypedScope factory if none was explicitly set.\n      // This means ANY way of creating a FlowChartBuilder (flowChart(), new FlowChartBuilder(),\n      // or any subclass) automatically gets TypedScope — no manual setScopeFactory needed.\n      scopeFactory: this._scopeFactory ?? (createTypedScopeFactory() as unknown as ScopeFactory<TScope>),\n    };\n\n    if (rootSpec.budgetMs !== undefined) this._checkBudget(chart);\n    return makeRunnable(chart);\n  }\n\n  /**\n   * The declared budget, checked (owner ruling Q2): refused when the chart's bounded part alone allows longer — a\n   * time its declared policies allow a run to take, so the budget cannot be promised; every stage it cannot bound is\n   * a dev-mode warning.\n   */\n  private _checkBudget(chart: FlowChart<TOut, TScope>): void {\n    const report = timeBudget(chart);\n    const refusal = budgetRefusal(report);\n    if (refusal !== undefined) fail(refusal);\n    if (!isDevMode()) return;\n    const warning = budgetWarning(report, chart.root.name);\n    // eslint-disable-next-line no-console\n    if (warning !== undefined) console.warn(warning);\n  }\n\n  /** Override the scope factory. Rarely needed — auto-embeds TypedScope by default. */\n  setScopeFactory(factory: ScopeFactory<TScope>): this {\n    this._scopeFactory = factory;\n    return this;\n  }\n\n  toSpec<TResult = SerializedPipelineStructure>(): TResult {\n    const rootSpec = this._rootSpec ?? fail('empty tree; call start() first');\n    return rootSpec as TResult;\n  }\n\n  toMermaid(): string {\n    const lines: string[] = ['flowchart TD'];\n    const idOf = (k: string) => (k || '').replace(/[^a-zA-Z0-9_]/g, '_') || '_';\n    const root = this._root ?? fail('empty tree; call start() first');\n\n    const walk = (n: StageNode<TOut, TScope>) => {\n      const nid = idOf(n.id);\n      lines.push(`${nid}[\"${n.name}\"]`);\n      for (const c of n.children || []) {\n        const cid = idOf(c.id);\n        lines.push(`${nid} --> ${cid}`);\n        walk(c);\n      }\n      if (n.next) {\n        const mid = idOf(n.next.id);\n        lines.push(`${nid} --> ${mid}`);\n        walk(n.next);\n      }\n    };\n    walk(root);\n    return lines.join('\\n');\n  }\n\n  // ── Internals (exposed for helper classes) ──\n\n  private _needCursor(): StageNode<TOut, TScope> {\n    return this._cursor ?? fail('cursor undefined; call start() first');\n  }\n\n  private _needCursorSpec(): SerializedPipelineStructure {\n    return this._cursorSpec ?? fail('cursor undefined; call start() first');\n  }\n\n  /**\n   * The node a fan-out (`addListOfFunction`, `addSubFlowChart`,\n   * `addLazySubFlowChart`) hangs its children on — the cursor, unless the\n   * cursor's `children` already MEAN something else:\n   *\n   * - a subflow MOUNT — the engine reads a mount that carries children as the\n   *   mounted chart's OWN content (`NodeResolver · resolveSubflowReference`),\n   *   so a fork hung there ran INSIDE the subflow: the subflow's real chart\n   *   never ran, everything after the fork ran twice, and a pause after it was\n   *   checkpointed under the wrong subflow path (and refused on resume);\n   * - a DECIDER or a SELECTOR (the cursor after `.end()`) — its children are\n   *   its branches, so a fork child became a branch nobody picks;\n   * - a `parallelForEach` — its branches come from `items` at run time and\n   *   built children are never dispatched, so the fork never ran.\n   *\n   * Through 9.37.0 the builder hung the fork there anyway. So after such a\n   * node the fork continues AFTER it: a function-less fork node\n   * `<nodeId>-fork` becomes the node's `next` and the new cursor — the shape\n   * `addFunction(...).addListOfFunction(...)` already builds, which every\n   * reader (engine, resume, structure, spec) handles. A second fan-out call\n   * reuses that node, as it would any cursor. The id is reserved both ways:\n   * refused here when a stage already has it, and by stage admission /\n   * `_registerSubflowDef` when a later stage or mount asks for it.\n   */\n  private _needForkParent(): { cur: StageNode<TOut, TScope>; curSpec: SerializedPipelineStructure } {\n    const owner = this._needCursor();\n    const ownerSpec = this._needCursorSpec();\n    const childrenMeanSomethingElse =\n      owner.isSubflowRoot || owner.isDynamicParallel || owner.deciderFn || owner.selectorFn;\n    if (!childrenMeanSomethingElse) return { cur: owner, curSpec: ownerSpec };\n\n    const id = `${owner.id}-fork`;\n    if (this._idTaken(id)) {\n      fail(\n        `cannot fan out after '${owner.name}': the fork node it needs, '${id}', ` +\n          `is already a stage id. Add a stage after '${owner.name}' and fan out from it.`,\n      );\n    }\n    const node: StageNode<TOut, TScope> = { name: id, id };\n    const spec: SerializedPipelineStructure = { name: id, id, type: 'fork' };\n    owner.next = node;\n    ownerSpec.next = spec;\n    this._cursor = node;\n    this._advanceCursorSpec(spec);\n    this._knownStageIds.add(id);\n    this._forkNodeIds.add(id);\n    this._fireStageAdded(spec);\n    this._fireNextEdgeFromParent(ownerSpec, id);\n    return { cur: node, curSpec: spec };\n  }\n\n  /** Ids `_needForkParent` generated — no later stage or mount may take one. */\n  private _forkNodeIds = new Set<string>();\n\n  /** Shared by stage admission and subflow registration: reserved structural ids cannot be reused. */\n  private _refuseForkNodeId(id: string): void {\n    if (this._claimedIds.has(id)) {\n      fail(`id '${id}' is already used by a lazy subflow mount or a parallelForEach in this chart. Rename the stage.`);\n    }\n    if (!this._forkNodeIds.has(id)) return;\n    fail(\n      `id '${id}' is taken: it is the fork node the builder placed after '${id.slice(0, -'-fork'.length)}' ` +\n        '(a fan-out right after a subflow mount, decider, selector or parallelForEach continues on it). ' +\n        'Rename the stage.',\n    );\n  }\n\n  /** Ids the lazy-mount and parallelForEach doors claimed (they register in no map). */\n  private _claimedIds = new Set<string>();\n\n  /** Structural declarations without an embedded function; not function entries or loop targets. */\n  private _functionlessStageIds = new Set<string>();\n\n  /** True when an earlier stage, branch, fork child, mount or generated fork node holds `id`. */\n  private _idTaken(id: string): boolean {\n    return (\n      this._knownStageIds.has(id) ||\n      this._stageMap.has(id) ||\n      this._functionlessStageIds.has(id) ||\n      this._subflowDefs.has(id) ||\n      this._claimedIds.has(id) ||\n      this._forkNodeIds.has(id)\n    );\n  }\n\n  /**\n   * @internal The lazy-mount doors and `addParallelForEach` register their id\n   * in no map, so through 9.37.0 they accepted an id another stage or mount\n   * already had (and a later stage could take theirs). They claim it here:\n   * refused when taken, recorded when fresh. Loop-ref stubs reference an\n   * existing stage rather than claiming a new id. Reusable function stages\n   * retain their separate `_addToMap` rule.\n   */\n  _claimFreshId(id: string, door: string): void {\n    if (this._idTaken(id)) {\n      fail(`${door}: id '${id}' is already used by another stage or mount in this chart. Give it its own id.`);\n    }\n    this._claimedIds.add(id);\n  }\n\n  /**\n   * Advance the spec cursor. Retained as a method so call sites stay\n   * one-liners and future cursor-related side effects have a hook.\n   */\n  /**\n   * What was attached to the CURSOR without advancing it — a subflow mount, a\n   * parallel fork's children. Cleared by {@link _advanceCursorSpec}, the single\n   * choke point every cursor-advancing method already goes through, so this\n   * marker cannot drift as new builder methods are added.\n   *\n   * Exists for `.retry()`. Those methods hang children off the current stage\n   * and leave the cursor pointing at that stage, so a chained `.retry()` would\n   * silently attach the policy to the stage BEFORE the thing you just wrote —\n   * exactly the silent mis-attribution this codebase refuses elsewhere (see\n   * the branch-segment marker rules). Naming what was last added lets the\n   * refusal say something useful.\n   */\n  private _cursorTail?: string;\n\n  private _advanceCursorSpec(newSpec: SerializedPipelineStructure | undefined): void {\n    this._cursorTail = undefined;\n    this._cursorSpec = newSpec;\n  }\n\n  _stageMapHas(key: string): boolean {\n    return this._stageMap.has(key);\n  }\n\n  /**\n   * @internal Register a mounted subflow's definition — first mount wins,\n   * at every eager mount site (linear, fork child, decider and selector\n   * branch). A SECOND mount under the same id is allowed (existing charts do\n   * it) and shares the first one's definition — but a pause inside either\n   * cannot be resumed: a checkpoint's `subflowPath` names the subflow id, not\n   * the mount, so `resume()` refuses the ambiguous path. Dev mode says so\n   * here, at build time, where the id can still be changed.\n   */\n  _registerSubflowDef(id: string, root: StageNode<TOut, TScope>): void {\n    this._refuseForkNodeId(id);\n    if (!this._subflowDefs.has(id)) {\n      this._subflowDefs.set(id, { root });\n      return;\n    }\n    if (isDevMode()) {\n      // eslint-disable-next-line no-console\n      console.warn(\n        `[footprint] subflow id '${id}' is mounted more than once in this chart. The mounts share one ` +\n          'definition, and a pause inside either cannot be resumed — the checkpoint cannot say which mount ' +\n          'paused. Give each mount its own id.',\n      );\n    }\n  }\n\n  /**\n   * @internal One admission path for optional-function children and branches.\n   * A missing function does not erase the graph identity: check reservations\n   * and record it for future fresh-id claims, without adding a function or a\n   * loop target. Existing function references by id/name remain legal.\n   */\n  _registerStage(id: string, fn: StageFunction<TOut, TScope> | undefined): void {\n    if (fn) {\n      this._addToMap(id, fn);\n      return;\n    }\n    this._refuseForkNodeId(id);\n    this._functionlessStageIds.add(id);\n  }\n\n  _addToMap(id: string, fn: StageFunction<TOut, TScope>) {\n    this._refuseForkNodeId(id);\n    if (this._stageMap.has(id)) {\n      const existing = this._stageMap.get(id);\n      if (existing !== fn) fail(`stageMap collision for id '${id}'`);\n    }\n    this._stageMap.set(id, fn);\n  }\n\n  _mergeStageMap(other: Map<string, StageFunction<TOut, TScope>>, prefix?: string) {\n    for (const [k, v] of other) {\n      const key = prefix ? joinPath(prefix, k) : k;\n      if (this._stageMap.has(key)) {\n        const existing = this._stageMap.get(key);\n        if (existing !== v) fail(`stageMap collision while mounting flowchart at '${key}'`);\n      } else {\n        this._stageMap.set(key, v);\n      }\n    }\n  }\n\n  /**\n   * Prefix a node tree with a subflow path segment at MOUNT time — the one\n   * prefixer, `engine/graph/prefixNodeTree.ts` (the traverser calls the same\n   * function at RUN time). Kept as the builder's door for its mount sites.\n   */\n  _prefixNodeTree(node: StageNode<TOut, TScope>, prefix: string): StageNode<TOut, TScope> {\n    return prefixNodeTree(node, prefix);\n  }\n\n  /**\n   * THE mount of a subflow chart under `id` (F10) — every eager mount site\n   * (`addSubFlowChart`, `addSubFlowChartNext`, a decider/selector\n   * `addSubFlowChartBranch`) goes through it, and it is the one caller of the\n   * prefixer. In order: register the chart's prefixed root under `id`;\n   * `place` the mount's own node + spec and fire its structure events; merge\n   * the chart's stage map under `id`; register its nested subflows under\n   * `id/<key>` (a key already registered is kept).\n   */\n  _mountSubflow(id: string, subflow: FlowChart<any, any>, place: () => void): void {\n    const prefixed = (root: StageNode<TOut, TScope>) => this._prefixNodeTree(root, id);\n    this._registerSubflowDef(id, prefixed(subflow.root));\n    place();\n    this._mergeStageMap(subflow.stageMap, id);\n    if (!subflow.subflows) return;\n    for (const [key, def] of Object.entries(subflow.subflows)) {\n      const prefixedKey = joinPath(id, key);\n      if (!this._subflowDefs.has(prefixedKey)) {\n        this._subflowDefs.set(prefixedKey, { root: prefixed(def.root as StageNode<TOut, TScope>) });\n      }\n    }\n  }\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Factory Function\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Start a flowchart with its first stage; returns a fluent builder.\n *\n * Chain `.addFunction()` / `.addDeciderFunction()` / `.addSelectorFunction()` /\n * `.addSubFlowChart()` etc. to add more stages, then finish with `.build()`.\n *\n * @param name    Human-readable display label for the stage (shown in the narrative/trace).\n * @param fn      The stage's work — a `(scope) => …` function, or a `PausableHandler` for human-in-the-loop pauses.\n * @param id      Stable stage id used in traces, the commit log, and `runtimeStageId`. Keep it unique within the chart.\n * @param options Optional `{ description?, structureRecorders? }`.\n *\n * @example\n * const chart = flowChart<State>('FetchUser', async (scope) => {\n *   scope.user = await getUser();\n * }, 'fetch-user')\n *   .addFunction('Process', processFn, 'process')\n *   .build();\n *\n * const trace = narrative();\n * const result = await chart.recorder(trace).run();\n * console.log(trace.getEntries().map((e) => e.text).join('\\n'));\n */\n// Overload 1: typed state with options object.\nexport function flowChart<TState extends object>(\n  name: string,\n  fn: TypedStageFunction<TState> | PausableHandler<TypedScope<TState>>,\n  id: string,\n  options?: FlowChartOptions,\n): FlowChartBuilder<any, TypedScope<TState>>;\n\n// Overload 2: explicit generics with options object.\nexport function flowChart<TOut = any, TScope = any>(\n  name: string,\n  fn: StageFunction<TOut, TScope> | PausableHandler<TScope>,\n  id: string,\n  options?: FlowChartOptions,\n): FlowChartBuilder<TOut, TScope>;\n\n// Single implementation — accepts the options bag (or undefined).\nexport function flowChart<TOut = any, TScope = any>(\n  name: string,\n  fn: StageFunction<TOut, TScope> | PausableHandler<TScope>,\n  id: string,\n  options?: FlowChartOptions,\n): FlowChartBuilder<TOut, TScope> {\n  const builder = new FlowChartBuilder<TOut, TScope>();\n  // Attach StructureRecorders BEFORE start() so the seed event fires through\n  // the normal dispatcher path (no replay needed). Iteration order matches\n  // array order, matching the fluent `.attachStructureRecorder()` chain\n  // semantics.\n  if (options?.structureRecorders) {\n    for (const rec of options.structureRecorders) {\n      builder.attachStructureRecorder(rec);\n    }\n  }\n  return builder.start(name, fn as any, id, options?.description, {\n    ...(options?.retry && { retry: options.retry }),\n    ...(options?.touches && { touches: options.touches }),\n    ...(options?.tags && { tags: options.tags }),\n  });\n}\n\n/**\n * Like `flowChart()`, but the ROOT stage is a SELECTOR — it runs first and\n * its branches attach directly to it (no separate seed stage). Returns a\n * `SelectorFnList`; declare branches then call `.end()` to get the builder\n * back for any subsequent stages.\n *\n * @example\n *   flowChartSelector<MyState>('Context', contextSelectorFn, 'context')\n *     .addSubFlowChartBranch('sf-system-prompt', sysSlot, 'System Prompt', {...})\n *     .addSubFlowChartBranch('sf-messages', msgSlot, 'Messages', {...})\n *     .end()\n *     .addFunction('messageAPI', assembleFn, 'message-api')\n *     .build();\n */\nexport function flowChartSelector<TOut = any, TScope = any>(\n  name: string,\n  fn: StageFunction<any, TScope>,\n  id: string,\n  options?: FlowChartOptions,\n): SelectorFnList<TOut, TScope> {\n  const builder = new FlowChartBuilder<TOut, TScope>();\n  if (options?.structureRecorders) {\n    for (const rec of options.structureRecorders) {\n      builder.attachStructureRecorder(rec);\n    }\n  }\n  return builder.startSelector(name, fn, id, options?.description, {\n    ...(options?.failFast !== undefined && { failFast: options.failFast }),\n    ...(options?.retry && { retry: options.retry }),\n    ...(options?.touches && { touches: options.touches }),\n    ...(options?.tags && { tags: options.tags }),\n  });\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Spec to StageNode Converter\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport function specToStageNode(spec: FlowChartSpec): StageNode<any, any> {\n  const inflate = (s: FlowChartSpec): StageNode<any, any> => ({\n    name: s.name,\n    id: s.id,\n    children: s.children?.length ? s.children.map(inflate) : undefined,\n    next: s.next ? inflate(s.next) : undefined,\n  });\n  return inflate(spec);\n}\n"]}