footprintjs 9.40.0 → 9.41.0

package/dist/esm/lib/runner/FlowChartExecutor.js

@@ -14,139 +14,55 @@
  *   // 2-param form (accepts a ScopeFactory directly, for backward compatibility):
  *   const executor = new FlowChartExecutor(chart, myFactory);
  *
+ *
+ * The executor composes four modules, one job each (F9): `attach.ts` (who
+ * observes a run), `resume.ts` (plan and announce a re-entry), `checkpoint.ts`
+ * (the pause checkpoint), `snapshot.ts` (what `getSnapshot()` serves). What
+ * stays here is the per-run state and the run lifecycle that threads it.
  *   const result = await executor.run({ input: data, env: { traceId: 'req-123' } });
  */
-import { deepFreeze } from '../capture/freeze.js';
 import { detachAndForget as _detachAndForget, detachAndJoinLater as _detachAndJoinLater } from '../detach/spawn.js';
-import { isDevMode } from '../devMode.js';
-import { ResumeEntry } from '../engine/handlers/ResumeEntry.js';
-import { servedSubflowResults } from '../engine/handlers/servedSubflowResults.js';
-import { CombinedNarrativeRecorder } from '../engine/narrative/CombinedNarrativeRecorder.js';
 import { ManifestFlowRecorder } from '../engine/narrative/recorders/ManifestFlowRecorder.js';
 import { FlowchartTraverser } from '../engine/traversal/FlowchartTraverser.js';
-import { resumeTraversalContext } from '../engine/traversalContext.js';
 import { defaultLogger, } from '../engine/types.js';
-import { buildRuntimeStageId, isExecutionKey } from '../ids/runtimeStageId.js';
 import { RedactionRule } from '../memory/redaction.js';
-import { pickDials, runPolicy } from '../memory/runPolicy.js';
-import { provideInterruptAnswer } from '../pause/interrupt.js';
-import { CHECKPOINT_VERSION, decodeCheckpoint } from '../pause/record.js';
-import { isPausedExecution, isPauseSignal } from '../pause/types.js';
-import { hasEmitRecorderMethods, hasFlowRecorderMethods, hasRecorderMethods } from '../recorder/CombinedRecorder.js';
-import { fire, recorderFailureEvent, warnInDevMode } from '../recorder/hooks.js';
-import { copyBundle } from '../recorder/snapshot.js';
-import { ScopeFacade } from '../scope/ScopeFacade.js';
-import { describeCheckpointCloneFailure, sanitizeDiagnosticBags } from './checkpointSanitize.js';
-import { DeferredObserverTier } from './DeferredObserverTier.js';
+import { runPolicy } from '../memory/runPolicy.js';
+import { isPauseSignal } from '../pause/types.js';
+import { RunObservers } from './attach.js';
+import { buildPauseCheckpoint } from './checkpoint.js';
 import { ExecutionRuntime } from './ExecutionRuntime.js';
+import { resolveExecutorArgs } from './options.js';
+import { announceResume, planResume, seedCounters } from './resume.js';
 import { generateRunId } from './runId.js';
+import { servedSnapshot } from './snapshot.js';
 import { validateInput } from './validateInput.js';
-/** Default scope factory — creates a plain ScopeFacade for each stage. */
-const defaultScopeFactory = (ctx, stageName, readOnly, env) => new ScopeFacade(ctx, stageName, readOnly, env);
-/**
- * The paused stage's stand-in for a resume: the stage's OWN node — so it keeps
- * its shape (a decider's or selector's branches, a fork parent's children,
- * its `next`) and its name, description and declared tags — with `fn` swapped
- * for the resume half.
- *
- * Dropped: `resumeFn` and `isPausable` (the resume half must not pause
- * because it returned a value — the original pausable contract); and, on the
- * `addPausableFunction` re-entry, the policies declared for the stage's OWN
- * function (`retry`, streaming) — that re-entry runs a different function
- * (`resumeFn`) under a different contract. The `interrupt()` re-entry re-runs
- * the stage's own function, so it keeps them.
- *
- * Tags follow the stage on BOTH re-entries (9.21.0): a tag is the stage's
- * NAME, not a policy over its function, and the resumed execution is that
- * stage running again — its bundle must carry it, or a chained axis would
- * show the paused leg tagged and the resumed leg silently not.
- */
-function standInFor(pausedNode, fn, isInterruptResume) {
-    const standIn = { ...pausedNode, fn };
-    delete standIn.resumeFn;
-    delete standIn.isPausable;
-    if (!isInterruptResume) {
-        delete standIn.retry;
-        delete standIn.isStreaming;
-        delete standIn.streamId;
-    }
-    return standIn;
-}
-/** The flow channel's isolation for the executor-made `onResume` (dev-mode warning, then skip). */
-const RESUME_FLOW_FAILURE = warnInDevMode('FlowChartExecutor');
-/**
- * The resume event's link, read off the checkpoint itself — so a resume records
- * the same wherever its checkpoint came from. `undefined` for a checkpoint
- * without `pausedExecution` (made before 9.37.0) or with a malformed one: the
- * link is a record, never used to plan the re-entry, so it is left out rather
- * than guessed.
- */
-function resumeLinkOf(checkpoint) {
-    const paused = checkpoint.pausedExecution;
-    return isPausedExecution(paused) ? { runId: paused.runId, runtimeStageId: paused.runtimeStageId } : undefined;
-}
 export class FlowChartExecutor {
     traverser;
-    /** Shared execution counter — survives pause/resume. Reset on fresh run(). */
+    /** Shared execution counter and per-stage visit counts (loopIteration) — shared BY
+     *  REFERENCE with every traverser of the run; survive pause/resume, reset on run(). */
     _executionCounter = { value: 0 };
-    /** Shared per-run visit counts (by stageId) driving TraversalContext.loopIteration.
-     *  Twin of _executionCounter: survives pause/resume, reset on fresh run(). */
     _visitCounts = new Map();
-    /** Per-`run()` identifier — generated fresh per run + per resume. Threaded
-     *  through every TraversalContext so recorders can scope state to a single
-     *  run. See `runId.ts`. */
+    /** Fresh per run() and per resume() — stamped on every TraversalContext (`runId.ts`). */
     _currentRunId = '';
-    narrativeEnabled = false;
-    narrativeOptions;
-    combinedRecorder;
-    flowRecorders = [];
-    scopeRecorders = [];
-    /**
-     * RFC-001 deferred-observer wiring — created LAZILY on the first
-     * `delivery: 'deferred'` attach. `undefined` for every executor that never
-     * opts in: zero allocation, zero per-event cost, byte-identical behavior
-     * (the emit fast-path precedent).
-     */
-    deferredTier;
+    /** Who observes the run — narrative, inline lists, deferred tier (`attach.ts`). */
+    observers = new RunObservers();
     redactionPolicy;
-    /**
-     * The run's ONE redaction rule (`memory/redaction.ts`): built fresh per
-     * `createTraverser` (per-call marks reset per run and per resume, as the
-     * shared set always did), installed on the runtime root so every context
-     * retains under it, and read by every `ScopeFacade` through its context.
-     */
+    /** The run's ONE redaction rule (`memory/redaction.ts`), built fresh per leg. */
     redactionRule = new RedactionRule();
     lastCheckpoint;
     /**
-     * `true` once `run()` (or a previous `resume()`) has executed on
-     * this instance. `resume()` branches on it:
-     *
-     *   • true  → reuse the constructor-time runtime (same-executor
-     *             continuity: execution tree, recorders, narrative
-     *             accumulate across pause/resume cycles)
-     *   • false → seed a fresh runtime from `checkpoint.sharedState`
-     *             (cross-executor / cross-process resume: new instance
-     *             reconstructed from a serialized checkpoint)
-     *
-     * Without this flag, fresh executors silently discarded the
-     * checkpoint's sharedState and resume handlers couldn't read pre-pause
-     * scope. See `test/lib/pause/cross-executor-resume.test.ts`.
+     * `true` once run() (or a resume) executed here. `resume()` branches on it:
+     * true → reuse the runtime (execution tree, recorders, narrative accumulate);
+     * false → seed a fresh runtime from `checkpoint.sharedState` (cross-executor
+     * resume). See `test/lib/pause/cross-executor-resume.test.ts`.
      */
     _hasRunBefore = false;
     /**
-     * Re-entrancy guard. `run()` and `resume()` mutate per-run instance state
-     * (traverser, runId, execution counter, checkpoint) and clear attached
-     * recorders — a second concurrent entry on the SAME executor would
-     * interleave runIds and cross-contaminate recorder/narrative state, and
-     * `getCheckpoint()` would return whichever run paused last. One executor =
-     * one in-flight execution; create an executor per concurrent run.
+     * Re-entrancy guard: run()/resume() mutate per-run state (traverser, runId,
+     * counters, checkpoint, recorders) — one executor = one in-flight execution.
      * See docs/guides/execution-model.md.
      */
     _isExecuting = false;
-    // SYNC REQUIRED: every optional field here must mirror FlowChartExecutorOptions
-    // AND be assigned in the constructor's options-resolution block (the `else if` branch).
-    // Adding a field to only one of the three places causes silent omission.
-    // (The dials ride `dials` whole — `pickDials` reads every one RunDials declares.)
     flowChartArgs;
     /**
      * Create a FlowChartExecutor.
@@ -165,142 +81,28 @@ export class FlowChartExecutor {
      * @param factoryOrOptions - A `ScopeFactory<TScope>` OR a `FlowChartExecutorOptions<TScope>` options object.
      */
     constructor(flowChart, factoryOrOptions) {
-        // Detect options-object form vs factory form
-        let scopeFactory;
-        let defaultValuesForContext;
-        let initialContext;
-        let readOnlyContext;
-        let throttlingErrorChecker;
-        let streamHandlers;
-        let scopeProtectionMode;
-        let dials = {};
-        if (typeof factoryOrOptions === 'function') {
-            // 2-param form: new FlowChartExecutor(chart, scopeFactory)
-            scopeFactory = factoryOrOptions;
-        }
-        else if (factoryOrOptions !== undefined) {
-            // Options object form
-            const opts = factoryOrOptions;
-            scopeFactory = opts.scopeFactory;
-            defaultValuesForContext = opts.defaultValuesForContext;
-            initialContext = opts.initialContext;
-            readOnlyContext = opts.readOnlyContext;
-            throttlingErrorChecker = opts.throttlingErrorChecker;
-            streamHandlers = opts.streamHandlers;
-            scopeProtectionMode = opts.scopeProtectionMode;
-            dials = pickDials(opts);
-        }
-        this.flowChartArgs = {
-            flowChart,
-            scopeFactory: scopeFactory ?? flowChart.scopeFactory ?? defaultScopeFactory,
-            defaultValuesForContext,
-            initialContext,
-            readOnlyContext,
-            throttlingErrorChecker,
-            streamHandlers,
-            scopeProtectionMode,
-            dials,
-        };
+        this.flowChartArgs = resolveExecutorArgs(flowChart, factoryOrOptions);
         this.traverser = this.createTraverser();
     }
     createTraverser(signal, readOnlyContextOverride, env, maxDepth, maxIterations, overrides) {
         const args = this.flowChartArgs;
         const fc = args.flowChart;
-        const narrativeFlag = this.narrativeEnabled || (fc.enableNarrative ?? false);
-        // ── Composed scope factory ─────────────────────────────────────────
-        // Collect all scope modifiers (recorders, redaction) into a single list,
-        // then create ONE factory that applies them in a loop. Replaces the
-        // previous 4-deep closure nesting with a flat, debuggable composition.
-        if (overrides?.preserveRecorders) {
-            // Resume mode: keep existing combinedRecorder so narrative accumulates
-        }
-        else if (narrativeFlag) {
-            this.combinedRecorder = new CombinedNarrativeRecorder(this.narrativeOptions);
-        }
-        else {
-            this.combinedRecorder = undefined;
-        }
+        const narrativeFlag = this.observers.startLeg(fc.enableNarrative ?? false, overrides?.preserveRecorders === true);
         this.redactionRule = new RedactionRule(this.redactionPolicy);
-        const modifiers = [];
-        // 1. Narrative recorder (if enabled)
-        if (this.combinedRecorder) {
-            const recorder = this.combinedRecorder;
-            modifiers.push((scope) => {
-                if (typeof scope.attachScopeRecorder === 'function')
-                    scope.attachScopeRecorder(recorder);
-            });
-        }
-        // 2. User-provided scope recorders
-        if (this.scopeRecorders.length > 0) {
-            const recorders = this.scopeRecorders;
-            modifiers.push((scope) => {
-                if (typeof scope.attachScopeRecorder === 'function') {
-                    for (const r of recorders)
-                        scope.attachScopeRecorder(r);
-                }
-            });
-        }
-        // 2b. Deferred-observer scope tap (RFC-001 Block 7) — a synthetic
-        // recorder whose hooks CAPTURE into the bounded queue instead of doing
-        // observer work. It rides the same per-stage recorder list as inline
-        // recorders, so it receives exactly the post-redaction events they do.
-        // Absent (zero work, identical list) when nobody opted into deferral.
-        const scopeTap = this.deferredTier?.buildScopeTap();
-        if (scopeTap) {
-            modifiers.push((scope) => {
-                if (typeof scope.attachScopeRecorder === 'function')
-                    scope.attachScopeRecorder(scopeTap);
-            });
-        }
-        // 3. Redaction policy (conditional — only when policy is set). A
-        // `ScopeFacade` already reads the run's rule through its context (the
-        // rule is installed on the runtime root below); this call is the legacy
-        // protocol for custom scopes that are not facades, and on a facade it
-        // re-states the executor's policy on the shared rule (a no-op).
-        if (this.redactionPolicy) {
-            const policy = this.redactionPolicy;
-            modifiers.push((scope) => {
-                if (typeof scope.useRedactionPolicy === 'function') {
-                    scope.useRedactionPolicy(policy);
-                }
-            });
-        }
-        // Compose: base factory + modifiers in a single pass.
-        // The marked-keys set is ALWAYS wired up (unconditional — ensures cross-stage
-        // propagation even without a policy, because stages can call setValue(key, val, true)
-        // for per-call redaction). Optional modifiers (recorders, policy) are in the list.
-        const baseFactory = args.scopeFactory;
-        const sharedRedactedKeys = this.redactionRule.markedKeys();
-        const scopeFactory = ((ctx, stageName, readOnly, envArg) => {
-            const scope = baseFactory(ctx, stageName, readOnly, envArg);
-            // Always wire shared redaction state
-            if (typeof scope.useSharedRedactedKeys === 'function') {
-                scope.useSharedRedactedKeys(sharedRedactedKeys);
-            }
-            // Apply optional modifiers
-            for (const mod of modifiers)
-                mod(scope);
-            return scope;
-        });
+        // ONE factory: the base factory, then every scope modifier (recorders,
+        // deferred tap, redaction) in a flat pass — see `RunObservers`.
+        const scopeFactory = this.observers.composeScopeFactory(args.scopeFactory, this.redactionPolicy, this.redactionRule.markedKeys());
         // The first stage this traversal runs: the resume's entry, else the chart root.
         const effectiveRoot = overrides?.resume?.start ?? fc.root;
         const effectiveInitialContext = overrides?.initialContext ?? args.initialContext;
-        // The run's policy (F5): the four dials, the redaction rule and the
-        // mirror flag as ONE frozen object, built once per leg — run AND resume
-        // (a resume brings a fresh rule, as per-call marks reset per leg). The
-        // runtime installs it on its root; every frame of the run, a subflow's
-        // included, holds the same reference. The rule is installed even without
-        // a policy: a per-call `setValue(key, value, true)` marks the key on it,
-        // and the paths that bypass the facade (subflow seed, outputMapper
-        // merge-back, resume re-seed) honour that mark through it. The mirror —
-        // a parallel redacted heap, so `getSnapshot({ redact: true })` is served
-        // at zero post-pass cost — is kept only under a policy.
+        // The run's policy (F5): the dials, the rule (installed even without a
+        // policy — per-call `setValue(k, v, true)` marks live on it) and the mirror
+        // flag (a redacted heap, kept only under a policy), ONE frozen object per
+        // leg that every frame of the run holds by reference.
         const policy = runPolicy(args.dials, this.redactionRule, this.redactionPolicy !== undefined);
         let runtime;
         if (overrides?.existingRuntime) {
-            // Resume mode: reuse existing runtime so execution tree continues from pause point.
-            // Preserve the original root for getSnapshot() (full tree), then advance
-            // rootStageContext to a continuation from the leaf (for traversal).
+            // Same-executor resume: the tree continues from the leaf; getSnapshot() keeps the full tree.
             runtime = overrides.existingRuntime;
             runtime.preserveSnapshotRoot();
             let leaf = runtime.rootStageContext;
@@ -313,9 +115,7 @@ export class FlowChartExecutor {
             runtime = new ExecutionRuntime(effectiveRoot.name, effectiveRoot.id, args.defaultValuesForContext, effectiveInitialContext, policy);
         }
         return new FlowchartTraverser({
-            // Always the REAL chart — every id (loop targets, a re-visit of the
-            // paused stage) resolves against it. A resume only moves where the
-            // traversal STARTS (`entry`), once.
+            // Always the REAL chart; a resume only moves where the traversal STARTS, once.
             root: fc.root,
             ...(overrides?.resume?.start && { entry: overrides.resume.start }),
             ...(overrides?.resume?.startPendingPauses && { pendingPauses: overrides.resume.startPendingPauses }),
@@ -333,7 +133,7 @@ export class FlowChartExecutor {
             logger: fc.logger ?? defaultLogger,
             signal,
             executionEnv: env,
-            flowRecorders: this.buildFlowRecordersList(),
+            flowRecorders: this.observers.flowRecordersList(),
             executionCounter: this._executionCounter,
             visitCounts: this._visitCounts,
             runId: this._currentRunId,
@@ -342,9 +142,7 @@ export class FlowChartExecutor {
         });
     }
     enableNarrative(options) {
-        this.narrativeEnabled = true;
-        if (options)
-            this.narrativeOptions = options;
+        this.observers.enableNarrative(options);
     }
     /**
      * Set a declarative redaction policy that applies to all stages.
@@ -354,32 +152,15 @@ export class FlowChartExecutor {
         this.redactionPolicy = policy;
         this.redactionRule = new RedactionRule(policy);
     }
-    /**
-     * Set the read-tracking policy for `StageSnapshot.stageReads` (#14).
-     * Must be called before run(). Equivalent to the `readTracking`
-     * constructor option — see {@link FlowChartExecutorOptions.readTracking}
-     * for the mode semantics ('full' default / 'summary' / 'off').
-     */
+    /** The `readTracking` dial (see {@link FlowChartExecutorOptions.readTracking}). Call before run(). */
     setReadTracking(mode) {
         this.flowChartArgs.dials = { ...this.flowChartArgs.dials, readTracking: mode };
     }
-    /**
-     * Set the write-tracking policy for `StageSnapshot.stageWrites` (#13c-A).
-     * Must be called before run(). Equivalent to the `writeTracking`
-     * constructor option — see {@link FlowChartExecutorOptions.writeTracking}
-     * for the mode semantics ('full' default / 'summary' / 'off'), the
-     * onCommit-payload consequence, and the redaction-precedence rule.
-     */
+    /** The `writeTracking` dial (see {@link FlowChartExecutorOptions.writeTracking}). Call before run(). */
     setWriteTracking(mode) {
         this.flowChartArgs.dials = { ...this.flowChartArgs.dials, writeTracking: mode };
     }
-    /**
-     * Set the commit-values encoding policy for the commit log (#13c-B).
-     * Must be called before run(). Equivalent to the `commitValues`
-     * constructor option — see {@link FlowChartExecutorOptions.commitValues}
-     * for the mode semantics ('full' default / 'delta'), the verb-qualified
-     * `overwrite` consequence, and the `commitValueAt` migration helper.
-     */
+    /** The `commitValues` dial (see {@link FlowChartExecutorOptions.commitValues}). Call before run(). */
     setCommitValues(mode) {
         this.flowChartArgs.dials = { ...this.flowChartArgs.dials, commitValues: mode };
     }
@@ -395,12 +176,9 @@ export class FlowChartExecutor {
      * Returns the checkpoint from the most recent paused execution, or `undefined`
      * if the last run completed without pausing.
      *
-     * The checkpoint is JSON-serializable — store it in Redis, Postgres, localStorage, etc.
-     *
-     * It is fully DETACHED from engine state: every field was deep-copied at
-     * pause time (see `buildPauseCheckpoint`). Holding, mutating, or persisting
-     * it cannot affect the executor, and a later same-executor resume cannot
-     * mutate a checkpoint you already stored.
+     * JSON-serializable (store it in Redis, Postgres, localStorage…) and fully
+     * DETACHED from engine state (`checkpoint.ts`): mutating or persisting it
+     * cannot affect the executor, nor a later resume a checkpoint you stored.
      *
      * @example
      * ```typescript
@@ -427,14 +205,8 @@ export class FlowChartExecutor {
      *
      * Returns 0 before any run; after, returns the cumulative commit
      * count across the executor's lifetime (including resumes).
-     *
-     * IMPLEMENTATION NOTE: this returns `runtime.executionHistory.length`,
-     * which is the same value as `getSnapshot().commitLog.length`. The
-     * naming asymmetry is historical — the underlying `EventLog` field
-     * is named `executionHistory` but stores the `CommitBundle[]` that
-     * `commitLog` exposes. They always report the same LENGTH (verified by the
-     * "matches commitLog.length" integration test); since 9.17.0 the snapshot
-     * serves a detached frozen COPY of the array, not the live one.
+     * Always equals `getSnapshot().commitLog.length` (the log is the
+     * `EventLog`'s `executionHistory`; the snapshot serves a frozen copy).
      */
     getCommitCount() {
         const runtime = this.traverser.getRuntime();
@@ -443,25 +215,16 @@ export class FlowChartExecutor {
     /**
      * Resume a paused flowchart from a checkpoint.
      *
-     * Restores the scope state, calls the paused stage's `resumeFn` with the
-     * provided input (or, for an `interrupt()` pause, re-runs the stage with the
-     * answer), then continues with whatever ran after that stage on the run —
-     * its own `next`, or the continuation of the decider, selector or fork that
-     * dispatched it, at every level of the pause path — and from there walks the
-     * chart as built. When parallel siblings paused in the same fan-out
-     * (`checkpoint.pendingPauses`), the run pauses again with the next sibling's
-     * question once this one's branch is done; the fan-out's join runs after the
-     * last answer. See `ResumeEntry` (`footprintjs/advanced`).
-     *
-     * The checkpoint can come from `getCheckpoint()` on a previous run, or from
-     * a serialized checkpoint stored in Redis/Postgres/localStorage.
+     * Restores the scope state, runs the paused stage's `resumeFn` with the input
+     * (an `interrupt()` pause re-runs the stage with the answer), then continues
+     * with whatever ran after that stage on the run — its `next`, or its
+     * dispatcher's continuation, at every level of the pause path. Parallel
+     * siblings that paused together (`checkpoint.pendingPauses`) are asked in
+     * turn; the join runs after the last answer. See `ResumeEntry`.
      *
-     * **Recorder/narrative state depends on the resume mode.** Resuming on the SAME
-     * executor that ran preserves and accumulates narrative/metrics/debug across the
-     * pause/resume cycle (preserveRecorders). Resuming on a FRESH executor
-     * (reconstructed from a stored checkpoint) starts with empty recorder state —
-     * collect what you need before discarding the paused executor. A fresh `runId`
-     * is generated either way.
+     * The checkpoint comes from `getCheckpoint()` or from storage. On the SAME
+     * executor, narrative/recorder state accumulates across the pause; on a
+     * FRESH executor it starts empty. A fresh `runId` either way.
      *
      * @example
      * ```typescript
@@ -476,602 +239,125 @@ export class FlowChartExecutor {
      * ```
      */
     async resume(checkpoint, resumeInput, options) {
-        // Re-entrancy guard FIRST — resume() mutates the same per-run state run()
-        // does (traverser, runId, checkpoint), so resume-during-run and
-        // double-resume are the same corruption class as concurrent run().
-        if (this._isExecuting) {
-            throw new Error('FlowChartExecutor: resume() called while another run()/resume() is in flight on this ' +
-                'executor. An executor holds per-run state (runId, recorders, checkpoint) — create ' +
-                'one executor per concurrent run. See docs/guides/execution-model.md.');
-        }
-        // ── Decode the checkpoint (may come from untrusted external storage, from
-        // any release) — the ONE codec: upcast, then check every pause record
-        // (`pause/record.ts`). (lastCheckpoint is wiped AFTER this — a rejected
-        // checkpoint must not destroy the executor's existing checkpoint state.)
-        checkpoint = decodeCheckpoint(checkpoint);
-        // Find the paused node in the graph
-        const pausedNode = this.findNodeInGraph(checkpoint.pausedStageId, checkpoint.subflowPath);
-        if (!pausedNode) {
-            throw new Error(`Cannot resume: stage '${checkpoint.pausedStageId}' not found in flowchart. ` +
-                'The chart may have changed since the checkpoint was created.');
-        }
-        // Two re-entry shapes, chosen by HOW the pause was raised:
-        //
-        //   • interrupt()      → RE-RUN THE STAGE'S OWN FUNCTION FROM ITS TOP.
-        //     Stages are atomic (the same law `resumeOnError` states): a stage that
-        //     stopped mid-body has no half to resume into, so the whole body runs
-        //     again and the answer comes back out of the `interrupt()` call itself.
-        //     Everything the body did before the interrupt is re-done — which is
-        //     why the docs tell you to keep that half idempotent.
-        //   • addPausableFunction → run the declared `resumeFn`.
-        //
-        // The discriminant is on the checkpoint, so this works cross-executor
-        // (a checkpoint restored from Redis on a fresh process resumes the same way).
-        const isInterruptResume = checkpoint.pausedBy === 'interrupt';
-        if (!pausedNode.resumeFn && !isInterruptResume) {
-            throw new Error(`Cannot resume: stage '${pausedNode.name}' (${pausedNode.id}) has no resumeFn. ` +
-                'Only stages created with addPausableFunction(), or stages that paused via interrupt(), can be resumed.');
-        }
-        // The resume half — what the paused stage's stand-in runs.
-        // resumeFn signature is (scope, input) per PausableHandler — wrap to match StageFunction(scope, breakFn).
-        let resumeStageFn;
-        if (isInterruptResume) {
-            const originalFn = pausedNode.fn ??
-                this.flowChartArgs.flowChart.stageMap.get(pausedNode.id) ??
-                this.flowChartArgs.flowChart.stageMap.get(pausedNode.name);
-            if (!originalFn) {
-                throw new Error(`Cannot resume: stage '${pausedNode.name}' (${pausedNode.id}) paused via interrupt() but its ` +
-                    'stage function is no longer in the chart. The chart may have changed since the checkpoint ' +
-                    'was created.');
-            }
-            resumeStageFn = (scope, breakFn, streamCallback) => {
-                // Deposit the answer for THIS scope instance before the body runs, so
-                // the `interrupt()` call that threw last time returns it this time.
-                // Keyed by scope identity — safe when several branches resume at once.
-                provideInterruptAnswer(scope, resumeInput);
-                return originalFn(scope, breakFn, streamCallback);
-            };
-        }
-        else {
-            const resumeFn = pausedNode.resumeFn;
-            resumeStageFn = (scope) => {
-                return resumeFn(scope, resumeInput);
-            };
-        }
-        // The paused stage's STAND-IN: the stage's OWN node — id, name,
-        // description, tags, and its shape (a decider's branches, a selector's, a
-        // fork parent's children, its `next`) — with its function swapped for the
-        // resume half. Built from the whole node so an `interrupt()` raised inside
-        // a decider, selector or fork-parent function DISPATCHES on resume, as the
-        // stage did on the run (before 9.28.0 only fn/next/tags/retry were copied
-        // and the dispatch was silently skipped). It is where the resumed
-        // traversal starts — and nothing else: it is never in a node map or the
-        // subflow dictionary, so a loop back to the paused id finds the REAL
-        // stage, which pauses again (see ResumeEntry). What runs after it — its
-        // own `next`, else its dispatcher's continuation — is attached by
-        // `ResumeEntry.plan`, from the chart.
-        const standIn = standInFor(pausedNode, resumeStageFn, isInterruptResume);
-        // Where the resume re-enters, planned against the chart as built:
-        //
-        //   • TOP-LEVEL PAUSE (subflowPath empty): the resumed traversal starts
-        //     at the stand-in.
-        //   • PAUSE INSIDE SUBFLOWS: it starts at the mount of the first subflow
-        //     on the path, so the outputMappers and the parent's continuation
-        //     run. Each subflow on the path is entered ONCE through its hop: its
-        //     nested runtime is seeded from its capture (in place of the
-        //     inputMapper's values) and its traversal starts at the mount of the
-        //     next subflow — or, at the leaf, at the stand-in. An outer subflow's
-        //     stages before that mount do not run again.
-        //   • AT EVERY LEVEL the entry carries what its dispatcher would have run
-        //     after it — a decider's `next`, a selector's, a fork's join — so a
-        //     subflow mounted as a branch or a fork child hands control back to
-        //     its parent's continuation at the parent's level.
-        //   • Parallel siblings that paused in the same fan-out wait in
-        //     `checkpoint.pendingPauses`: each is raised again in turn, and the
-        //     join runs only once the last one is resumed.
-        //
-        // Everything else walks the REAL chart: `fc.root` and `fc.subflows` are
-        // untouched, so every later loop target and every later subflow entry
-        // (real root, inputMapper) resolves as it would on a run. Refused HERE —
-        // before any state is touched — when the checkpoint's path does not fit
-        // this chart.
-        //
-        // Clone-in: the captures seed nested runtimes (shallow-merged into each
-        // nested SharedMemory), so without a copy the engine would hold live
-        // references into the caller's checkpoint object — caller mutations would
-        // bleed into the resumed run and engine writes would reach a checkpoint
-        // the caller may have already persisted. The same for the waiting
-        // siblings' captures.
-        const fc = this.flowChartArgs.flowChart;
-        const resumeEntry = ResumeEntry.plan({
-            root: fc.root,
-            subflows: fc.subflows,
-            path: checkpoint.subflowPath,
-            captures: structuredClone(checkpoint.subflowStates),
-            standIn,
-            ...(checkpoint.pendingPauses !== undefined && { pendingPauses: structuredClone(checkpoint.pendingPauses) }),
-        });
-        // ── Seed the shared execution counter + per-stage visit counts ──
-        //
-        // Only now — every refusal above (the checkpoint's shape, the paused
-        // stage, the plan) leaves the executor exactly as it was. MUST run before
-        // the counter is READ below (the stand-in's runtimeStageId for
-        // `onResume`) AND before createTraverser() hands the traverser these
-        // objects BY REFERENCE. Seeding keeps runtimeStageIds unique and
-        // loopIteration monotonic across a CROSS-executor resume (a fresh
-        // executor starts both at 0/empty; the checkpoint carries the pause-time
-        // values).
-        //
-        // MUTATE, never REPLACE: `_executionCounter` and `_visitCounts` are shared
-        // by reference into the traverser (and, transitively, every subflow
-        // traverser — see FlowchartTraverser's sub-traverser factory). Assigning a
-        // fresh object here would sever that shared reference. Both fields are
-        // optional on the checkpoint (older persisted checkpoints omit them) — skip
-        // seeding when absent, preserving the previous behavior. Same-executor
-        // resume is idempotent: at pause the instance values already equal the
-        // checkpoint's, so re-seeding them changes nothing.
-        if (checkpoint.executionCount !== undefined) {
-            this._executionCounter.value = checkpoint.executionCount;
-        }
-        if (checkpoint.visitCounts) {
-            this._visitCounts.clear();
-            for (const [stageId, count] of Object.entries(checkpoint.visitCounts)) {
-                this._visitCounts.set(stageId, count);
-            }
-        }
-        // (Wiped only now: every refusal above leaves the executor's existing
-        // checkpoint untouched.)
+        this.assertIdle('resume');
+        // Every refusal happens in the plan — before any state below is touched,
+        // so a rejected checkpoint leaves the executor (and its checkpoint) as it was.
+        const plan = planResume(this.flowChartArgs.flowChart, checkpoint, resumeInput);
+        // MUST precede the counter read in `announceResume` and the traverser,
+        // which takes both counters BY REFERENCE.
+        seedCounters(plan.checkpoint, this._executionCounter, this._visitCounts);
         this.lastCheckpoint = undefined;
-        // Don't clear recorders — resume continues from previous state.
-        // Narrative, metrics, debug entries accumulate across pause/resume.
-        //
-        // Two-mode resume:
-        //   • Same-executor (run() previously called on THIS instance):
-        //     reuse the existing runtime so the execution tree continues
-        //     from the pause point and recorders/narrative accumulate.
-        //   • Cross-executor (fresh executor reconstructed from a stored
-        //     checkpoint): seed a NEW runtime from `checkpoint.sharedState`
-        //     so resume handlers can read pre-pause scope. The execution
-        //     tree starts at the resume entry — we don't have the previous
-        //     traversal's tree on a fresh process anyway.
-        const sameExecutor = this._hasRunBefore;
-        const existingRuntime = sameExecutor
+        // Same executor: reuse the runtime. Fresh executor: seed a NEW one from
+        // `checkpoint.sharedState`. Either way a NEW runId (a distinct logical run).
+        const existingRuntime = this._hasRunBefore
             ? this.traverser.getRuntime()
             : undefined;
         this._hasRunBefore = true; // any path that resumes counts as a run
-        // Resume gets a NEW runId — resume is logically a distinct run.
-        // Original runId is recoverable from checkpoint metadata if a consumer
-        // needs cross-run audit (we don't store it on the checkpoint today;
-        // future enhancement). See `runId.ts`.
         this._currentRunId = generateRunId();
-        // Initial context: `checkpoint.sharedState` — the top level's view at the
-        // pause (a subflow's outputMapper writes back into it). Same-executor, the
-        // existing runtime is reused and this is moot, but passed for consistency.
-        // Clone-in for the same reason as the captures: `initialContext` seeds
-        // the fresh SharedMemory via `mergeContextWins`, which copies only the TOP
-        // level — nested objects would alias the caller's checkpoint.
-        const resumeInitialContext = structuredClone(checkpoint.sharedState);
         this.traverser = this.createTraverser(options?.signal, undefined, options?.env, options?.maxDepth, options?.maxIterations, {
-            initialContext: resumeInitialContext,
+            // Clone-in: `initialContext` seeds the fresh SharedMemory with a
+            // top-level-only merge — nested objects would alias the caller's checkpoint.
+            initialContext: structuredClone(plan.checkpoint.sharedState),
             preserveRecorders: true,
             ...(existingRuntime ? { existingRuntime } : {}),
-            resume: resumeEntry,
+            resume: plan.entry,
+        });
+        // Before the traversal on purpose: `onResume` precedes `onRunStart`.
+        announceResume(plan, resumeInput, {
+            runId: this._currentRunId,
+            executionCount: this._executionCounter.value,
+            observers: this.observers,
         });
-        // Fire onResume event on all recorders (flow + scope). Stamp the
-        // synthetic TraversalContext for the resumed stage with the NEW
-        // runId so consumers detect "this is a fresh logical run" via
-        // the same runId-change pattern they use for `onRunStart`. The stamp is
-        // built by the one constructor (`engine/traversalContext.ts`): it names the
-        // REAL subflow the stand-in runs in and its depth, and LINKS to the paused
-        // execution (`resumedFrom`, read off `checkpoint.pausedExecution`) — 9.37.0.
-        //
-        // The runtimeStageId is the STAND-IN's own: it runs after one mount per
-        // subflow on the path (each entered at its mount), so its execution index
-        // is the counter plus the path's length — the event and the stand-in's
-        // commit name the same execution. (Fired before the traversal on purpose:
-        // `onResume` precedes `onRunStart`, which recorders rely on to adopt the
-        // new runId without resetting.) The one shape where the index cannot be
-        // known up front — a degraded checkpoint missing an OUTER subflow's
-        // capture, whose opening stages then re-run — names the planned position.
-        const hasInput = resumeInput !== undefined;
-        const stepsBeforeStandIn = resumeEntry.stepsBeforeStandIn ?? checkpoint.subflowPath.length;
-        const resumeRuntimeStageId = buildRuntimeStageId(pausedNode.id, this._executionCounter.value + stepsBeforeStandIn);
-        const resumedFrom = resumeLinkOf(checkpoint);
-        const flowResumeEvent = {
-            stageName: pausedNode.name,
-            stageId: pausedNode.id,
-            hasInput,
-            traversalContext: resumeTraversalContext({
-                runId: this._currentRunId,
-                stageId: pausedNode.id,
-                stageName: pausedNode.name,
-                runtimeStageId: resumeRuntimeStageId,
-                subflowPath: checkpoint.subflowPath,
-                resumedFrom,
-            }),
-            channel: 'flow',
-        };
-        // Executor-made (`HOOKS.onResume.executorMade`): fired through the same `fire` loop as every
-        // engine event, so a throwing recorder is isolated instead of rejecting `resume()` (R10).
-        const flowListeners = this.combinedRecorder ? [this.combinedRecorder, ...this.flowRecorders] : this.flowRecorders;
-        fire(flowListeners, 'onResume', flowResumeEvent, RESUME_FLOW_FAILURE);
-        const scopeResumeEvent = {
-            stageName: pausedNode.name,
-            stageId: pausedNode.id,
-            runtimeStageId: resumeRuntimeStageId,
-            hasInput,
-            ...(resumedFrom && { resumedFrom }),
-            pipelineId: '',
-            timestamp: Date.now(),
-            channel: 'scope',
-        };
-        fire(this.scopeRecorders, 'onResume', scopeResumeEvent, (error, _recorder, hook) => 
-        // The scope channel's policy (as `ScopeFacade` routes a stage's hook failure): the throw
-        // becomes an `onError` on every scope recorder, whose own throw is dropped.
-        fire(this.scopeRecorders, 'onError', recorderFailureEvent(scopeResumeEvent, error, hook)));
-        // Deferred tier (RFC-001): these executor-synthesized onResume events
-        // bypass the per-stage dispatch sites, so capture them directly.
-        if (this.deferredTier) {
-            this.deferredTier.capture('flow', 'onResume', resumeRuntimeStageId, this._currentRunId, flowResumeEvent);
-            this.deferredTier.capture('scope', 'onResume', scopeResumeEvent.runtimeStageId, scopeResumeEvent.pipelineId, scopeResumeEvent);
-        }
         // Set AFTER all sync validation/lookup throws above (nothing can leak the
         // flag); no await between the top-of-method check and here, so race-free.
         this._isExecuting = true;
         try {
             const result = await this.traverser.execute();
             // Terminal flush (RFC-001 Block 8) — same boundary contract as run().
-            this.deferredTier?.terminalFlush();
+            this.observers.deferredTier?.terminalFlush();
             return result;
         }
         catch (error) {
-            this.deferredTier?.terminalFlush();
-            if (isPauseSignal(error)) {
-                this.lastCheckpoint = this.buildPauseCheckpoint(error);
-                return { paused: true, checkpoint: this.lastCheckpoint };
-            }
-            throw error;
+            return this.pausedOrThrow(error);
         }
         finally {
             this._isExecuting = false;
         }
     }
     /**
-     * Build a fully DETACHED checkpoint from a caught PauseSignal.
-     *
-     * Every field is deep-copied via one `structuredClone` of the assembled
-     * checkpoint, because the raw pieces alias live engine state:
-     *
-     *   - `sharedState` IS `SharedMemory`'s current generation — never edited,
-     *     but (copy-on-write, 9.29.0) every later generation shares its
-     *     unchanged subtrees, so a checkpoint that aliased it would alias the
-     *     resumed run's state too.
-     *   - `executionTree` nodes are fresh, but their `logs`/`errors`/`metrics`/
-     *     `evals`/`stageReads`/`flowMessages` fields reference live
-     *     `DiagnosticCollector` bags that keep accumulating on same-executor
-     *     resume.
-     *   - `subflowStates` values are shallow copies whose NESTED objects alias
-     *     subflow memory, and they get seeded back into live runtimes on resume.
-     *   - `subflowResults` values stay referenced by the traverser's results map.
-     *
-     * The checkpoint is persisted by contract ("store in Redis/Postgres") — it
-     * must never share structure with the engine. Pause is not a hot path; the
-     * clone cost is irrelevant.
-     *
-     * The JSON-safe checkpoint contract (no functions, no class instances)
-     * governs CONSUMER-owned data — but the executionTree's diagnostic bags
-     * accept ANY value at write time without cloning ($debug/$error/$metric/
-     * $eval store raw references), so a contract-compliant run can still carry
-     * a non-cloneable diagnostic. Observability side-bags never abort traversal
-     * anywhere else in the library, so they must not abort the pause either:
-     * on clone failure we sanitize the diagnostic bags (non-cloneable values
-     * become '[non-serializable: …]' markers — the live engine bags are never
-     * touched) and retry. If the retry STILL fails, the violation is in
-     * consumer-owned data (realistically `pauseData` — a function can never
-     * reach shared state in the first place: TransactionBuffer clones every
-     * written value at write time, so the offending write already rejected)
-     * and we throw a DESCRIPTIVE contract error naming the offending
-     * checkpoint field(s). A naked DataCloneError never escapes.
-     *
-     * Subflow scope capture (`subflowStates`) survives ONLY on the signal — the
-     * nested runtimes are GC'd as the stack unwinds. Promoting it onto the
-     * checkpoint here lets cross-executor resume restore pre-pause subflow
-     * scope (e.g. an Agent's `scope.history`). Empty `{}` for root-level pauses.
-     */
-    buildPauseCheckpoint(signal) {
-        // Every pause that paused in THIS run is named by it; a sibling raised again
-        // on resume keeps the run it originally paused in.
-        signal.completeExecution(this._currentRunId);
-        const snapshot = this.traverser.getSnapshot();
-        const sfResults = this.traverser.getSubflowResults();
-        // Lean subflowResults for the checkpoint (design: docs/design/subflow-commit-visibility.md):
-        //   • DROP the per-iteration mount-runtimeStageId keys ('#') that the snapshot dual-keys —
-        //     they would DOUBLE the checkpoint, and resume restores scope from `subflowStates`, not these.
-        //   • STRIP each subflow's `treeContext.history` — resume NEVER reads `subflowResults` (it
-        //     restores from `subflowStates` + `sharedState`), so the per-subflow commit log is pure
-        //     checkpoint bloat. The flat agent's checkpoint carries no commit history either → symmetric.
-        const leanSubflowResults = {};
-        for (const [key, value] of sfResults) {
-            if (isExecutionKey(key))
-                continue; // per-iteration keys are snapshot-only
-            const v = value;
-            if (v?.treeContext) {
-                const treeCtxRest = {};
-                for (const ck of Object.keys(v.treeContext)) {
-                    if (ck !== 'history')
-                        treeCtxRest[ck] = v.treeContext[ck]; // strip the per-subflow commit log
-                }
-                leanSubflowResults[key] = { ...value, treeContext: treeCtxRest };
-            }
-            else {
-                leanSubflowResults[key] = value;
-            }
-        }
-        const checkpoint = {
-            // The format (9.39.0) — read back by `pause/record.ts · decodeCheckpoint`.
-            checkpointVersion: CHECKPOINT_VERSION,
-            sharedState: snapshot.sharedState,
-            executionTree: snapshot.executionTree,
-            pausedStageId: signal.stageId,
-            // The paused EXECUTION (9.37.0) — a queued sibling raised on resume
-            // carries the run it ORIGINALLY paused in.
-            ...(signal.pausedExecution && { pausedExecution: signal.pausedExecution }),
-            subflowPath: signal.subflowPath,
-            pauseData: signal.pauseData,
-            subflowStates: signal.subflowStates,
-            // Counter continuity — seeded back in resume() so runtimeStageIds stay
-            // unique and loopIteration stays monotonic across a CROSS-executor resume
-            // (both are plain number/record, so they ride the single structuredClone
-            // below untouched). See test/lib/pause/resume-execution-counter-continuity.test.ts.
-            executionCount: this._executionCounter.value,
-            visitCounts: Object.fromEntries(this._visitCounts),
-            ...(Object.keys(leanSubflowResults).length > 0 && { subflowResults: leanSubflowResults }),
-            // Invoker context — collected during traversal bubble-up (not tree-walked).
-            // (`continuationStageId` is legacy-only since 9.39.0: no longer written.)
-            ...(signal.invokerStageId && { invokerStageId: signal.invokerStageId }),
-            // Parallel siblings' pauses from the same fan-out, waiting their turn
-            // (9.28.0). Absent when only one child paused — the shape every
-            // earlier checkpoint has.
-            ...(signal.pendingPauses.length > 0 && { pendingPauses: signal.pendingPauses }),
-            // HOW the pause was raised. One checkpoint shape, one extra optional
-            // field — an interrupt() pause is not a second kind of checkpoint, it is
-            // the same checkpoint that resume() re-enters differently (stage top vs
-            // resumeFn). Absent for every pre-9.14.0 checkpoint, which is correct.
-            ...(signal.pausedBy && { pausedBy: signal.pausedBy }),
-            pausedAt: Date.now(),
-        };
-        try {
-            return structuredClone(checkpoint);
-        }
-        catch {
-            // Non-cloneable diagnostics must not swallow the pause — sanitize the
-            // executionTree's bags (markers replace the offenders) and retry.
-            try {
-                checkpoint.executionTree = sanitizeDiagnosticBags(checkpoint.executionTree);
-                return structuredClone(checkpoint);
-            }
-            catch (retryError) {
-                // Genuine JSON-safe contract violation in consumer-owned data.
-                throw describeCheckpointCloneFailure(checkpoint, retryError);
-            }
-        }
-    }
-    /**
-     * Find a StageNode in the compiled graph by ID.
-     * Handles subflow paths by drilling into registered subflows.
+     * The settle of a leg that threw: flush the deferred tier (the OUTERMOST
+     * handler — a pause re-throws through subflow traversers without exit
+     * events, so per-traverser hooks would miss it), then turn a pause into a
+     * detached checkpoint (`checkpoint.ts`) and a `PausedResult`; anything else
+     * is rethrown.
      */
-    findNodeInGraph(stageId, subflowPath) {
-        const fc = this.flowChartArgs.flowChart;
-        if (subflowPath.length === 0) {
-            // Top-level: DFS from root
-            return this.dfsFind(fc.root, stageId);
-        }
-        // Subflow: drill into the subflow chain, then search from the last subflow's root
-        let subflowRoot;
-        for (const sfId of subflowPath) {
-            const subflow = fc.subflows?.[sfId];
-            if (!subflow)
-                return undefined;
-            subflowRoot = subflow.root;
+    pausedOrThrow(error) {
+        this.observers.deferredTier?.terminalFlush();
+        if (isPauseSignal(error)) {
+            this.lastCheckpoint = buildPauseCheckpoint(error, this.traverser, {
+                runId: this._currentRunId,
+                executionCount: this._executionCounter.value,
+                visitCounts: this._visitCounts,
+            });
+            return { paused: true, checkpoint: this.lastCheckpoint };
         }
-        if (!subflowRoot)
-            return undefined;
-        return this.dfsFind(subflowRoot, stageId);
+        throw error;
     }
-    /** DFS search for a node by ID in the StageNode graph. Cycle-safe via visited set. */
-    dfsFind(node, targetId, visited = new Set()) {
-        // Skip loop back-edge references (they share the target's ID but have no fn/resumeFn)
-        if (node.isLoopRef)
-            return undefined;
-        if (visited.has(node.id))
-            return undefined;
-        visited.add(node.id);
-        if (node.id === targetId)
-            return node;
-        if (node.children) {
-            for (const child of node.children) {
-                const found = this.dfsFind(child, targetId, visited);
-                if (found)
-                    return found;
-            }
+    /** The re-entrancy guard: one executor = one in-flight execution. */
+    assertIdle(method) {
+        if (this._isExecuting) {
+            throw new Error(`FlowChartExecutor: ${method}() called while another run()/resume() is in flight on this ` +
+                'executor. An executor holds per-run state (runId, recorders, checkpoint) — create ' +
+                'one executor per concurrent run. See docs/guides/execution-model.md.');
         }
-        if (node.next)
-            return this.dfsFind(node.next, targetId, visited);
-        return undefined;
     }
-    // ─── ScopeRecorder Management ───
+    // ─── Recorders (the register lives in `attach.ts`) ───
     /**
-     * Attach a scope ScopeRecorder to observe data operations (reads, writes, commits).
-     * Automatically attached to every ScopeFacade created during traversal.
-     * Must be called before run().
-     *
-     * **Idempotent by ID:** If a recorder with the same `id` is already attached,
-     * it is replaced (not duplicated). This prevents double-counting when both
-     * a framework and the user attach the same recorder type.
-     *
-     * Built-in recorders use auto-increment IDs (`metrics-1`, `debug-1`, ...) by
-     * default, so multiple instances with different configs coexist. To override
-     * a framework-attached recorder, pass the same well-known ID.
+     * Attach a ScopeRecorder to observe data operations (reads, writes, commits)
+     * on every stage scope. Call before run(). **Idempotent by `id`** (replaced,
+     * never duplicated). `{ delivery: 'deferred' }` moves it off the hot path —
+     * delivered at the next microtask checkpoint; re-attaching an id on the
+     * other tier SWAPS tiers (`docs/guides/observers-deferred.md`).
      *
      * @example
      * ```typescript
-     * // Multiple recorders with different configs — each gets a unique ID
      * executor.attachScopeRecorder(new MetricRecorder());
-     * executor.attachScopeRecorder(new DebugRecorder({ verbosity: 'minimal' }));
-     *
-     * // Override a framework-attached recorder by passing its well-known ID
-     * executor.attachScopeRecorder(new MetricRecorder('metrics'));
-     *
-     * // Attaching twice with same ID replaces (no double-counting)
-     * executor.attachScopeRecorder(new MetricRecorder('my-metrics'));
-     * executor.attachScopeRecorder(new MetricRecorder('my-metrics')); // replaces previous
+     * executor.attachScopeRecorder(new MetricRecorder('my-metrics')); // replaces same id
      * ```
-     *
-     * **Delivery tier (RFC-001):** pass `{ delivery: 'deferred' }` to take the
-     * recorder out of the engine's hot path — events are captured into a
-     * bounded queue and delivered at the next microtask checkpoint ("one beat
-     * behind"). Omitting `delivery` keeps the historical synchronous call,
-     * byte-identical to previous releases. Re-attaching the same `id` with a
-     * different tier SWAPS tiers cleanly — never double delivery. See
-     * `docs/guides/observers-deferred.md`.
      */
     attachScopeRecorder(recorder, options) {
-        // Tier swap, both directions: an id lives on exactly ONE tier per list.
-        this.scopeRecorders = this.scopeRecorders.filter((r) => r.id !== recorder.id);
-        if (options?.delivery === 'deferred') {
-            this.ensureDeferredTier(options).register(recorder, { scope: true }, options);
-            return;
-        }
-        this.deferredTier?.removeFromLists(recorder.id, { scope: true });
-        this.scopeRecorders.push(recorder);
-    }
-    /**
-     * Lazily create the executor's ONE deferred-observer tier (one merged
-     * queue, total event order across all three channels). The FIRST deferred
-     * attach's options configure the dispatcher; later differing options are
-     * dev-warned and ignored (see `AttachRecorderOptions`).
-     */
-    ensureDeferredTier(options) {
-        if (!this.deferredTier)
-            this.deferredTier = new DeferredObserverTier(options);
-        return this.deferredTier;
-    }
-    // ─── Detach (T4) ─────────────────────────────────────────────────────────
-    //
-    // Bare-executor entry point for fire-and-forget child flowchart execution.
-    // Use from outside any chart (consumer code that wants to detach work
-    // without first running a parent chart). For detach FROM INSIDE a stage,
-    // use `scope.$detachAndJoinLater(...)` / `scope.$detachAndForget(...)` —
-    // those mint refIds from the calling stage's runtimeStageId for trace
-    // correlation; the bare-executor entries use a synthetic prefix
-    // (`__executor__`) instead.
-    /**
-     * Detach a child flowchart on the given driver and return a `DetachHandle`
-     * the caller can `wait()` on (Promise) or read `.status` from (sync).
-     *
-     * The driver is a REQUIRED first argument — there is no library-default,
-     * to keep the engine free of driver imports and to make the choice of
-     * scheduling algorithm explicit at the call site.
-     *
-     * @example
-     * ```typescript
-     * import { microtaskBatchDriver } from 'footprintjs/detach';
-     *
-     * const exec = new FlowChartExecutor(parentChart);
-     * const handle = exec.detachAndJoinLater(microtaskBatchDriver, telemetryChart, { event: 'x' });
-     * await handle.wait(); // optional
-     * ```
-     */
-    detachAndJoinLater(driver, child, input) {
-        return _detachAndJoinLater(driver, child, input, '__executor__');
-    }
-    /**
-     * Detach a child flowchart on the given driver and DISCARD the handle.
-     * Use for telemetry exports / fire-and-forget side effects where the
-     * caller doesn't care about the result.
-     *
-     * Errors raised by the child still land on the (discarded) handle — they
-     * go silent unless surfaced through a recorder. For observable detach,
-     * prefer `detachAndJoinLater` and surface failures via `.wait().catch()`.
-     */
-    detachAndForget(driver, child, input) {
-        _detachAndForget(driver, child, input, '__executor__');
+        this.observers.attachScope(recorder, options);
     }
     /** Detach all scope Recorders with the given ID — both delivery tiers. */
     detachScopeRecorder(id) {
-        this.scopeRecorders = this.scopeRecorders.filter((r) => r.id !== id);
-        this.deferredTier?.removeFromLists(id, { scope: true });
+        this.observers.detachScope(id);
     }
     /** Returns a defensive copy of attached scope Recorders (both tiers). */
     getScopeRecorders() {
-        return [...this.scopeRecorders, ...(this.deferredTier?.scopeListRecorders() ?? [])];
+        return this.observers.scopeList();
     }
-    // ─── FlowRecorder Management ───
     /**
-     * Attach a FlowRecorder to observe control flow events.
-     * Automatically enables narrative if not already enabled.
-     * Must be called before run() — recorders are passed to the traverser at creation time.
-     *
-     * **Idempotent by ID:** replaces existing recorder with same `id`.
-     *
-     * **Delivery tier (RFC-001):** pass `{ delivery: 'deferred' }` for
-     * next-checkpoint delivery off the hot path — see `attachScopeRecorder`.
+     * Attach a FlowRecorder to observe control flow events. Automatically
+     * enables narrative. Must be called before run(). Idempotent by `id`;
+     * `{ delivery: 'deferred' }` as for `attachScopeRecorder`.
      */
     attachFlowRecorder(recorder, options) {
-        // Tier swap, both directions: an id lives on exactly ONE tier per list.
-        this.flowRecorders = this.flowRecorders.filter((r) => r.id !== recorder.id);
-        this.narrativeEnabled = true;
-        if (options?.delivery === 'deferred') {
-            this.ensureDeferredTier(options).register(recorder, { flow: true }, options);
-            return;
-        }
-        this.deferredTier?.removeFromLists(recorder.id, { flow: true });
-        this.flowRecorders.push(recorder);
+        this.observers.attachFlow(recorder, options);
     }
     /** Detach all FlowRecorders with the given ID — both delivery tiers. */
     detachFlowRecorder(id) {
-        this.flowRecorders = this.flowRecorders.filter((r) => r.id !== id);
-        this.deferredTier?.removeFromLists(id, { flow: true });
+        this.observers.detachFlow(id);
     }
     /** Returns a defensive copy of attached FlowRecorders (both tiers). */
     getFlowRecorders() {
-        return [...this.flowRecorders, ...(this.deferredTier?.flowListRecorders() ?? [])];
+        return this.observers.flowList();
     }
-    // ─── Combined ScopeRecorder Management ───
     /**
-     * Attach a recorder that may observe multiple event streams (scope
-     * data-flow, control-flow, or both). Detects at runtime which streams the
-     * recorder has methods for and routes it to the correct internal channels.
-     *
-     * Preferred over calling `attachScopeRecorder` and `attachFlowRecorder`
-     * separately, because forgetting one of the two is a silent foot-gun —
-     * half your events never fire and there is no runtime warning. With
-     * `attachCombinedRecorder` the library guarantees the recorder's declared
-     * methods all fire, and adds no overhead versus two explicit calls.
-     *
-     * ## Idempotency
-     *
-     * Idempotent by `id` across ALL channels — re-attaching with the same `id`
-     * replaces the previous instance everywhere it was registered. Mixing
-     * `attachCombinedRecorder(x)` with a prior `attachScopeRecorder(y)` or
-     * `attachFlowRecorder(y)` that share `x.id === y.id` is also safe: the
-     * combined attach replaces the single-channel registration on whichever
-     * channel(s) `x` has methods for. No duplicate firings occur.
-     *
-     * ## Narrative activation
-     *
-     * If the recorder has any control-flow methods, `enableNarrative()` is
-     * called as a side effect (the narrative subsystem is required to emit
-     * control-flow events). Data-flow-only recorders do NOT activate the
-     * narrative.
-     *
-     * ## Detection rule
-     *
-     * Only **own** event methods count (see `hasRecorderMethods`). Methods
-     * inherited via the prototype chain are ignored — this protects against
-     * accidental `Object.prototype` pollution attaching handlers you never
-     * declared. A recorder that provides only `clear`/`toSnapshot` is a
-     * no-op and emits a dev-mode warning to surface the likely mistake.
+     * Attach a recorder to every channel (scope, flow, emit) it has OWN `on*`
+     * methods for — preferred over single-channel calls, where forgetting one
+     * silently loses events. Idempotent by `id` across all channels; a flow
+     * method enables the narrative; `delivery` comes from the options or the
+     * recorder's own field.
      *
      * @example
      * ```typescript
@@ -1084,60 +370,16 @@ export class FlowChartExecutor {
      * ```
      */
     attachCombinedRecorder(recorder, options) {
-        const hasData = hasRecorderMethods(recorder);
-        const hasFlow = hasFlowRecorderMethods(recorder);
-        const hasEmit = hasEmitRecorderMethods(recorder);
-        // Delivery tier (RFC-001): options bag OR the recorder's own
-        // `delivery: 'deferred'` field. The field is a string — channel routing
-        // above counts event-METHOD properties only, so declaring it never
-        // changes which channels the recorder lands on.
-        const delivery = options?.delivery ?? recorder.delivery;
-        const tierOptions = delivery === undefined ? options : { ...options, delivery };
-        // Emit recorders live on the SAME channel as data-flow recorders
-        // (ScopeFacade iterates `_recorders` for onEmit dispatch). So
-        // attachEmitRecorder internally calls attachScopeRecorder — but we want to
-        // avoid double-attach when the recorder implements BOTH onEmit AND
-        // other ScopeRecorder methods. Short-circuit: if hasData OR hasEmit, the
-        // recorder lands on the scope-recorder list exactly once.
-        if (hasData || hasEmit)
-            this.attachScopeRecorder(recorder, tierOptions);
-        if (hasFlow)
-            this.attachFlowRecorder(recorder, tierOptions);
-        if (!hasData && !hasFlow && !hasEmit && isDevMode()) {
-            // Dev-mode only: silent skips are invisible and produce hard-to-debug
-            // "why didn't my recorder fire" reports. Per library convention, gated
-            // on the central isDevMode() flag (not process.env) so consumers can
-            // control dev tooling centrally via enableDevMode()/disableDevMode().
-            // eslint-disable-next-line no-console
-            console.warn(`[footprintjs] attachCombinedRecorder: recorder '${recorder.id}' has ` +
-                'no observer event methods — nothing to attach. Did you forget to ' +
-                'add an on* handler (onWrite, onDecision, onSubflowEntry, ...)? ' +
-                'Note: only OWN properties count; methods on the prototype chain ' +
-                'are ignored on purpose.');
-        }
+        this.observers.attachCombined(recorder, options);
     }
-    /**
-     * Detach a combined recorder from all channels it was attached to.
-     * Safe to call if the recorder was only on one channel or never attached.
-     */
+    /** Detach a combined recorder from every channel it was attached to (safe if never attached). */
     detachCombinedRecorder(id) {
         this.detachScopeRecorder(id);
         this.detachFlowRecorder(id);
     }
-    // ─── Emit ScopeRecorder Management (Phase 3) ───
     /**
-     * Attach an `EmitRecorder` — an observer for consumer-emitted structured
-     * events fired via `scope.$emit(name, payload)`.
-     *
-     * Internally, emit recorders share the scope-recorder channel because
-     * emit events fire from inside `ScopeFacade` during stage execution,
-     * same timing as `onRead`/`onWrite`. This method is a convenience that
-     * delegates to `attachScopeRecorder` — consumers can also use
-     * `attachScopeRecorder` directly for a recorder that implements BOTH
-     * `onWrite` and `onEmit`. Either approach places the recorder on the
-     * same underlying list, so `onEmit` fires exactly once per event.
-     *
-     * **Idempotent by `id`:** replaces existing recorder with same `id`.
+     * Attach an `EmitRecorder` for `scope.$emit(name, payload)` events. It rides
+     * the scope list, so `onEmit` fires exactly once per event. Idempotent by `id`.
      *
      * @example
      * ```typescript
@@ -1156,45 +398,49 @@ export class FlowChartExecutor {
     detachEmitRecorder(id) {
         this.detachScopeRecorder(id);
     }
-    /**
-     * Returns a defensive copy of attached recorders (both delivery tiers)
-     * filtered to those that implement `onEmit`. Useful for inspection during
-     * testing.
-     */
+    /** Returns a defensive copy of attached recorders (both tiers) that implement `onEmit`. */
     getEmitRecorders() {
         return this.getScopeRecorders().filter((r) => typeof r.onEmit === 'function');
     }
+    // ─── Detach (T4) ───
+    // Bare-executor entry points for fire-and-forget child charts. From inside a
+    // stage use `scope.$detachAndJoinLater(...)` / `scope.$detachAndForget(...)`,
+    // which mint refIds from the calling stage; these use `__executor__`.
     /**
-     * Returns structured narrative entries — the single public narrative API.
-     * Each entry has a type (stage, step, condition, fork, etc.), text, and
-     * depth. Consumers render however they want; call `.map(e => e.text)`
-     * if a flat `string[]` is needed locally.
+     * Detach a child flowchart on the given driver and return a `DetachHandle`
+     * the caller can `wait()` on (Promise) or read `.status` from (sync). The
+     * driver is REQUIRED — there is no library default.
+     *
+     * @example
+     * ```typescript
+     * import { microtaskBatchDriver } from 'footprintjs/detach';
+     *
+     * const exec = new FlowChartExecutor(parentChart);
+     * const handle = exec.detachAndJoinLater(microtaskBatchDriver, telemetryChart, { event: 'x' });
+     * await handle.wait(); // optional
+     * ```
      */
-    getNarrativeEntries() {
-        if (this.combinedRecorder) {
-            return this.combinedRecorder.getEntries();
-        }
-        const flowSentences = this.traverser.getNarrative();
-        return flowSentences.map((text) => ({ type: 'stage', text, depth: 0 }));
+    detachAndJoinLater(driver, child, input) {
+        return _detachAndJoinLater(driver, child, input, '__executor__');
+    }
+    /**
+     * Detach a child flowchart on the given driver and DISCARD the handle — for
+     * fire-and-forget side effects. A child's error lands on the discarded handle;
+     * for observable detach prefer `detachAndJoinLater` + `.wait().catch()`.
+     */
+    detachAndForget(driver, child, input) {
+        _detachAndForget(driver, child, input, '__executor__');
     }
     /**
-     * Returns the combined FlowRecorders list. When narrative is enabled,
-     * includes the CombinedNarrativeRecorder (which builds merged flow+data
-     * entries inline). Plus any user-attached recorders.
+     * Structured narrative entries (type, text, depth) — the one public narrative
+     * API; `.map(e => e.text)` for a flat `string[]`.
      */
-    buildFlowRecordersList() {
-        const recorders = [];
-        if (this.combinedRecorder) {
-            recorders.push(this.combinedRecorder);
+    getNarrativeEntries() {
+        if (this.observers.combinedRecorder) {
+            return this.observers.combinedRecorder.getEntries();
         }
-        recorders.push(...this.flowRecorders);
-        // Deferred-observer flow tap (RFC-001 Block 7) — captures every flow
-        // event for deferred listeners. Appended like any other flow recorder,
-        // so the FlowRecorderDispatcher site needs no tier logic of its own.
-        const flowTap = this.deferredTier?.buildFlowTap();
-        if (flowTap)
-            recorders.push(flowTap);
-        return recorders.length > 0 ? recorders : undefined;
+        const flowSentences = this.traverser.getNarrative();
+        return flowSentences.map((text) => ({ type: 'stage', text, depth: 0 }));
     }
     /**
      * Execute the chart. Resolves when the run finishes — or pauses, if a
@@ -1214,73 +460,37 @@ export class FlowChartExecutor {
      * checkpoint). Create one executor per concurrent run.
      */
     async run(options) {
-        // Re-entrancy guard FIRST — before clearing recorders or touching any
-        // per-run field, so a rejected concurrent call leaves the in-flight run
-        // completely untouched.
-        if (this._isExecuting) {
-            throw new Error('FlowChartExecutor: run() called while another run()/resume() is in flight on this ' +
-                'executor. An executor holds per-run state (runId, recorders, checkpoint) — create ' +
-                'one executor per concurrent run. See docs/guides/execution-model.md.');
-        }
-        // Validate input against inputSchema if both are present. Validation runs
-        // BEFORE the timeout timer is created so a rejected input can't leak a
-        // pending timer (same "failed entry leaves no side effects" rule as the
-        // re-entrancy guard above).
+        // A failed entry leaves no side effects: the guard FIRST (the in-flight
+        // run stays untouched), validation before the timeout timer exists.
+        this.assertIdle('run');
         let validatedInput = options?.input;
         if (validatedInput && this.flowChartArgs.flowChart.inputSchema) {
             validatedInput = validateInput(this.flowChartArgs.flowChart.inputSchema, validatedInput);
         }
         let signal = options?.signal;
         let timeoutId;
-        // Create an internal AbortController for timeoutMs
         if (options?.timeoutMs && !signal) {
             const controller = new AbortController();
             signal = controller.signal;
             timeoutId = setTimeout(() => controller.abort(new Error(`Execution timed out after ${options.timeoutMs}ms`)), options.timeoutMs);
         }
-        // User-attached recorders (flowRecorders + scopeRecorders) are cleared via clear() to prevent
-        // cross-run accumulation. The combinedRecorder is NOT cleared here — createTraverser() always
-        // creates a fresh CombinedNarrativeRecorder instance on each run, so stale state is never an issue.
-        for (const r of this.flowRecorders) {
-            r.clear?.();
-        }
-        for (const r of this.scopeRecorders) {
-            r.clear?.();
-        }
-        this.deferredTier?.clearRecorders();
+        this.observers.clearForRun(); // no cross-run accumulation
         this.lastCheckpoint = undefined;
-        this._executionCounter = { value: 0 }; // Reset counter on fresh run
-        this._visitCounts = new Map(); // Reset loop-iteration counts on fresh run (twin of _executionCounter)
-        this._currentRunId = generateRunId(); // Fresh runId per run() call
-        this._hasRunBefore = true; // mark so a later resume() takes the
-        // same-executor branch (reuse runtime, accumulate execution tree).
+        this._executionCounter = { value: 0 };
+        this._visitCounts = new Map();
+        this._currentRunId = generateRunId();
+        this._hasRunBefore = true; // a later resume() reuses this runtime
         this.traverser = this.createTraverser(signal, validatedInput, options?.env, options?.maxDepth, options?.maxIterations);
-        // Set AFTER all sync validation throws (nothing above can leak the flag);
-        // no await between the top-of-method check and here, so this is race-free.
+        // After every sync throw, with no await since the guard: race-free.
         this._isExecuting = true;
         try {
             const result = await this.traverser.execute();
-            // Terminal flush (RFC-001 Block 8) at the RESOLVE boundary: every
-            // captured-but-undelivered observer event is delivered synchronously
-            // before run() returns — "one beat behind" never becomes "lost at exit".
-            this.deferredTier?.terminalFlush();
+            // Terminal flush (RFC-001 Block 8): "one beat behind" never becomes "lost at exit".
+            this.observers.deferredTier?.terminalFlush();
             return result;
         }
         catch (error) {
-            // Terminal flush at the PAUSE and REJECT boundaries — this is the
-            // OUTERMOST handler (a pause re-throws through subflow traversers
-            // without exit events, so per-traverser hooks would miss it). Runs
-            // before the checkpoint is exposed and before the error reaches the
-            // caller.
-            this.deferredTier?.terminalFlush();
-            if (isPauseSignal(error)) {
-                // Build a detached checkpoint from current execution state — see
-                // buildPauseCheckpoint() for the deep-copy rationale.
-                this.lastCheckpoint = this.buildPauseCheckpoint(error);
-                // Return a PauseResult-shaped value so callers can check without try/catch
-                return { paused: true, checkpoint: this.lastCheckpoint };
-            }
-            throw error;
+            return this.pausedOrThrow(error);
         }
         finally {
             this._isExecuting = false;
@@ -1289,116 +499,31 @@ export class FlowChartExecutor {
         }
     }
     /**
-     * Flush the deferred-observer backlog, then await async listener
-     * completions under a deadline (RFC-001 Block 8 — the serverless /
-     * graceful-shutdown pattern: call before the process freezes or exits so
-     * "one beat behind" work is not lost). Resolves immediately with zeros
-     * when no deferred observer was ever attached. `pending === 0` means a
-     * full drain; a non-zero `pending` reports continuations (plus any queued
-     * events) still outstanding at the deadline — honest, never silent.
+     * Flush the deferred-observer backlog, then await async listener completions
+     * under a deadline — call before a serverless process freezes or exits.
+     * Zeros when no deferred observer was attached; `pending > 0` reports what
+     * was still outstanding at the deadline.
      */
     drainObservers(opts) {
-        if (!this.deferredTier)
+        const tier = this.observers.deferredTier;
+        if (!tier)
             return Promise.resolve({ done: 0, failed: 0, pending: 0 });
-        return this.deferredTier.drain(opts);
+        return tier.drain(opts);
     }
     // ─── Introspection ───
     /**
      * Returns the runtime snapshot.
      *
-     * @param options.redact  When `true`, `sharedState` comes from the parallel
-     *   redacted mirror (if maintained — see `setRedactionPolicy`). This is
-     *   the safe view for exporting traces externally (paste into a viewer,
-     *   share with support). When no redaction policy is configured the
-     *   redacted mirror is not maintained, so this flag is a no-op —
-     *   `sharedState` is the raw working memory either way. Default `false`.
-     *
-     *   The commit log is already redacted at write-time regardless of this
-     *   flag, and the execution tree carries only structural metadata.
-     *   `subflowResults[*].treeContext.globalContext` follows the flag too
-     *   (9.20.0): under `redact: true` it is each subflow's own redacted
-     *   mirror; plain, the subflow's live heap.
+     * @param options.redact  `true` serves `sharedState` (and each subflow's
+     *   `globalContext`) from the redacted mirror — the safe view to export. A
+     *   no-op without a redaction policy. The commit log is redacted at write
+     *   time regardless. Default `false`.
      *
      * **Treat `sharedState` as READ-ONLY.** In production it is a live view of
-     * the engine's working memory (zero copy cost) — mutating it corrupts
-     * engine state. In dev mode (`enableDevMode()`) it is a deep-frozen CLONE,
-     * so any consumer mutation throws loudly instead of corrupting silently.
+     * engine memory; in dev mode a deep-frozen clone, so a mutation throws.
      */
     getSnapshot(options) {
-        const snapshot = this.traverser.getSnapshot(options);
-        if (isDevMode()) {
-            // Dev-mode mutation guard: freeze a CLONE, never the live engine
-            // state — `snapshot.sharedState` IS SharedMemory's current generation,
-            // whose unchanged subtrees every later generation shares
-            // (copy-on-write, 9.29.0).
-            // Production stays zero-copy; clone-always is a measured decision
-            // deferred until the bench says it's affordable (BACKLOG #8).
-            // NOTE: deepFreeze (capture/freeze.ts — the one walk) cannot reach
-            // Map/Set INTERNALS (`map.set()` on the frozen clone won't throw) and
-            // skips typed arrays. The CLONE still isolates the engine.
-            snapshot.sharedState = deepFreeze(structuredClone(snapshot.sharedState));
-        }
-        const sfResults = this.traverser.getSubflowResults();
-        if (sfResults.size > 0) {
-            // Under `redact: true` each subflow's `globalContext` is its own mirror
-            // (9.20.0) — served, never written into the record (see
-            // engine/handlers/servedSubflowResults.ts). Plain: the records as they are.
-            snapshot.subflowResults = servedSubflowResults(sfResults, options?.redact === true);
-        }
-        const recorderSnapshots = this.collectRecorderSnapshots();
-        if (recorderSnapshots.length > 0) {
-            snapshot.recorders = recorderSnapshots;
-        }
-        // RFC-001 Block 9: the deferred-observer accounting surface. Present
-        // ONLY when a deferred observer was attached on this executor —
-        // zero-cost discipline for everyone else.
-        if (this.deferredTier) {
-            snapshot.observerStats = this.deferredTier.getStats();
-        }
-        return snapshot;
-    }
-    /**
-     * Collect `toSnapshot()` bundles from every attached recorder — ONE entry
-     * per recorder id, across all channels and both delivery tiers.
-     *
-     * The dedupe is load-bearing, not tidiness. A recorder that implements a
-     * shared-name hook (`onError` / `onPause` / `onResume` — declared on BOTH
-     * the scope and flow interfaces) is legitimately registered on BOTH inline
-     * lists by `attachCombinedRecorder`, and that is by design: each channel
-     * calls the hook with its own payload variant. `MetricRecorder.onPause` is
-     * the everyday case. Walking the lists without a shared `seen` set turned
-     * that into a DUPLICATED snapshot entry (same id twice), which breaks every
-     * consumer that indexes `snapshot.recorders` by id.
-     *
-     * Ordering is scope list → flow list → deferred tier, and the FIRST bundle
-     * for an id wins. A recorder with no `toSnapshot` never claims an id, so it
-     * cannot shadow a same-id recorder that does have one.
-     *
-     * The row is REBUILT field by field by the one copier (`recorder/snapshot.ts
-     * · copyBundle`, shared with `CompositeRecorder`) rather than spread, so a
-     * recorder cannot smuggle an `id` of its own choosing into the snapshot (the
-     * id is the executor's, and consumers index by it).
-     */
-    collectRecorderSnapshots() {
-        const out = [];
-        const seen = new Set();
-        const collect = (r) => {
-            if (!r.toSnapshot || seen.has(r.id))
-                return;
-            seen.add(r.id);
-            out.push(copyBundle(r.id, r.toSnapshot()));
-        };
-        for (const r of this.scopeRecorders)
-            collect(r);
-        for (const r of this.flowRecorders)
-            collect(r);
-        if (this.deferredTier) {
-            for (const r of this.deferredTier.scopeListRecorders())
-                collect(r);
-            for (const r of this.deferredTier.flowListRecorders())
-                collect(r);
-        }
-        return out;
+        return servedSnapshot(this.traverser, this.observers, options);
     }
     /** @internal */
     getRuntime() {
@@ -1429,7 +554,7 @@ export class FlowChartExecutor {
      * Returns empty array if no ManifestFlowRecorder is attached.
      */
     getSubflowManifest() {
-        const recorder = this.flowRecorders.find((r) => r instanceof ManifestFlowRecorder);
+        const recorder = this.observers.flowRecorders.find((r) => r instanceof ManifestFlowRecorder);
         return recorder?.getManifest() ?? [];
     }
     /**
@@ -1437,8 +562,8 @@ export class FlowChartExecutor {
      * Requires an attached ManifestFlowRecorder that observed the registration.
      */
     getSubflowSpec(subflowId) {
-        const recorder = this.flowRecorders.find((r) => r instanceof ManifestFlowRecorder);
+        const recorder = this.observers.flowRecorders.find((r) => r instanceof ManifestFlowRecorder);
         return recorder?.getSpec(subflowId);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FlowChartExecutor.js","sourceRoot":"","sources":["../../../../src/lib/runner/FlowChartExecutor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * FlowChartExecutor — Public API for executing a compiled FlowChart.\n *\n * Wraps FlowchartTraverser. Build a chart with flowChart() and pass the result here:\n *\n *   const chart = flowChart('entry', entryFn).addFunction('process', processFn).build();\n *\n *   // No-options form (uses auto-detected TypedScope factory from the chart):\n *   const executor = new FlowChartExecutor(chart);\n *\n *   // Options-object form (preferred when you need to customize behavior):\n *   const executor = new FlowChartExecutor(chart, { scopeFactory: myFactory });\n *\n *   // 2-param form (accepts a ScopeFactory directly, for backward compatibility):\n *   const executor = new FlowChartExecutor(chart, myFactory);\n *\n *   const result = await executor.run({ input: data, env: { traceId: 'req-123' } });\n */\n\nimport type { FlowChart } from '../builder/types.js';\nimport { deepFreeze } from '../capture/freeze.js';\nimport { detachAndForget as _detachAndForget, detachAndJoinLater as _detachAndJoinLater } from '../detach/spawn.js';\nimport { isDevMode } from '../devMode.js';\nimport { ResumeEntry } from '../engine/handlers/ResumeEntry.js';\nimport { servedSubflowResults } from '../engine/handlers/servedSubflowResults.js';\nimport type { CombinedNarrativeRecorderOptions } from '../engine/narrative/CombinedNarrativeRecorder.js';\nimport { CombinedNarrativeRecorder } from '../engine/narrative/CombinedNarrativeRecorder.js';\nimport type { CombinedNarrativeEntry } from '../engine/narrative/narrativeTypes.js';\nimport type { ManifestEntry } from '../engine/narrative/recorders/ManifestFlowRecorder.js';\nimport { ManifestFlowRecorder } from '../engine/narrative/recorders/ManifestFlowRecorder.js';\nimport type { FlowRecorder, ResumeLink } from '../engine/narrative/types.js';\nimport { FlowchartTraverser } from '../engine/traversal/FlowchartTraverser.js';\nimport { resumeTraversalContext } from '../engine/traversalContext.js';\nimport {\n  type ExecutorResult,\n  type PausedResult,\n  type RunOptions,\n  type ScopeFactory,\n  type SerializedPipelineStructure,\n  type StageFunction,\n  type StageNode,\n  type StreamHandlers,\n  type SubflowResult,\n  type TraversalResult,\n  defaultLogger,\n} from '../engine/types.js';\nimport { buildRuntimeStageId, isExecutionKey } from '../ids/runtimeStageId.js';\nimport { RedactionRule } from '../memory/redaction.js';\nimport type { RunDials } from '../memory/runPolicy.js';\nimport { pickDials, runPolicy } from '../memory/runPolicy.js';\nimport type { CommitValuesMode, ReadTrackingMode, StageSnapshot, WriteTrackingMode } from '../memory/types.js';\nimport { provideInterruptAnswer } from '../pause/interrupt.js';\nimport { CHECKPOINT_VERSION, decodeCheckpoint } from '../pause/record.js';\nimport type { FlowchartCheckpoint, PauseSignal } from '../pause/types.js';\nimport { isPausedExecution, isPauseSignal } from '../pause/types.js';\nimport type { CombinedRecorder } from '../recorder/CombinedRecorder.js';\nimport { hasEmitRecorderMethods, hasFlowRecorderMethods, hasRecorderMethods } from '../recorder/CombinedRecorder.js';\nimport type { EmitRecorder } from '../recorder/EmitRecorder.js';\nimport { fire, recorderFailureEvent, warnInDevMode } from '../recorder/hooks.js';\nimport { copyBundle } from '../recorder/snapshot.js';\nimport type { ScopeProtectionMode } from '../scope/protection/types.js';\nimport { ScopeFacade } from '../scope/ScopeFacade.js';\nimport type { RedactionPolicy, RedactionReport, ScopeRecorder } from '../scope/types.js';\nimport { describeCheckpointCloneFailure, sanitizeDiagnosticBags } from './checkpointSanitize.js';\nimport { type AttachRecorderOptions, type ObserverDrainResult, DeferredObserverTier } from './DeferredObserverTier.js';\nimport { type RecorderSnapshot, type RuntimeSnapshot, ExecutionRuntime } from './ExecutionRuntime.js';\nimport { generateRunId } from './runId.js';\nimport { validateInput } from './validateInput.js';\n\n/** Default scope factory — creates a plain ScopeFacade for each stage. */\nconst defaultScopeFactory: ScopeFactory = (ctx, stageName, readOnly, env) =>\n  new ScopeFacade(ctx, stageName, readOnly, env);\n\n/**\n * The paused stage's stand-in for a resume: the stage's OWN node — so it keeps\n * its shape (a decider's or selector's branches, a fork parent's children,\n * its `next`) and its name, description and declared tags — with `fn` swapped\n * for the resume half.\n *\n * Dropped: `resumeFn` and `isPausable` (the resume half must not pause\n * because it returned a value — the original pausable contract); and, on the\n * `addPausableFunction` re-entry, the policies declared for the stage's OWN\n * function (`retry`, streaming) — that re-entry runs a different function\n * (`resumeFn`) under a different contract. The `interrupt()` re-entry re-runs\n * the stage's own function, so it keeps them.\n *\n * Tags follow the stage on BOTH re-entries (9.21.0): a tag is the stage's\n * NAME, not a policy over its function, and the resumed execution is that\n * stage running again — its bundle must carry it, or a chained axis would\n * show the paused leg tagged and the resumed leg silently not.\n */\nfunction standInFor<TOut, TScope>(\n  pausedNode: StageNode<TOut, TScope>,\n  fn: StageFunction<TOut, TScope>,\n  isInterruptResume: boolean,\n): StageNode<TOut, TScope> {\n  const standIn: StageNode<TOut, TScope> = { ...pausedNode, fn };\n  delete standIn.resumeFn;\n  delete standIn.isPausable;\n  if (!isInterruptResume) {\n    delete standIn.retry;\n    delete standIn.isStreaming;\n    delete standIn.streamId;\n  }\n  return standIn;\n}\n\n/** The flow channel's isolation for the executor-made `onResume` (dev-mode warning, then skip). */\nconst RESUME_FLOW_FAILURE = warnInDevMode('FlowChartExecutor');\n\n/**\n * The resume event's link, read off the checkpoint itself — so a resume records\n * the same wherever its checkpoint came from. `undefined` for a checkpoint\n * without `pausedExecution` (made before 9.37.0) or with a malformed one: the\n * link is a record, never used to plan the re-entry, so it is left out rather\n * than guessed.\n */\nfunction resumeLinkOf(checkpoint: FlowchartCheckpoint): ResumeLink | undefined {\n  const paused: unknown = checkpoint.pausedExecution;\n  return isPausedExecution(paused) ? { runId: paused.runId, runtimeStageId: paused.runtimeStageId } : undefined;\n}\n\n/**\n * Options object for `FlowChartExecutor` — preferred over positional params.\n *\n * ```typescript\n * const ex = new FlowChartExecutor(chart, {\n *   scopeFactory: myFactory,\n *   defaultValuesForContext: { ... },\n * });\n * ```\n *\n * **Sync note for maintainers:** Every field added here must also appear in the\n * `flowChartArgs` private field type and in the constructor's options-resolution\n * block (the `else if` branch that reads from `opts`). Missing any one of the\n * three causes silent omission — the option is accepted but never applied.\n * The observability DIALS are the exception: they come from `RunDials`\n * (memory/runPolicy.ts) and travel as one `dials` field, so a new dial is\n * added there and nowhere here.\n *\n * **TScope inference note:** When using the options-object form with a custom scope,\n * TypeScript cannot infer `TScope` through the options object. Pass the type\n * explicitly: `new FlowChartExecutor<TOut, MyScope>(chart, { scopeFactory })`.\n */\nexport interface FlowChartExecutorOptions<TScope = any> extends RunDials {\n  // ── Common options (most callers need only these) ────────────────────────\n\n  /** Custom scope factory. Defaults to TypedScope or ScopeFacade auto-detection. */\n  scopeFactory?: ScopeFactory<TScope>;\n\n  // ── Context options ──────────────────────────────────────────────────────\n\n  /**\n   * Default values pre-populated into the shared context before **each** stage\n   * (re-applied every stage, acting as baseline defaults).\n   */\n  defaultValuesForContext?: unknown;\n  /**\n   * Initial context values merged into the shared context **once** at startup\n   * (applied before the first stage, not repeated on subsequent stages).\n   * Distinct from `defaultValuesForContext`, which is re-applied every stage.\n   */\n  initialContext?: unknown;\n  /** Read-only input accessible via `scope.getArgs()` — never tracked or written. */\n  readOnlyContext?: unknown;\n\n  // ── Observability cost options ────────────────────────────────────────────\n  // The four dials — `readTracking`, `writeTracking`, `commitValues`,\n  // `writeProvenance` — are inherited from `RunDials` (memory/runPolicy.ts,\n  // where each is documented): the executor picks them off this object and\n  // builds the run's ONE policy from them (F5).\n\n  // ── Advanced / escape-hatch options (most callers do not need these) ─────\n\n  /**\n   * Custom error classifier for throttling detection. Return `true` if a fork\n   * child's error represents a rate-limit or backpressure condition; the\n   * executor then fires `FlowRecorder.onThrottled` for that child (9.39.0 —\n   * an EVENT, not a state key: the `monitor.isThrottled` write it replaced\n   * never landed). The child's failure is otherwise handled as before.\n   * Defaults to no throttling classification.\n   */\n  throttlingErrorChecker?: (error: unknown) => boolean;\n  /** Handlers for streaming stage lifecycle events (see `addStreamingFunction`). */\n  streamHandlers?: StreamHandlers;\n  /** Scope protection mode for TypedScope direct-assignment detection. */\n  scopeProtectionMode?: ScopeProtectionMode;\n}\n\nexport class FlowChartExecutor<TOut = any, TScope = any> {\n  private traverser: FlowchartTraverser<TOut, TScope>;\n  /** Shared execution counter — survives pause/resume. Reset on fresh run(). */\n  private _executionCounter = { value: 0 };\n  /** Shared per-run visit counts (by stageId) driving TraversalContext.loopIteration.\n   *  Twin of _executionCounter: survives pause/resume, reset on fresh run(). */\n  private _visitCounts = new Map<string, number>();\n  /** Per-`run()` identifier — generated fresh per run + per resume. Threaded\n   *  through every TraversalContext so recorders can scope state to a single\n   *  run. See `runId.ts`. */\n  private _currentRunId = '';\n  private narrativeEnabled = false;\n  private narrativeOptions?: CombinedNarrativeRecorderOptions;\n  private combinedRecorder: CombinedNarrativeRecorder | undefined;\n  private flowRecorders: FlowRecorder[] = [];\n  private scopeRecorders: ScopeRecorder[] = [];\n  /**\n   * RFC-001 deferred-observer wiring — created LAZILY on the first\n   * `delivery: 'deferred'` attach. `undefined` for every executor that never\n   * opts in: zero allocation, zero per-event cost, byte-identical behavior\n   * (the emit fast-path precedent).\n   */\n  private deferredTier?: DeferredObserverTier;\n  private redactionPolicy: RedactionPolicy | undefined;\n  /**\n   * The run's ONE redaction rule (`memory/redaction.ts`): built fresh per\n   * `createTraverser` (per-call marks reset per run and per resume, as the\n   * shared set always did), installed on the runtime root so every context\n   * retains under it, and read by every `ScopeFacade` through its context.\n   */\n  private redactionRule = new RedactionRule();\n  private lastCheckpoint: FlowchartCheckpoint | undefined;\n  /**\n   * `true` once `run()` (or a previous `resume()`) has executed on\n   * this instance. `resume()` branches on it:\n   *\n   *   • true  → reuse the constructor-time runtime (same-executor\n   *             continuity: execution tree, recorders, narrative\n   *             accumulate across pause/resume cycles)\n   *   • false → seed a fresh runtime from `checkpoint.sharedState`\n   *             (cross-executor / cross-process resume: new instance\n   *             reconstructed from a serialized checkpoint)\n   *\n   * Without this flag, fresh executors silently discarded the\n   * checkpoint's sharedState and resume handlers couldn't read pre-pause\n   * scope. See `test/lib/pause/cross-executor-resume.test.ts`.\n   */\n  private _hasRunBefore = false;\n  /**\n   * Re-entrancy guard. `run()` and `resume()` mutate per-run instance state\n   * (traverser, runId, execution counter, checkpoint) and clear attached\n   * recorders — a second concurrent entry on the SAME executor would\n   * interleave runIds and cross-contaminate recorder/narrative state, and\n   * `getCheckpoint()` would return whichever run paused last. One executor =\n   * one in-flight execution; create an executor per concurrent run.\n   * See docs/guides/execution-model.md.\n   */\n  private _isExecuting = false;\n\n  // SYNC REQUIRED: every optional field here must mirror FlowChartExecutorOptions\n  // AND be assigned in the constructor's options-resolution block (the `else if` branch).\n  // Adding a field to only one of the three places causes silent omission.\n  // (The dials ride `dials` whole — `pickDials` reads every one RunDials declares.)\n  private readonly flowChartArgs: {\n    flowChart: FlowChart<TOut, TScope>;\n    scopeFactory: ScopeFactory<TScope>;\n    defaultValuesForContext?: unknown;\n    initialContext?: unknown;\n    readOnlyContext?: unknown;\n    throttlingErrorChecker?: (error: unknown) => boolean;\n    streamHandlers?: StreamHandlers;\n    scopeProtectionMode?: ScopeProtectionMode;\n    /** The dials as given (absent = default) — the run's policy is built from them per leg. */\n    dials: RunDials;\n  };\n\n  /**\n   * Create a FlowChartExecutor.\n   *\n   * **Options object form** (preferred):\n   * ```typescript\n   * new FlowChartExecutor(chart, { scopeFactory, defaultValuesForContext })\n   * ```\n   *\n   * **2-param form** (also supported):\n   * ```typescript\n   * new FlowChartExecutor(chart, scopeFactory)\n   * ```\n   *\n   * @param flowChart - The compiled FlowChart returned by `flowChart(...).build()`\n   * @param factoryOrOptions - A `ScopeFactory<TScope>` OR a `FlowChartExecutorOptions<TScope>` options object.\n   */\n  constructor(\n    flowChart: FlowChart<TOut, TScope>,\n    factoryOrOptions?: ScopeFactory<TScope> | FlowChartExecutorOptions<TScope>,\n  ) {\n    // Detect options-object form vs factory form\n    let scopeFactory: ScopeFactory<TScope> | undefined;\n    let defaultValuesForContext: unknown;\n    let initialContext: unknown;\n    let readOnlyContext: unknown;\n    let throttlingErrorChecker: ((error: unknown) => boolean) | undefined;\n    let streamHandlers: StreamHandlers | undefined;\n    let scopeProtectionMode: ScopeProtectionMode | undefined;\n    let dials: RunDials = {};\n\n    if (typeof factoryOrOptions === 'function') {\n      // 2-param form: new FlowChartExecutor(chart, scopeFactory)\n      scopeFactory = factoryOrOptions;\n    } else if (factoryOrOptions !== undefined) {\n      // Options object form\n      const opts = factoryOrOptions;\n      scopeFactory = opts.scopeFactory;\n      defaultValuesForContext = opts.defaultValuesForContext;\n      initialContext = opts.initialContext;\n      readOnlyContext = opts.readOnlyContext;\n      throttlingErrorChecker = opts.throttlingErrorChecker;\n      streamHandlers = opts.streamHandlers;\n      scopeProtectionMode = opts.scopeProtectionMode;\n      dials = pickDials(opts);\n    }\n    this.flowChartArgs = {\n      flowChart,\n      scopeFactory: scopeFactory ?? flowChart.scopeFactory ?? (defaultScopeFactory as ScopeFactory<TScope>),\n      defaultValuesForContext,\n      initialContext,\n      readOnlyContext,\n      throttlingErrorChecker,\n      streamHandlers,\n      scopeProtectionMode,\n      dials,\n    };\n    this.traverser = this.createTraverser();\n  }\n\n  private createTraverser(\n    signal?: AbortSignal,\n    readOnlyContextOverride?: unknown,\n    env?: import('../engine/types.js').ExecutionEnv,\n    maxDepth?: number,\n    maxIterations?: number,\n    overrides?: {\n      initialContext?: unknown;\n      preserveRecorders?: boolean;\n      existingRuntime?: InstanceType<typeof ExecutionRuntime>;\n      /** The resume's one-shot re-entry — where the resumed traversal\n       *  starts (`resume.start`) and what each subflow on the pause path\n       *  takes on its first entry. The traverser still walks the REAL chart\n       *  (`fc.root`, `fc.subflows`): the re-entry is never a node an id can\n       *  resolve to. Undefined on normal run() paths. */\n      resume?: ResumeEntry<TOut, TScope>;\n    },\n  ): FlowchartTraverser<TOut, TScope> {\n    const args = this.flowChartArgs;\n    const fc = args.flowChart;\n    const narrativeFlag = this.narrativeEnabled || (fc.enableNarrative ?? false);\n\n    // ── Composed scope factory ─────────────────────────────────────────\n    // Collect all scope modifiers (recorders, redaction) into a single list,\n    // then create ONE factory that applies them in a loop. Replaces the\n    // previous 4-deep closure nesting with a flat, debuggable composition.\n\n    if (overrides?.preserveRecorders) {\n      // Resume mode: keep existing combinedRecorder so narrative accumulates\n    } else if (narrativeFlag) {\n      this.combinedRecorder = new CombinedNarrativeRecorder(this.narrativeOptions);\n    } else {\n      this.combinedRecorder = undefined;\n    }\n\n    this.redactionRule = new RedactionRule(this.redactionPolicy);\n\n    // Build modifier list — each modifier receives the scope after creation\n    type ScopeModifier = (scope: any) => void;\n    const modifiers: ScopeModifier[] = [];\n\n    // 1. Narrative recorder (if enabled)\n    if (this.combinedRecorder) {\n      const recorder = this.combinedRecorder;\n      modifiers.push((scope) => {\n        if (typeof scope.attachScopeRecorder === 'function') scope.attachScopeRecorder(recorder);\n      });\n    }\n\n    // 2. User-provided scope recorders\n    if (this.scopeRecorders.length > 0) {\n      const recorders = this.scopeRecorders;\n      modifiers.push((scope) => {\n        if (typeof scope.attachScopeRecorder === 'function') {\n          for (const r of recorders) scope.attachScopeRecorder(r);\n        }\n      });\n    }\n\n    // 2b. Deferred-observer scope tap (RFC-001 Block 7) — a synthetic\n    // recorder whose hooks CAPTURE into the bounded queue instead of doing\n    // observer work. It rides the same per-stage recorder list as inline\n    // recorders, so it receives exactly the post-redaction events they do.\n    // Absent (zero work, identical list) when nobody opted into deferral.\n    const scopeTap = this.deferredTier?.buildScopeTap();\n    if (scopeTap) {\n      modifiers.push((scope) => {\n        if (typeof scope.attachScopeRecorder === 'function') scope.attachScopeRecorder(scopeTap);\n      });\n    }\n\n    // 3. Redaction policy (conditional — only when policy is set). A\n    // `ScopeFacade` already reads the run's rule through its context (the\n    // rule is installed on the runtime root below); this call is the legacy\n    // protocol for custom scopes that are not facades, and on a facade it\n    // re-states the executor's policy on the shared rule (a no-op).\n    if (this.redactionPolicy) {\n      const policy = this.redactionPolicy;\n      modifiers.push((scope) => {\n        if (typeof scope.useRedactionPolicy === 'function') {\n          scope.useRedactionPolicy(policy);\n        }\n      });\n    }\n\n    // Compose: base factory + modifiers in a single pass.\n    // The marked-keys set is ALWAYS wired up (unconditional — ensures cross-stage\n    // propagation even without a policy, because stages can call setValue(key, val, true)\n    // for per-call redaction). Optional modifiers (recorders, policy) are in the list.\n    const baseFactory = args.scopeFactory;\n    const sharedRedactedKeys = this.redactionRule.markedKeys();\n    const scopeFactory = ((ctx: any, stageName: string, readOnly?: unknown, envArg?: any) => {\n      const scope = baseFactory(ctx, stageName, readOnly, envArg);\n      // Always wire shared redaction state\n      if (typeof (scope as any).useSharedRedactedKeys === 'function') {\n        (scope as any).useSharedRedactedKeys(sharedRedactedKeys);\n      }\n      // Apply optional modifiers\n      for (const mod of modifiers) mod(scope);\n      return scope;\n    }) as ScopeFactory<TScope>;\n\n    // The first stage this traversal runs: the resume's entry, else the chart root.\n    const effectiveRoot = overrides?.resume?.start ?? fc.root;\n    const effectiveInitialContext = overrides?.initialContext ?? args.initialContext;\n\n    // The run's policy (F5): the four dials, the redaction rule and the\n    // mirror flag as ONE frozen object, built once per leg — run AND resume\n    // (a resume brings a fresh rule, as per-call marks reset per leg). The\n    // runtime installs it on its root; every frame of the run, a subflow's\n    // included, holds the same reference. The rule is installed even without\n    // a policy: a per-call `setValue(key, value, true)` marks the key on it,\n    // and the paths that bypass the facade (subflow seed, outputMapper\n    // merge-back, resume re-seed) honour that mark through it. The mirror —\n    // a parallel redacted heap, so `getSnapshot({ redact: true })` is served\n    // at zero post-pass cost — is kept only under a policy.\n    const policy = runPolicy(args.dials, this.redactionRule, this.redactionPolicy !== undefined);\n\n    let runtime: ExecutionRuntime;\n    if (overrides?.existingRuntime) {\n      // Resume mode: reuse existing runtime so execution tree continues from pause point.\n      // Preserve the original root for getSnapshot() (full tree), then advance\n      // rootStageContext to a continuation from the leaf (for traversal).\n      runtime = overrides.existingRuntime;\n      runtime.preserveSnapshotRoot();\n      let leaf = runtime.rootStageContext;\n      while (leaf.next) leaf = leaf.next;\n      runtime.rootStageContext = leaf.createNext('', effectiveRoot.name, effectiveRoot.id);\n      runtime.usePolicy(policy);\n    } else {\n      runtime = new ExecutionRuntime(\n        effectiveRoot.name,\n        effectiveRoot.id,\n        args.defaultValuesForContext,\n        effectiveInitialContext,\n        policy,\n      );\n    }\n\n    return new FlowchartTraverser<TOut, TScope>({\n      // Always the REAL chart — every id (loop targets, a re-visit of the\n      // paused stage) resolves against it. A resume only moves where the\n      // traversal STARTS (`entry`), once.\n      root: fc.root,\n      ...(overrides?.resume?.start && { entry: overrides.resume.start }),\n      ...(overrides?.resume?.startPendingPauses && { pendingPauses: overrides.resume.startPendingPauses }),\n      ...(overrides?.resume && { resume: overrides.resume }),\n      stageMap: fc.stageMap,\n      scopeFactory,\n      executionRuntime: runtime,\n      readOnlyContext: readOnlyContextOverride ?? args.readOnlyContext,\n      throttlingErrorChecker: args.throttlingErrorChecker,\n      streamHandlers: args.streamHandlers,\n      scopeProtectionMode: args.scopeProtectionMode,\n      subflows: fc.subflows,\n      narrativeEnabled: narrativeFlag,\n      buildTimeStructure: fc.buildTimeStructure,\n      logger: fc.logger ?? defaultLogger,\n      signal,\n      executionEnv: env,\n      flowRecorders: this.buildFlowRecordersList(),\n      executionCounter: this._executionCounter,\n      visitCounts: this._visitCounts,\n      runId: this._currentRunId,\n      ...(maxDepth !== undefined && { maxDepth }),\n      ...(maxIterations !== undefined && { maxIterations }),\n    });\n  }\n\n  enableNarrative(options?: CombinedNarrativeRecorderOptions): void {\n    this.narrativeEnabled = true;\n    if (options) this.narrativeOptions = options;\n  }\n\n  /**\n   * Set a declarative redaction policy that applies to all stages.\n   * Must be called before run().\n   */\n  setRedactionPolicy(policy: RedactionPolicy): void {\n    this.redactionPolicy = policy;\n    this.redactionRule = new RedactionRule(policy);\n  }\n\n  /**\n   * Set the read-tracking policy for `StageSnapshot.stageReads` (#14).\n   * Must be called before run(). Equivalent to the `readTracking`\n   * constructor option — see {@link FlowChartExecutorOptions.readTracking}\n   * for the mode semantics ('full' default / 'summary' / 'off').\n   */\n  setReadTracking(mode: ReadTrackingMode): void {\n    this.flowChartArgs.dials = { ...this.flowChartArgs.dials, readTracking: mode };\n  }\n\n  /**\n   * Set the write-tracking policy for `StageSnapshot.stageWrites` (#13c-A).\n   * Must be called before run(). Equivalent to the `writeTracking`\n   * constructor option — see {@link FlowChartExecutorOptions.writeTracking}\n   * for the mode semantics ('full' default / 'summary' / 'off'), the\n   * onCommit-payload consequence, and the redaction-precedence rule.\n   */\n  setWriteTracking(mode: WriteTrackingMode): void {\n    this.flowChartArgs.dials = { ...this.flowChartArgs.dials, writeTracking: mode };\n  }\n\n  /**\n   * Set the commit-values encoding policy for the commit log (#13c-B).\n   * Must be called before run(). Equivalent to the `commitValues`\n   * constructor option — see {@link FlowChartExecutorOptions.commitValues}\n   * for the mode semantics ('full' default / 'delta'), the verb-qualified\n   * `overwrite` consequence, and the `commitValueAt` migration helper.\n   */\n  setCommitValues(mode: CommitValuesMode): void {\n    this.flowChartArgs.dials = { ...this.flowChartArgs.dials, commitValues: mode };\n  }\n\n  /**\n   * Returns a compliance-friendly report of all redaction activity from the\n   * most recent run. Never includes actual values.\n   */\n  getRedactionReport(): RedactionReport {\n    return this.redactionRule.report();\n  }\n\n  // ─── Pause/Resume ───\n\n  /**\n   * Returns the checkpoint from the most recent paused execution, or `undefined`\n   * if the last run completed without pausing.\n   *\n   * The checkpoint is JSON-serializable — store it in Redis, Postgres, localStorage, etc.\n   *\n   * It is fully DETACHED from engine state: every field was deep-copied at\n   * pause time (see `buildPauseCheckpoint`). Holding, mutating, or persisting\n   * it cannot affect the executor, and a later same-executor resume cannot\n   * mutate a checkpoint you already stored.\n   *\n   * @example\n   * ```typescript\n   * const result = await executor.run({ input });\n   * if (executor.isPaused()) {\n   *   const checkpoint = executor.getCheckpoint()!;\n   *   await redis.set(`session:${id}`, JSON.stringify(checkpoint));\n   * }\n   * ```\n   */\n  getCheckpoint(): FlowchartCheckpoint | undefined {\n    return this.lastCheckpoint;\n  }\n\n  /** Returns `true` if the most recent run() was paused (checkpoint available). */\n  isPaused(): boolean {\n    return this.lastCheckpoint !== undefined;\n  }\n\n  /**\n   * Number of commits in the run's commit log. O(1) — direct length\n   * read, no snapshot materialization. Use this to stamp commit\n   * indices on observer events (e.g., `BoundaryRecorder` storing\n   * `commitIdxBefore` / `commitIdxAfter` per domain event for\n   * `CommitRangeIndex` queries — see `footprintjs/trace`).\n   *\n   * Returns 0 before any run; after, returns the cumulative commit\n   * count across the executor's lifetime (including resumes).\n   *\n   * IMPLEMENTATION NOTE: this returns `runtime.executionHistory.length`,\n   * which is the same value as `getSnapshot().commitLog.length`. The\n   * naming asymmetry is historical — the underlying `EventLog` field\n   * is named `executionHistory` but stores the `CommitBundle[]` that\n   * `commitLog` exposes. They always report the same LENGTH (verified by the\n   * \"matches commitLog.length\" integration test); since 9.17.0 the snapshot\n   * serves a detached frozen COPY of the array, not the live one.\n   */\n  getCommitCount(): number {\n    const runtime = this.traverser.getRuntime() as InstanceType<typeof ExecutionRuntime> | undefined;\n    return runtime?.executionHistory.length ?? 0;\n  }\n\n  /**\n   * Resume a paused flowchart from a checkpoint.\n   *\n   * Restores the scope state, calls the paused stage's `resumeFn` with the\n   * provided input (or, for an `interrupt()` pause, re-runs the stage with the\n   * answer), then continues with whatever ran after that stage on the run —\n   * its own `next`, or the continuation of the decider, selector or fork that\n   * dispatched it, at every level of the pause path — and from there walks the\n   * chart as built. When parallel siblings paused in the same fan-out\n   * (`checkpoint.pendingPauses`), the run pauses again with the next sibling's\n   * question once this one's branch is done; the fan-out's join runs after the\n   * last answer. See `ResumeEntry` (`footprintjs/advanced`).\n   *\n   * The checkpoint can come from `getCheckpoint()` on a previous run, or from\n   * a serialized checkpoint stored in Redis/Postgres/localStorage.\n   *\n   * **Recorder/narrative state depends on the resume mode.** Resuming on the SAME\n   * executor that ran preserves and accumulates narrative/metrics/debug across the\n   * pause/resume cycle (preserveRecorders). Resuming on a FRESH executor\n   * (reconstructed from a stored checkpoint) starts with empty recorder state —\n   * collect what you need before discarding the paused executor. A fresh `runId`\n   * is generated either way.\n   *\n   * @example\n   * ```typescript\n   * // Process A — after a pause, persist the checkpoint:\n   * const checkpoint = executor.getCheckpoint()!;\n   * await redis.set(`session:${id}`, JSON.stringify(checkpoint));\n   *\n   * // Process B (possibly different server, same chart) — restore and resume:\n   * const restored = JSON.parse(await redis.get(`session:${id}`));\n   * const executor = new FlowChartExecutor(chart);\n   * const result = await executor.resume(restored, { approved: true });\n   * ```\n   */\n  async resume(\n    checkpoint: FlowchartCheckpoint,\n    resumeInput?: unknown,\n    options?: Pick<RunOptions, 'signal' | 'env' | 'maxDepth' | 'maxIterations'>,\n  ): Promise<ExecutorResult> {\n    // Re-entrancy guard FIRST — resume() mutates the same per-run state run()\n    // does (traverser, runId, checkpoint), so resume-during-run and\n    // double-resume are the same corruption class as concurrent run().\n    if (this._isExecuting) {\n      throw new Error(\n        'FlowChartExecutor: resume() called while another run()/resume() is in flight on this ' +\n          'executor. An executor holds per-run state (runId, recorders, checkpoint) — create ' +\n          'one executor per concurrent run. See docs/guides/execution-model.md.',\n      );\n    }\n    // ── Decode the checkpoint (may come from untrusted external storage, from\n    // any release) — the ONE codec: upcast, then check every pause record\n    // (`pause/record.ts`). (lastCheckpoint is wiped AFTER this — a rejected\n    // checkpoint must not destroy the executor's existing checkpoint state.)\n    checkpoint = decodeCheckpoint(checkpoint);\n\n    // Find the paused node in the graph\n    const pausedNode = this.findNodeInGraph(checkpoint.pausedStageId, checkpoint.subflowPath);\n    if (!pausedNode) {\n      throw new Error(\n        `Cannot resume: stage '${checkpoint.pausedStageId}' not found in flowchart. ` +\n          'The chart may have changed since the checkpoint was created.',\n      );\n    }\n    // Two re-entry shapes, chosen by HOW the pause was raised:\n    //\n    //   • interrupt()      → RE-RUN THE STAGE'S OWN FUNCTION FROM ITS TOP.\n    //     Stages are atomic (the same law `resumeOnError` states): a stage that\n    //     stopped mid-body has no half to resume into, so the whole body runs\n    //     again and the answer comes back out of the `interrupt()` call itself.\n    //     Everything the body did before the interrupt is re-done — which is\n    //     why the docs tell you to keep that half idempotent.\n    //   • addPausableFunction → run the declared `resumeFn`.\n    //\n    // The discriminant is on the checkpoint, so this works cross-executor\n    // (a checkpoint restored from Redis on a fresh process resumes the same way).\n    const isInterruptResume = checkpoint.pausedBy === 'interrupt';\n    if (!pausedNode.resumeFn && !isInterruptResume) {\n      throw new Error(\n        `Cannot resume: stage '${pausedNode.name}' (${pausedNode.id}) has no resumeFn. ` +\n          'Only stages created with addPausableFunction(), or stages that paused via interrupt(), can be resumed.',\n      );\n    }\n    // The resume half — what the paused stage's stand-in runs.\n    // resumeFn signature is (scope, input) per PausableHandler — wrap to match StageFunction(scope, breakFn).\n    let resumeStageFn: StageFunction<TOut, TScope>;\n    if (isInterruptResume) {\n      const originalFn =\n        pausedNode.fn ??\n        this.flowChartArgs.flowChart.stageMap.get(pausedNode.id) ??\n        this.flowChartArgs.flowChart.stageMap.get(pausedNode.name);\n      if (!originalFn) {\n        throw new Error(\n          `Cannot resume: stage '${pausedNode.name}' (${pausedNode.id}) paused via interrupt() but its ` +\n            'stage function is no longer in the chart. The chart may have changed since the checkpoint ' +\n            'was created.',\n        );\n      }\n      resumeStageFn = (scope, breakFn, streamCallback) => {\n        // Deposit the answer for THIS scope instance before the body runs, so\n        // the `interrupt()` call that threw last time returns it this time.\n        // Keyed by scope identity — safe when several branches resume at once.\n        provideInterruptAnswer(scope, resumeInput);\n        return originalFn(scope, breakFn, streamCallback);\n      };\n    } else {\n      const resumeFn = pausedNode.resumeFn!;\n      resumeStageFn = (scope: TScope) => {\n        return resumeFn(scope, resumeInput) as TOut | Promise<TOut>;\n      };\n    }\n\n    // The paused stage's STAND-IN: the stage's OWN node — id, name,\n    // description, tags, and its shape (a decider's branches, a selector's, a\n    // fork parent's children, its `next`) — with its function swapped for the\n    // resume half. Built from the whole node so an `interrupt()` raised inside\n    // a decider, selector or fork-parent function DISPATCHES on resume, as the\n    // stage did on the run (before 9.28.0 only fn/next/tags/retry were copied\n    // and the dispatch was silently skipped). It is where the resumed\n    // traversal starts — and nothing else: it is never in a node map or the\n    // subflow dictionary, so a loop back to the paused id finds the REAL\n    // stage, which pauses again (see ResumeEntry). What runs after it — its\n    // own `next`, else its dispatcher's continuation — is attached by\n    // `ResumeEntry.plan`, from the chart.\n    const standIn = standInFor(pausedNode, resumeStageFn, isInterruptResume);\n\n    // Where the resume re-enters, planned against the chart as built:\n    //\n    //   • TOP-LEVEL PAUSE (subflowPath empty): the resumed traversal starts\n    //     at the stand-in.\n    //   • PAUSE INSIDE SUBFLOWS: it starts at the mount of the first subflow\n    //     on the path, so the outputMappers and the parent's continuation\n    //     run. Each subflow on the path is entered ONCE through its hop: its\n    //     nested runtime is seeded from its capture (in place of the\n    //     inputMapper's values) and its traversal starts at the mount of the\n    //     next subflow — or, at the leaf, at the stand-in. An outer subflow's\n    //     stages before that mount do not run again.\n    //   • AT EVERY LEVEL the entry carries what its dispatcher would have run\n    //     after it — a decider's `next`, a selector's, a fork's join — so a\n    //     subflow mounted as a branch or a fork child hands control back to\n    //     its parent's continuation at the parent's level.\n    //   • Parallel siblings that paused in the same fan-out wait in\n    //     `checkpoint.pendingPauses`: each is raised again in turn, and the\n    //     join runs only once the last one is resumed.\n    //\n    // Everything else walks the REAL chart: `fc.root` and `fc.subflows` are\n    // untouched, so every later loop target and every later subflow entry\n    // (real root, inputMapper) resolves as it would on a run. Refused HERE —\n    // before any state is touched — when the checkpoint's path does not fit\n    // this chart.\n    //\n    // Clone-in: the captures seed nested runtimes (shallow-merged into each\n    // nested SharedMemory), so without a copy the engine would hold live\n    // references into the caller's checkpoint object — caller mutations would\n    // bleed into the resumed run and engine writes would reach a checkpoint\n    // the caller may have already persisted. The same for the waiting\n    // siblings' captures.\n    const fc = this.flowChartArgs.flowChart;\n    const resumeEntry = ResumeEntry.plan<TOut, TScope>({\n      root: fc.root,\n      subflows: fc.subflows,\n      path: checkpoint.subflowPath,\n      captures: structuredClone(checkpoint.subflowStates),\n      standIn,\n      ...(checkpoint.pendingPauses !== undefined && { pendingPauses: structuredClone(checkpoint.pendingPauses) }),\n    });\n\n    // ── Seed the shared execution counter + per-stage visit counts ──\n    //\n    // Only now — every refusal above (the checkpoint's shape, the paused\n    // stage, the plan) leaves the executor exactly as it was. MUST run before\n    // the counter is READ below (the stand-in's runtimeStageId for\n    // `onResume`) AND before createTraverser() hands the traverser these\n    // objects BY REFERENCE. Seeding keeps runtimeStageIds unique and\n    // loopIteration monotonic across a CROSS-executor resume (a fresh\n    // executor starts both at 0/empty; the checkpoint carries the pause-time\n    // values).\n    //\n    // MUTATE, never REPLACE: `_executionCounter` and `_visitCounts` are shared\n    // by reference into the traverser (and, transitively, every subflow\n    // traverser — see FlowchartTraverser's sub-traverser factory). Assigning a\n    // fresh object here would sever that shared reference. Both fields are\n    // optional on the checkpoint (older persisted checkpoints omit them) — skip\n    // seeding when absent, preserving the previous behavior. Same-executor\n    // resume is idempotent: at pause the instance values already equal the\n    // checkpoint's, so re-seeding them changes nothing.\n    if (checkpoint.executionCount !== undefined) {\n      this._executionCounter.value = checkpoint.executionCount;\n    }\n    if (checkpoint.visitCounts) {\n      this._visitCounts.clear();\n      for (const [stageId, count] of Object.entries(checkpoint.visitCounts)) {\n        this._visitCounts.set(stageId, count);\n      }\n    }\n    // (Wiped only now: every refusal above leaves the executor's existing\n    // checkpoint untouched.)\n    this.lastCheckpoint = undefined;\n\n    // Don't clear recorders — resume continues from previous state.\n    // Narrative, metrics, debug entries accumulate across pause/resume.\n    //\n    // Two-mode resume:\n    //   • Same-executor (run() previously called on THIS instance):\n    //     reuse the existing runtime so the execution tree continues\n    //     from the pause point and recorders/narrative accumulate.\n    //   • Cross-executor (fresh executor reconstructed from a stored\n    //     checkpoint): seed a NEW runtime from `checkpoint.sharedState`\n    //     so resume handlers can read pre-pause scope. The execution\n    //     tree starts at the resume entry — we don't have the previous\n    //     traversal's tree on a fresh process anyway.\n    const sameExecutor = this._hasRunBefore;\n    const existingRuntime = sameExecutor\n      ? (this.traverser.getRuntime() as InstanceType<typeof ExecutionRuntime>)\n      : undefined;\n    this._hasRunBefore = true; // any path that resumes counts as a run\n    // Resume gets a NEW runId — resume is logically a distinct run.\n    // Original runId is recoverable from checkpoint metadata if a consumer\n    // needs cross-run audit (we don't store it on the checkpoint today;\n    // future enhancement). See `runId.ts`.\n    this._currentRunId = generateRunId();\n\n    // Initial context: `checkpoint.sharedState` — the top level's view at the\n    // pause (a subflow's outputMapper writes back into it). Same-executor, the\n    // existing runtime is reused and this is moot, but passed for consistency.\n    // Clone-in for the same reason as the captures: `initialContext` seeds\n    // the fresh SharedMemory via `mergeContextWins`, which copies only the TOP\n    // level — nested objects would alias the caller's checkpoint.\n    const resumeInitialContext = structuredClone(checkpoint.sharedState);\n\n    this.traverser = this.createTraverser(\n      options?.signal,\n      undefined,\n      options?.env,\n      options?.maxDepth,\n      options?.maxIterations,\n      {\n        initialContext: resumeInitialContext,\n        preserveRecorders: true,\n        ...(existingRuntime ? { existingRuntime } : {}),\n        resume: resumeEntry,\n      },\n    );\n\n    // Fire onResume event on all recorders (flow + scope). Stamp the\n    // synthetic TraversalContext for the resumed stage with the NEW\n    // runId so consumers detect \"this is a fresh logical run\" via\n    // the same runId-change pattern they use for `onRunStart`. The stamp is\n    // built by the one constructor (`engine/traversalContext.ts`): it names the\n    // REAL subflow the stand-in runs in and its depth, and LINKS to the paused\n    // execution (`resumedFrom`, read off `checkpoint.pausedExecution`) — 9.37.0.\n    //\n    // The runtimeStageId is the STAND-IN's own: it runs after one mount per\n    // subflow on the path (each entered at its mount), so its execution index\n    // is the counter plus the path's length — the event and the stand-in's\n    // commit name the same execution. (Fired before the traversal on purpose:\n    // `onResume` precedes `onRunStart`, which recorders rely on to adopt the\n    // new runId without resetting.) The one shape where the index cannot be\n    // known up front — a degraded checkpoint missing an OUTER subflow's\n    // capture, whose opening stages then re-run — names the planned position.\n    const hasInput = resumeInput !== undefined;\n    const stepsBeforeStandIn = resumeEntry.stepsBeforeStandIn ?? checkpoint.subflowPath.length;\n    const resumeRuntimeStageId = buildRuntimeStageId(pausedNode.id, this._executionCounter.value + stepsBeforeStandIn);\n    const resumedFrom = resumeLinkOf(checkpoint);\n    const flowResumeEvent = {\n      stageName: pausedNode.name,\n      stageId: pausedNode.id,\n      hasInput,\n      traversalContext: resumeTraversalContext({\n        runId: this._currentRunId,\n        stageId: pausedNode.id,\n        stageName: pausedNode.name,\n        runtimeStageId: resumeRuntimeStageId,\n        subflowPath: checkpoint.subflowPath,\n        resumedFrom,\n      }),\n      channel: 'flow' as const,\n    };\n    // Executor-made (`HOOKS.onResume.executorMade`): fired through the same `fire` loop as every\n    // engine event, so a throwing recorder is isolated instead of rejecting `resume()` (R10).\n    const flowListeners = this.combinedRecorder ? [this.combinedRecorder, ...this.flowRecorders] : this.flowRecorders;\n    fire(flowListeners, 'onResume', flowResumeEvent, RESUME_FLOW_FAILURE);\n\n    const scopeResumeEvent = {\n      stageName: pausedNode.name,\n      stageId: pausedNode.id,\n      runtimeStageId: resumeRuntimeStageId,\n      hasInput,\n      ...(resumedFrom && { resumedFrom }),\n      pipelineId: '',\n      timestamp: Date.now(),\n      channel: 'scope' as const,\n    };\n    fire(this.scopeRecorders, 'onResume', scopeResumeEvent, (error, _recorder, hook) =>\n      // The scope channel's policy (as `ScopeFacade` routes a stage's hook failure): the throw\n      // becomes an `onError` on every scope recorder, whose own throw is dropped.\n      fire(this.scopeRecorders, 'onError', recorderFailureEvent(scopeResumeEvent, error, hook)),\n    );\n\n    // Deferred tier (RFC-001): these executor-synthesized onResume events\n    // bypass the per-stage dispatch sites, so capture them directly.\n    if (this.deferredTier) {\n      this.deferredTier.capture('flow', 'onResume', resumeRuntimeStageId, this._currentRunId, flowResumeEvent);\n      this.deferredTier.capture(\n        'scope',\n        'onResume',\n        scopeResumeEvent.runtimeStageId,\n        scopeResumeEvent.pipelineId,\n        scopeResumeEvent,\n      );\n    }\n\n    // Set AFTER all sync validation/lookup throws above (nothing can leak the\n    // flag); no await between the top-of-method check and here, so race-free.\n    this._isExecuting = true;\n    try {\n      const result = await this.traverser.execute();\n      // Terminal flush (RFC-001 Block 8) — same boundary contract as run().\n      this.deferredTier?.terminalFlush();\n      return result;\n    } catch (error: unknown) {\n      this.deferredTier?.terminalFlush();\n      if (isPauseSignal(error)) {\n        this.lastCheckpoint = this.buildPauseCheckpoint(error);\n        return { paused: true, checkpoint: this.lastCheckpoint } satisfies PausedResult;\n      }\n      throw error;\n    } finally {\n      this._isExecuting = false;\n    }\n  }\n\n  /**\n   * Build a fully DETACHED checkpoint from a caught PauseSignal.\n   *\n   * Every field is deep-copied via one `structuredClone` of the assembled\n   * checkpoint, because the raw pieces alias live engine state:\n   *\n   *   - `sharedState` IS `SharedMemory`'s current generation — never edited,\n   *     but (copy-on-write, 9.29.0) every later generation shares its\n   *     unchanged subtrees, so a checkpoint that aliased it would alias the\n   *     resumed run's state too.\n   *   - `executionTree` nodes are fresh, but their `logs`/`errors`/`metrics`/\n   *     `evals`/`stageReads`/`flowMessages` fields reference live\n   *     `DiagnosticCollector` bags that keep accumulating on same-executor\n   *     resume.\n   *   - `subflowStates` values are shallow copies whose NESTED objects alias\n   *     subflow memory, and they get seeded back into live runtimes on resume.\n   *   - `subflowResults` values stay referenced by the traverser's results map.\n   *\n   * The checkpoint is persisted by contract (\"store in Redis/Postgres\") — it\n   * must never share structure with the engine. Pause is not a hot path; the\n   * clone cost is irrelevant.\n   *\n   * The JSON-safe checkpoint contract (no functions, no class instances)\n   * governs CONSUMER-owned data — but the executionTree's diagnostic bags\n   * accept ANY value at write time without cloning ($debug/$error/$metric/\n   * $eval store raw references), so a contract-compliant run can still carry\n   * a non-cloneable diagnostic. Observability side-bags never abort traversal\n   * anywhere else in the library, so they must not abort the pause either:\n   * on clone failure we sanitize the diagnostic bags (non-cloneable values\n   * become '[non-serializable: …]' markers — the live engine bags are never\n   * touched) and retry. If the retry STILL fails, the violation is in\n   * consumer-owned data (realistically `pauseData` — a function can never\n   * reach shared state in the first place: TransactionBuffer clones every\n   * written value at write time, so the offending write already rejected)\n   * and we throw a DESCRIPTIVE contract error naming the offending\n   * checkpoint field(s). A naked DataCloneError never escapes.\n   *\n   * Subflow scope capture (`subflowStates`) survives ONLY on the signal — the\n   * nested runtimes are GC'd as the stack unwinds. Promoting it onto the\n   * checkpoint here lets cross-executor resume restore pre-pause subflow\n   * scope (e.g. an Agent's `scope.history`). Empty `{}` for root-level pauses.\n   */\n  private buildPauseCheckpoint(signal: PauseSignal): FlowchartCheckpoint {\n    // Every pause that paused in THIS run is named by it; a sibling raised again\n    // on resume keeps the run it originally paused in.\n    signal.completeExecution(this._currentRunId);\n    const snapshot = this.traverser.getSnapshot();\n    const sfResults = this.traverser.getSubflowResults();\n    // Lean subflowResults for the checkpoint (design: docs/design/subflow-commit-visibility.md):\n    //   • DROP the per-iteration mount-runtimeStageId keys ('#') that the snapshot dual-keys —\n    //     they would DOUBLE the checkpoint, and resume restores scope from `subflowStates`, not these.\n    //   • STRIP each subflow's `treeContext.history` — resume NEVER reads `subflowResults` (it\n    //     restores from `subflowStates` + `sharedState`), so the per-subflow commit log is pure\n    //     checkpoint bloat. The flat agent's checkpoint carries no commit history either → symmetric.\n    const leanSubflowResults: Record<string, unknown> = {};\n    for (const [key, value] of sfResults) {\n      if (isExecutionKey(key)) continue; // per-iteration keys are snapshot-only\n      const v = value as unknown as { treeContext?: Record<string, unknown> };\n      if (v?.treeContext) {\n        const treeCtxRest: Record<string, unknown> = {};\n        for (const ck of Object.keys(v.treeContext)) {\n          if (ck !== 'history') treeCtxRest[ck] = v.treeContext[ck]; // strip the per-subflow commit log\n        }\n        leanSubflowResults[key] = { ...(value as unknown as Record<string, unknown>), treeContext: treeCtxRest };\n      } else {\n        leanSubflowResults[key] = value;\n      }\n    }\n    const checkpoint = {\n      // The format (9.39.0) — read back by `pause/record.ts · decodeCheckpoint`.\n      checkpointVersion: CHECKPOINT_VERSION,\n      sharedState: snapshot.sharedState,\n      executionTree: snapshot.executionTree,\n      pausedStageId: signal.stageId,\n      // The paused EXECUTION (9.37.0) — a queued sibling raised on resume\n      // carries the run it ORIGINALLY paused in.\n      ...(signal.pausedExecution && { pausedExecution: signal.pausedExecution }),\n      subflowPath: signal.subflowPath,\n      pauseData: signal.pauseData,\n      subflowStates: signal.subflowStates,\n      // Counter continuity — seeded back in resume() so runtimeStageIds stay\n      // unique and loopIteration stays monotonic across a CROSS-executor resume\n      // (both are plain number/record, so they ride the single structuredClone\n      // below untouched). See test/lib/pause/resume-execution-counter-continuity.test.ts.\n      executionCount: this._executionCounter.value,\n      visitCounts: Object.fromEntries(this._visitCounts),\n      ...(Object.keys(leanSubflowResults).length > 0 && { subflowResults: leanSubflowResults }),\n      // Invoker context — collected during traversal bubble-up (not tree-walked).\n      // (`continuationStageId` is legacy-only since 9.39.0: no longer written.)\n      ...(signal.invokerStageId && { invokerStageId: signal.invokerStageId }),\n      // Parallel siblings' pauses from the same fan-out, waiting their turn\n      // (9.28.0). Absent when only one child paused — the shape every\n      // earlier checkpoint has.\n      ...(signal.pendingPauses.length > 0 && { pendingPauses: signal.pendingPauses }),\n      // HOW the pause was raised. One checkpoint shape, one extra optional\n      // field — an interrupt() pause is not a second kind of checkpoint, it is\n      // the same checkpoint that resume() re-enters differently (stage top vs\n      // resumeFn). Absent for every pre-9.14.0 checkpoint, which is correct.\n      ...(signal.pausedBy && { pausedBy: signal.pausedBy }),\n      pausedAt: Date.now(),\n    };\n    try {\n      return structuredClone(checkpoint);\n    } catch {\n      // Non-cloneable diagnostics must not swallow the pause — sanitize the\n      // executionTree's bags (markers replace the offenders) and retry.\n      try {\n        checkpoint.executionTree = sanitizeDiagnosticBags(checkpoint.executionTree as StageSnapshot);\n        return structuredClone(checkpoint);\n      } catch (retryError) {\n        // Genuine JSON-safe contract violation in consumer-owned data.\n        throw describeCheckpointCloneFailure(checkpoint, retryError);\n      }\n    }\n  }\n\n  /**\n   * Find a StageNode in the compiled graph by ID.\n   * Handles subflow paths by drilling into registered subflows.\n   */\n  private findNodeInGraph(stageId: string, subflowPath: readonly string[]): StageNode<TOut, TScope> | undefined {\n    const fc = this.flowChartArgs.flowChart;\n\n    if (subflowPath.length === 0) {\n      // Top-level: DFS from root\n      return this.dfsFind(fc.root, stageId);\n    }\n\n    // Subflow: drill into the subflow chain, then search from the last subflow's root\n    let subflowRoot: StageNode<TOut, TScope> | undefined;\n    for (const sfId of subflowPath) {\n      const subflow = fc.subflows?.[sfId];\n      if (!subflow) return undefined;\n      subflowRoot = subflow.root;\n    }\n    if (!subflowRoot) return undefined;\n    return this.dfsFind(subflowRoot, stageId);\n  }\n\n  /** DFS search for a node by ID in the StageNode graph. Cycle-safe via visited set. */\n  private dfsFind(\n    node: StageNode<TOut, TScope>,\n    targetId: string,\n    visited = new Set<string>(),\n  ): StageNode<TOut, TScope> | undefined {\n    // Skip loop back-edge references (they share the target's ID but have no fn/resumeFn)\n    if (node.isLoopRef) return undefined;\n    if (visited.has(node.id)) return undefined;\n    visited.add(node.id);\n    if (node.id === targetId) return node;\n    if (node.children) {\n      for (const child of node.children) {\n        const found = this.dfsFind(child, targetId, visited);\n        if (found) return found;\n      }\n    }\n    if (node.next) return this.dfsFind(node.next, targetId, visited);\n    return undefined;\n  }\n\n  // ─── ScopeRecorder Management ───\n\n  /**\n   * Attach a scope ScopeRecorder to observe data operations (reads, writes, commits).\n   * Automatically attached to every ScopeFacade created during traversal.\n   * Must be called before run().\n   *\n   * **Idempotent by ID:** If a recorder with the same `id` is already attached,\n   * it is replaced (not duplicated). This prevents double-counting when both\n   * a framework and the user attach the same recorder type.\n   *\n   * Built-in recorders use auto-increment IDs (`metrics-1`, `debug-1`, ...) by\n   * default, so multiple instances with different configs coexist. To override\n   * a framework-attached recorder, pass the same well-known ID.\n   *\n   * @example\n   * ```typescript\n   * // Multiple recorders with different configs — each gets a unique ID\n   * executor.attachScopeRecorder(new MetricRecorder());\n   * executor.attachScopeRecorder(new DebugRecorder({ verbosity: 'minimal' }));\n   *\n   * // Override a framework-attached recorder by passing its well-known ID\n   * executor.attachScopeRecorder(new MetricRecorder('metrics'));\n   *\n   * // Attaching twice with same ID replaces (no double-counting)\n   * executor.attachScopeRecorder(new MetricRecorder('my-metrics'));\n   * executor.attachScopeRecorder(new MetricRecorder('my-metrics')); // replaces previous\n   * ```\n   *\n   * **Delivery tier (RFC-001):** pass `{ delivery: 'deferred' }` to take the\n   * recorder out of the engine's hot path — events are captured into a\n   * bounded queue and delivered at the next microtask checkpoint (\"one beat\n   * behind\"). Omitting `delivery` keeps the historical synchronous call,\n   * byte-identical to previous releases. Re-attaching the same `id` with a\n   * different tier SWAPS tiers cleanly — never double delivery. See\n   * `docs/guides/observers-deferred.md`.\n   */\n  attachScopeRecorder(recorder: ScopeRecorder, options?: AttachRecorderOptions): void {\n    // Tier swap, both directions: an id lives on exactly ONE tier per list.\n    this.scopeRecorders = this.scopeRecorders.filter((r) => r.id !== recorder.id);\n    if (options?.delivery === 'deferred') {\n      this.ensureDeferredTier(options).register(recorder, { scope: true }, options);\n      return;\n    }\n    this.deferredTier?.removeFromLists(recorder.id, { scope: true });\n    this.scopeRecorders.push(recorder);\n  }\n\n  /**\n   * Lazily create the executor's ONE deferred-observer tier (one merged\n   * queue, total event order across all three channels). The FIRST deferred\n   * attach's options configure the dispatcher; later differing options are\n   * dev-warned and ignored (see `AttachRecorderOptions`).\n   */\n  private ensureDeferredTier(options?: AttachRecorderOptions): DeferredObserverTier {\n    if (!this.deferredTier) this.deferredTier = new DeferredObserverTier(options);\n    return this.deferredTier;\n  }\n\n  // ─── Detach (T4) ─────────────────────────────────────────────────────────\n  //\n  // Bare-executor entry point for fire-and-forget child flowchart execution.\n  // Use from outside any chart (consumer code that wants to detach work\n  // without first running a parent chart). For detach FROM INSIDE a stage,\n  // use `scope.$detachAndJoinLater(...)` / `scope.$detachAndForget(...)` —\n  // those mint refIds from the calling stage's runtimeStageId for trace\n  // correlation; the bare-executor entries use a synthetic prefix\n  // (`__executor__`) instead.\n\n  /**\n   * Detach a child flowchart on the given driver and return a `DetachHandle`\n   * the caller can `wait()` on (Promise) or read `.status` from (sync).\n   *\n   * The driver is a REQUIRED first argument — there is no library-default,\n   * to keep the engine free of driver imports and to make the choice of\n   * scheduling algorithm explicit at the call site.\n   *\n   * @example\n   * ```typescript\n   * import { microtaskBatchDriver } from 'footprintjs/detach';\n   *\n   * const exec = new FlowChartExecutor(parentChart);\n   * const handle = exec.detachAndJoinLater(microtaskBatchDriver, telemetryChart, { event: 'x' });\n   * await handle.wait(); // optional\n   * ```\n   */\n  detachAndJoinLater(\n    driver: import('../detach/types.js').DetachDriver,\n    child: import('../builder/types.js').FlowChart,\n    input?: unknown,\n  ): import('../detach/types.js').DetachHandle {\n    return _detachAndJoinLater(driver, child, input, '__executor__');\n  }\n\n  /**\n   * Detach a child flowchart on the given driver and DISCARD the handle.\n   * Use for telemetry exports / fire-and-forget side effects where the\n   * caller doesn't care about the result.\n   *\n   * Errors raised by the child still land on the (discarded) handle — they\n   * go silent unless surfaced through a recorder. For observable detach,\n   * prefer `detachAndJoinLater` and surface failures via `.wait().catch()`.\n   */\n  detachAndForget(\n    driver: import('../detach/types.js').DetachDriver,\n    child: import('../builder/types.js').FlowChart,\n    input?: unknown,\n  ): void {\n    _detachAndForget(driver, child, input, '__executor__');\n  }\n\n  /** Detach all scope Recorders with the given ID — both delivery tiers. */\n  detachScopeRecorder(id: string): void {\n    this.scopeRecorders = this.scopeRecorders.filter((r) => r.id !== id);\n    this.deferredTier?.removeFromLists(id, { scope: true });\n  }\n\n  /** Returns a defensive copy of attached scope Recorders (both tiers). */\n  getScopeRecorders(): ScopeRecorder[] {\n    return [...this.scopeRecorders, ...(this.deferredTier?.scopeListRecorders() ?? [])];\n  }\n\n  // ─── FlowRecorder Management ───\n\n  /**\n   * Attach a FlowRecorder to observe control flow events.\n   * Automatically enables narrative if not already enabled.\n   * Must be called before run() — recorders are passed to the traverser at creation time.\n   *\n   * **Idempotent by ID:** replaces existing recorder with same `id`.\n   *\n   * **Delivery tier (RFC-001):** pass `{ delivery: 'deferred' }` for\n   * next-checkpoint delivery off the hot path — see `attachScopeRecorder`.\n   */\n  attachFlowRecorder(recorder: FlowRecorder, options?: AttachRecorderOptions): void {\n    // Tier swap, both directions: an id lives on exactly ONE tier per list.\n    this.flowRecorders = this.flowRecorders.filter((r) => r.id !== recorder.id);\n    this.narrativeEnabled = true;\n    if (options?.delivery === 'deferred') {\n      this.ensureDeferredTier(options).register(recorder, { flow: true }, options);\n      return;\n    }\n    this.deferredTier?.removeFromLists(recorder.id, { flow: true });\n    this.flowRecorders.push(recorder);\n  }\n\n  /** Detach all FlowRecorders with the given ID — both delivery tiers. */\n  detachFlowRecorder(id: string): void {\n    this.flowRecorders = this.flowRecorders.filter((r) => r.id !== id);\n    this.deferredTier?.removeFromLists(id, { flow: true });\n  }\n\n  /** Returns a defensive copy of attached FlowRecorders (both tiers). */\n  getFlowRecorders(): FlowRecorder[] {\n    return [...this.flowRecorders, ...(this.deferredTier?.flowListRecorders() ?? [])];\n  }\n\n  // ─── Combined ScopeRecorder Management ───\n\n  /**\n   * Attach a recorder that may observe multiple event streams (scope\n   * data-flow, control-flow, or both). Detects at runtime which streams the\n   * recorder has methods for and routes it to the correct internal channels.\n   *\n   * Preferred over calling `attachScopeRecorder` and `attachFlowRecorder`\n   * separately, because forgetting one of the two is a silent foot-gun —\n   * half your events never fire and there is no runtime warning. With\n   * `attachCombinedRecorder` the library guarantees the recorder's declared\n   * methods all fire, and adds no overhead versus two explicit calls.\n   *\n   * ## Idempotency\n   *\n   * Idempotent by `id` across ALL channels — re-attaching with the same `id`\n   * replaces the previous instance everywhere it was registered. Mixing\n   * `attachCombinedRecorder(x)` with a prior `attachScopeRecorder(y)` or\n   * `attachFlowRecorder(y)` that share `x.id === y.id` is also safe: the\n   * combined attach replaces the single-channel registration on whichever\n   * channel(s) `x` has methods for. No duplicate firings occur.\n   *\n   * ## Narrative activation\n   *\n   * If the recorder has any control-flow methods, `enableNarrative()` is\n   * called as a side effect (the narrative subsystem is required to emit\n   * control-flow events). Data-flow-only recorders do NOT activate the\n   * narrative.\n   *\n   * ## Detection rule\n   *\n   * Only **own** event methods count (see `hasRecorderMethods`). Methods\n   * inherited via the prototype chain are ignored — this protects against\n   * accidental `Object.prototype` pollution attaching handlers you never\n   * declared. A recorder that provides only `clear`/`toSnapshot` is a\n   * no-op and emits a dev-mode warning to surface the likely mistake.\n   *\n   * @example\n   * ```typescript\n   * const audit: CombinedRecorder = {\n   *   id: 'audit',\n   *   onWrite: (e) => log('scope write', e.key),\n   *   onDecision: (e) => log('routed to', e.chosen),\n   * };\n   * executor.attachCombinedRecorder(audit);\n   * ```\n   */\n  attachCombinedRecorder(recorder: CombinedRecorder, options?: AttachRecorderOptions): void {\n    const hasData = hasRecorderMethods(recorder);\n    const hasFlow = hasFlowRecorderMethods(recorder);\n    const hasEmit = hasEmitRecorderMethods(recorder);\n\n    // Delivery tier (RFC-001): options bag OR the recorder's own\n    // `delivery: 'deferred'` field. The field is a string — channel routing\n    // above counts event-METHOD properties only, so declaring it never\n    // changes which channels the recorder lands on.\n    const delivery = options?.delivery ?? recorder.delivery;\n    const tierOptions: AttachRecorderOptions | undefined = delivery === undefined ? options : { ...options, delivery };\n\n    // Emit recorders live on the SAME channel as data-flow recorders\n    // (ScopeFacade iterates `_recorders` for onEmit dispatch). So\n    // attachEmitRecorder internally calls attachScopeRecorder — but we want to\n    // avoid double-attach when the recorder implements BOTH onEmit AND\n    // other ScopeRecorder methods. Short-circuit: if hasData OR hasEmit, the\n    // recorder lands on the scope-recorder list exactly once.\n    if (hasData || hasEmit) this.attachScopeRecorder(recorder as ScopeRecorder, tierOptions);\n    if (hasFlow) this.attachFlowRecorder(recorder as FlowRecorder, tierOptions);\n\n    if (!hasData && !hasFlow && !hasEmit && isDevMode()) {\n      // Dev-mode only: silent skips are invisible and produce hard-to-debug\n      // \"why didn't my recorder fire\" reports. Per library convention, gated\n      // on the central isDevMode() flag (not process.env) so consumers can\n      // control dev tooling centrally via enableDevMode()/disableDevMode().\n      // eslint-disable-next-line no-console\n      console.warn(\n        `[footprintjs] attachCombinedRecorder: recorder '${recorder.id}' has ` +\n          'no observer event methods — nothing to attach. Did you forget to ' +\n          'add an on* handler (onWrite, onDecision, onSubflowEntry, ...)? ' +\n          'Note: only OWN properties count; methods on the prototype chain ' +\n          'are ignored on purpose.',\n      );\n    }\n  }\n\n  /**\n   * Detach a combined recorder from all channels it was attached to.\n   * Safe to call if the recorder was only on one channel or never attached.\n   */\n  detachCombinedRecorder(id: string): void {\n    this.detachScopeRecorder(id);\n    this.detachFlowRecorder(id);\n  }\n\n  // ─── Emit ScopeRecorder Management (Phase 3) ───\n\n  /**\n   * Attach an `EmitRecorder` — an observer for consumer-emitted structured\n   * events fired via `scope.$emit(name, payload)`.\n   *\n   * Internally, emit recorders share the scope-recorder channel because\n   * emit events fire from inside `ScopeFacade` during stage execution,\n   * same timing as `onRead`/`onWrite`. This method is a convenience that\n   * delegates to `attachScopeRecorder` — consumers can also use\n   * `attachScopeRecorder` directly for a recorder that implements BOTH\n   * `onWrite` and `onEmit`. Either approach places the recorder on the\n   * same underlying list, so `onEmit` fires exactly once per event.\n   *\n   * **Idempotent by `id`:** replaces existing recorder with same `id`.\n   *\n   * @example\n   * ```typescript\n   * executor.attachEmitRecorder({\n   *   id: 'token-meter',\n   *   onEmit: (e) => {\n   *     if (e.name === 'agentfootprint.llm.tokens') trackTokens(e.payload);\n   *   },\n   * });\n   * ```\n   */\n  attachEmitRecorder(recorder: EmitRecorder, options?: AttachRecorderOptions): void {\n    this.attachScopeRecorder(recorder as ScopeRecorder, options);\n  }\n\n  /** Detach an `EmitRecorder` by id. Safe to call if never attached. */\n  detachEmitRecorder(id: string): void {\n    this.detachScopeRecorder(id);\n  }\n\n  /**\n   * Returns a defensive copy of attached recorders (both delivery tiers)\n   * filtered to those that implement `onEmit`. Useful for inspection during\n   * testing.\n   */\n  getEmitRecorders(): EmitRecorder[] {\n    return this.getScopeRecorders().filter(\n      (r): r is EmitRecorder => typeof (r as { onEmit?: unknown }).onEmit === 'function',\n    );\n  }\n\n  /**\n   * Returns structured narrative entries — the single public narrative API.\n   * Each entry has a type (stage, step, condition, fork, etc.), text, and\n   * depth. Consumers render however they want; call `.map(e => e.text)`\n   * if a flat `string[]` is needed locally.\n   */\n  getNarrativeEntries(): CombinedNarrativeEntry[] {\n    if (this.combinedRecorder) {\n      return this.combinedRecorder.getEntries();\n    }\n    const flowSentences = this.traverser.getNarrative();\n    return flowSentences.map((text) => ({ type: 'stage' as const, text, depth: 0 }));\n  }\n\n  /**\n   * Returns the combined FlowRecorders list. When narrative is enabled,\n   * includes the CombinedNarrativeRecorder (which builds merged flow+data\n   * entries inline). Plus any user-attached recorders.\n   */\n  private buildFlowRecordersList(): FlowRecorder[] | undefined {\n    const recorders: FlowRecorder[] = [];\n    if (this.combinedRecorder) {\n      recorders.push(this.combinedRecorder);\n    }\n    recorders.push(...this.flowRecorders);\n    // Deferred-observer flow tap (RFC-001 Block 7) — captures every flow\n    // event for deferred listeners. Appended like any other flow recorder,\n    // so the FlowRecorderDispatcher site needs no tier logic of its own.\n    const flowTap = this.deferredTier?.buildFlowTap();\n    if (flowTap) recorders.push(flowTap);\n    return recorders.length > 0 ? recorders : undefined;\n  }\n\n  /**\n   * Execute the chart. Resolves when the run finishes — or pauses, if a\n   * pausable stage returned data (check `isPaused()` afterward).\n   *\n   * @param options `{ input, env }` — `input` is the frozen business input\n   *   (read in a stage via `scope.$getArgs()`); `env` is infrastructure context\n   *   like `{ signal, timeoutMs, traceId }` (read via `scope.$getEnv()`).\n   *\n   * After it resolves, read results off the executor:\n   * - `getSnapshot()` — full state, commit log, execution tree.\n   * - `getNarrativeEntries()` — the plain-English trace (call `enableNarrative()`\n   *   or attach a `narrative()` recorder first).\n   * - `isPaused()` — true if a stage paused; then use `getCheckpoint()` / `resume()`.\n   *\n   * One run at a time per executor — it holds per-run state (runId, recorders,\n   * checkpoint). Create one executor per concurrent run.\n   */\n  async run(options?: RunOptions): Promise<ExecutorResult> {\n    // Re-entrancy guard FIRST — before clearing recorders or touching any\n    // per-run field, so a rejected concurrent call leaves the in-flight run\n    // completely untouched.\n    if (this._isExecuting) {\n      throw new Error(\n        'FlowChartExecutor: run() called while another run()/resume() is in flight on this ' +\n          'executor. An executor holds per-run state (runId, recorders, checkpoint) — create ' +\n          'one executor per concurrent run. See docs/guides/execution-model.md.',\n      );\n    }\n    // Validate input against inputSchema if both are present. Validation runs\n    // BEFORE the timeout timer is created so a rejected input can't leak a\n    // pending timer (same \"failed entry leaves no side effects\" rule as the\n    // re-entrancy guard above).\n    let validatedInput = options?.input;\n    if (validatedInput && this.flowChartArgs.flowChart.inputSchema) {\n      validatedInput = validateInput(this.flowChartArgs.flowChart.inputSchema, validatedInput);\n    }\n\n    let signal = options?.signal;\n    let timeoutId: ReturnType<typeof setTimeout> | undefined;\n\n    // Create an internal AbortController for timeoutMs\n    if (options?.timeoutMs && !signal) {\n      const controller = new AbortController();\n      signal = controller.signal;\n      timeoutId = setTimeout(\n        () => controller.abort(new Error(`Execution timed out after ${options.timeoutMs}ms`)),\n        options.timeoutMs,\n      );\n    }\n\n    // User-attached recorders (flowRecorders + scopeRecorders) are cleared via clear() to prevent\n    // cross-run accumulation. The combinedRecorder is NOT cleared here — createTraverser() always\n    // creates a fresh CombinedNarrativeRecorder instance on each run, so stale state is never an issue.\n    for (const r of this.flowRecorders) {\n      r.clear?.();\n    }\n    for (const r of this.scopeRecorders) {\n      r.clear?.();\n    }\n    this.deferredTier?.clearRecorders();\n\n    this.lastCheckpoint = undefined;\n    this._executionCounter = { value: 0 }; // Reset counter on fresh run\n    this._visitCounts = new Map(); // Reset loop-iteration counts on fresh run (twin of _executionCounter)\n    this._currentRunId = generateRunId(); // Fresh runId per run() call\n    this._hasRunBefore = true; // mark so a later resume() takes the\n    // same-executor branch (reuse runtime, accumulate execution tree).\n    this.traverser = this.createTraverser(\n      signal,\n      validatedInput,\n      options?.env,\n      options?.maxDepth,\n      options?.maxIterations,\n    );\n    // Set AFTER all sync validation throws (nothing above can leak the flag);\n    // no await between the top-of-method check and here, so this is race-free.\n    this._isExecuting = true;\n    try {\n      const result = await this.traverser.execute();\n      // Terminal flush (RFC-001 Block 8) at the RESOLVE boundary: every\n      // captured-but-undelivered observer event is delivered synchronously\n      // before run() returns — \"one beat behind\" never becomes \"lost at exit\".\n      this.deferredTier?.terminalFlush();\n      return result;\n    } catch (error: unknown) {\n      // Terminal flush at the PAUSE and REJECT boundaries — this is the\n      // OUTERMOST handler (a pause re-throws through subflow traversers\n      // without exit events, so per-traverser hooks would miss it). Runs\n      // before the checkpoint is exposed and before the error reaches the\n      // caller.\n      this.deferredTier?.terminalFlush();\n      if (isPauseSignal(error)) {\n        // Build a detached checkpoint from current execution state — see\n        // buildPauseCheckpoint() for the deep-copy rationale.\n        this.lastCheckpoint = this.buildPauseCheckpoint(error);\n        // Return a PauseResult-shaped value so callers can check without try/catch\n        return { paused: true, checkpoint: this.lastCheckpoint } satisfies PausedResult;\n      }\n      throw error;\n    } finally {\n      this._isExecuting = false;\n      if (timeoutId !== undefined) clearTimeout(timeoutId);\n    }\n  }\n\n  /**\n   * Flush the deferred-observer backlog, then await async listener\n   * completions under a deadline (RFC-001 Block 8 — the serverless /\n   * graceful-shutdown pattern: call before the process freezes or exits so\n   * \"one beat behind\" work is not lost). Resolves immediately with zeros\n   * when no deferred observer was ever attached. `pending === 0` means a\n   * full drain; a non-zero `pending` reports continuations (plus any queued\n   * events) still outstanding at the deadline — honest, never silent.\n   */\n  drainObservers(opts?: { timeoutMs?: number }): Promise<ObserverDrainResult> {\n    if (!this.deferredTier) return Promise.resolve({ done: 0, failed: 0, pending: 0 });\n    return this.deferredTier.drain(opts);\n  }\n\n  // ─── Introspection ───\n\n  /**\n   * Returns the runtime snapshot.\n   *\n   * @param options.redact  When `true`, `sharedState` comes from the parallel\n   *   redacted mirror (if maintained — see `setRedactionPolicy`). This is\n   *   the safe view for exporting traces externally (paste into a viewer,\n   *   share with support). When no redaction policy is configured the\n   *   redacted mirror is not maintained, so this flag is a no-op —\n   *   `sharedState` is the raw working memory either way. Default `false`.\n   *\n   *   The commit log is already redacted at write-time regardless of this\n   *   flag, and the execution tree carries only structural metadata.\n   *   `subflowResults[*].treeContext.globalContext` follows the flag too\n   *   (9.20.0): under `redact: true` it is each subflow's own redacted\n   *   mirror; plain, the subflow's live heap.\n   *\n   * **Treat `sharedState` as READ-ONLY.** In production it is a live view of\n   * the engine's working memory (zero copy cost) — mutating it corrupts\n   * engine state. In dev mode (`enableDevMode()`) it is a deep-frozen CLONE,\n   * so any consumer mutation throws loudly instead of corrupting silently.\n   */\n  getSnapshot(options?: { redact?: boolean }): RuntimeSnapshot {\n    const snapshot = this.traverser.getSnapshot(options) as RuntimeSnapshot;\n    if (isDevMode()) {\n      // Dev-mode mutation guard: freeze a CLONE, never the live engine\n      // state — `snapshot.sharedState` IS SharedMemory's current generation,\n      // whose unchanged subtrees every later generation shares\n      // (copy-on-write, 9.29.0).\n      // Production stays zero-copy; clone-always is a measured decision\n      // deferred until the bench says it's affordable (BACKLOG #8).\n      // NOTE: deepFreeze (capture/freeze.ts — the one walk) cannot reach\n      // Map/Set INTERNALS (`map.set()` on the frozen clone won't throw) and\n      // skips typed arrays. The CLONE still isolates the engine.\n      snapshot.sharedState = deepFreeze(structuredClone(snapshot.sharedState));\n    }\n    const sfResults = this.traverser.getSubflowResults();\n    if (sfResults.size > 0) {\n      // Under `redact: true` each subflow's `globalContext` is its own mirror\n      // (9.20.0) — served, never written into the record (see\n      // engine/handlers/servedSubflowResults.ts). Plain: the records as they are.\n      snapshot.subflowResults = servedSubflowResults(sfResults, options?.redact === true);\n    }\n\n    const recorderSnapshots = this.collectRecorderSnapshots();\n    if (recorderSnapshots.length > 0) {\n      snapshot.recorders = recorderSnapshots;\n    }\n\n    // RFC-001 Block 9: the deferred-observer accounting surface. Present\n    // ONLY when a deferred observer was attached on this executor —\n    // zero-cost discipline for everyone else.\n    if (this.deferredTier) {\n      snapshot.observerStats = this.deferredTier.getStats();\n    }\n\n    return snapshot;\n  }\n\n  /**\n   * Collect `toSnapshot()` bundles from every attached recorder — ONE entry\n   * per recorder id, across all channels and both delivery tiers.\n   *\n   * The dedupe is load-bearing, not tidiness. A recorder that implements a\n   * shared-name hook (`onError` / `onPause` / `onResume` — declared on BOTH\n   * the scope and flow interfaces) is legitimately registered on BOTH inline\n   * lists by `attachCombinedRecorder`, and that is by design: each channel\n   * calls the hook with its own payload variant. `MetricRecorder.onPause` is\n   * the everyday case. Walking the lists without a shared `seen` set turned\n   * that into a DUPLICATED snapshot entry (same id twice), which breaks every\n   * consumer that indexes `snapshot.recorders` by id.\n   *\n   * Ordering is scope list → flow list → deferred tier, and the FIRST bundle\n   * for an id wins. A recorder with no `toSnapshot` never claims an id, so it\n   * cannot shadow a same-id recorder that does have one.\n   *\n   * The row is REBUILT field by field by the one copier (`recorder/snapshot.ts\n   * · copyBundle`, shared with `CompositeRecorder`) rather than spread, so a\n   * recorder cannot smuggle an `id` of its own choosing into the snapshot (the\n   * id is the executor's, and consumers index by it).\n   */\n  private collectRecorderSnapshots(): RecorderSnapshot[] {\n    const out: RecorderSnapshot[] = [];\n    const seen = new Set<string>();\n    const collect = (r: ScopeRecorder | FlowRecorder): void => {\n      if (!r.toSnapshot || seen.has(r.id)) return;\n      seen.add(r.id);\n      out.push(copyBundle(r.id, r.toSnapshot()));\n    };\n    for (const r of this.scopeRecorders) collect(r);\n    for (const r of this.flowRecorders) collect(r);\n    if (this.deferredTier) {\n      for (const r of this.deferredTier.scopeListRecorders()) collect(r);\n      for (const r of this.deferredTier.flowListRecorders()) collect(r);\n    }\n    return out;\n  }\n\n  /** @internal */\n  getRuntime() {\n    return this.traverser.getRuntime();\n  }\n\n  /** @internal */\n  setRootObject(path: string[], key: string, value: unknown): void {\n    this.traverser.setRootObject(path, key, value);\n  }\n\n  /** @internal */\n  getBranchIds() {\n    return this.traverser.getBranchIds();\n  }\n\n  /** @internal */\n  getRuntimeRoot(): StageNode {\n    return this.traverser.getRuntimeRoot();\n  }\n\n  /** @internal */\n  getRuntimeStructure(): SerializedPipelineStructure | undefined {\n    return this.traverser.getRuntimeStructure();\n  }\n\n  /** @internal */\n  getSubflowResults(): Map<string, SubflowResult> {\n    return this.traverser.getSubflowResults();\n  }\n\n  /**\n   * Returns the subflow manifest from an attached ManifestFlowRecorder.\n   * Returns empty array if no ManifestFlowRecorder is attached.\n   */\n  getSubflowManifest(): ManifestEntry[] {\n    const recorder = this.flowRecorders.find((r) => r instanceof ManifestFlowRecorder) as\n      | ManifestFlowRecorder\n      | undefined;\n    return recorder?.getManifest() ?? [];\n  }\n\n  /**\n   * Returns the full spec for a dynamically-registered subflow.\n   * Requires an attached ManifestFlowRecorder that observed the registration.\n   */\n  getSubflowSpec(subflowId: string): unknown | undefined {\n    const recorder = this.flowRecorders.find((r) => r instanceof ManifestFlowRecorder) as\n      | ManifestFlowRecorder\n      | undefined;\n    return recorder?.getSpec(subflowId);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FlowChartExecutor.js","sourceRoot":"","sources":["../../../../src/lib/runner/FlowChartExecutor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * FlowChartExecutor — Public API for executing a compiled FlowChart.\n *\n * Wraps FlowchartTraverser. Build a chart with flowChart() and pass the result here:\n *\n *   const chart = flowChart('entry', entryFn).addFunction('process', processFn).build();\n *\n *   // No-options form (uses auto-detected TypedScope factory from the chart):\n *   const executor = new FlowChartExecutor(chart);\n *\n *   // Options-object form (preferred when you need to customize behavior):\n *   const executor = new FlowChartExecutor(chart, { scopeFactory: myFactory });\n *\n *   // 2-param form (accepts a ScopeFactory directly, for backward compatibility):\n *   const executor = new FlowChartExecutor(chart, myFactory);\n *\n *\n * The executor composes four modules, one job each (F9): `attach.ts` (who\n * observes a run), `resume.ts` (plan and announce a re-entry), `checkpoint.ts`\n * (the pause checkpoint), `snapshot.ts` (what `getSnapshot()` serves). What\n * stays here is the per-run state and the run lifecycle that threads it.\n *   const result = await executor.run({ input: data, env: { traceId: 'req-123' } });\n */\n\nimport type { FlowChart } from '../builder/types.js';\nimport { detachAndForget as _detachAndForget, detachAndJoinLater as _detachAndJoinLater } from '../detach/spawn.js';\nimport type { ResumeEntry } from '../engine/handlers/ResumeEntry.js';\nimport type { CombinedNarrativeRecorderOptions } from '../engine/narrative/CombinedNarrativeRecorder.js';\nimport type { CombinedNarrativeEntry } from '../engine/narrative/narrativeTypes.js';\nimport type { ManifestEntry } from '../engine/narrative/recorders/ManifestFlowRecorder.js';\nimport { ManifestFlowRecorder } from '../engine/narrative/recorders/ManifestFlowRecorder.js';\nimport type { FlowRecorder } from '../engine/narrative/types.js';\nimport { FlowchartTraverser } from '../engine/traversal/FlowchartTraverser.js';\nimport {\n  type ExecutorResult,\n  type PausedResult,\n  type RunOptions,\n  type ScopeFactory,\n  type SerializedPipelineStructure,\n  type StageNode,\n  type SubflowResult,\n  defaultLogger,\n} from '../engine/types.js';\nimport { RedactionRule } from '../memory/redaction.js';\nimport { runPolicy } from '../memory/runPolicy.js';\nimport type { CommitValuesMode, ReadTrackingMode, WriteTrackingMode } from '../memory/types.js';\nimport type { FlowchartCheckpoint } from '../pause/types.js';\nimport { isPauseSignal } from '../pause/types.js';\nimport type { CombinedRecorder } from '../recorder/CombinedRecorder.js';\nimport type { EmitRecorder } from '../recorder/EmitRecorder.js';\nimport type { RedactionPolicy, RedactionReport, ScopeRecorder } from '../scope/types.js';\nimport { RunObservers } from './attach.js';\nimport { buildPauseCheckpoint } from './checkpoint.js';\nimport type { AttachRecorderOptions, ObserverDrainResult } from './DeferredObserverTier.js';\nimport { type RuntimeSnapshot, ExecutionRuntime } from './ExecutionRuntime.js';\nimport { type ExecutorArgs, type FlowChartExecutorOptions, resolveExecutorArgs } from './options.js';\nimport { announceResume, planResume, seedCounters } from './resume.js';\nimport { generateRunId } from './runId.js';\nimport { servedSnapshot } from './snapshot.js';\nimport { validateInput } from './validateInput.js';\n\nexport class FlowChartExecutor<TOut = any, TScope = any> {\n  private traverser: FlowchartTraverser<TOut, TScope>;\n  /** Shared execution counter and per-stage visit counts (loopIteration) — shared BY\n   *  REFERENCE with every traverser of the run; survive pause/resume, reset on run(). */\n  private _executionCounter = { value: 0 };\n  private _visitCounts = new Map<string, number>();\n  /** Fresh per run() and per resume() — stamped on every TraversalContext (`runId.ts`). */\n  private _currentRunId = '';\n  /** Who observes the run — narrative, inline lists, deferred tier (`attach.ts`). */\n  private readonly observers = new RunObservers();\n  private redactionPolicy: RedactionPolicy | undefined;\n  /** The run's ONE redaction rule (`memory/redaction.ts`), built fresh per leg. */\n  private redactionRule = new RedactionRule();\n  private lastCheckpoint: FlowchartCheckpoint | undefined;\n  /**\n   * `true` once run() (or a resume) executed here. `resume()` branches on it:\n   * true → reuse the runtime (execution tree, recorders, narrative accumulate);\n   * false → seed a fresh runtime from `checkpoint.sharedState` (cross-executor\n   * resume). See `test/lib/pause/cross-executor-resume.test.ts`.\n   */\n  private _hasRunBefore = false;\n  /**\n   * Re-entrancy guard: run()/resume() mutate per-run state (traverser, runId,\n   * counters, checkpoint, recorders) — one executor = one in-flight execution.\n   * See docs/guides/execution-model.md.\n   */\n  private _isExecuting = false;\n\n  private readonly flowChartArgs: ExecutorArgs<TOut, TScope>;\n\n  /**\n   * Create a FlowChartExecutor.\n   *\n   * **Options object form** (preferred):\n   * ```typescript\n   * new FlowChartExecutor(chart, { scopeFactory, defaultValuesForContext })\n   * ```\n   *\n   * **2-param form** (also supported):\n   * ```typescript\n   * new FlowChartExecutor(chart, scopeFactory)\n   * ```\n   *\n   * @param flowChart - The compiled FlowChart returned by `flowChart(...).build()`\n   * @param factoryOrOptions - A `ScopeFactory<TScope>` OR a `FlowChartExecutorOptions<TScope>` options object.\n   */\n  constructor(\n    flowChart: FlowChart<TOut, TScope>,\n    factoryOrOptions?: ScopeFactory<TScope> | FlowChartExecutorOptions<TScope>,\n  ) {\n    this.flowChartArgs = resolveExecutorArgs(flowChart, factoryOrOptions);\n    this.traverser = this.createTraverser();\n  }\n\n  private createTraverser(\n    signal?: AbortSignal,\n    readOnlyContextOverride?: unknown,\n    env?: import('../engine/types.js').ExecutionEnv,\n    maxDepth?: number,\n    maxIterations?: number,\n    overrides?: {\n      initialContext?: unknown;\n      preserveRecorders?: boolean;\n      existingRuntime?: InstanceType<typeof ExecutionRuntime>;\n      /** The resume's one-shot re-entry (`resume.ts`); the traverser still walks the REAL chart. */\n      resume?: ResumeEntry<TOut, TScope>;\n    },\n  ): FlowchartTraverser<TOut, TScope> {\n    const args = this.flowChartArgs;\n    const fc = args.flowChart;\n    const narrativeFlag = this.observers.startLeg(fc.enableNarrative ?? false, overrides?.preserveRecorders === true);\n\n    this.redactionRule = new RedactionRule(this.redactionPolicy);\n    // ONE factory: the base factory, then every scope modifier (recorders,\n    // deferred tap, redaction) in a flat pass — see `RunObservers`.\n    const scopeFactory = this.observers.composeScopeFactory(\n      args.scopeFactory,\n      this.redactionPolicy,\n      this.redactionRule.markedKeys(),\n    );\n\n    // The first stage this traversal runs: the resume's entry, else the chart root.\n    const effectiveRoot = overrides?.resume?.start ?? fc.root;\n    const effectiveInitialContext = overrides?.initialContext ?? args.initialContext;\n\n    // The run's policy (F5): the dials, the rule (installed even without a\n    // policy — per-call `setValue(k, v, true)` marks live on it) and the mirror\n    // flag (a redacted heap, kept only under a policy), ONE frozen object per\n    // leg that every frame of the run holds by reference.\n    const policy = runPolicy(args.dials, this.redactionRule, this.redactionPolicy !== undefined);\n\n    let runtime: ExecutionRuntime;\n    if (overrides?.existingRuntime) {\n      // Same-executor resume: the tree continues from the leaf; getSnapshot() keeps the full tree.\n      runtime = overrides.existingRuntime;\n      runtime.preserveSnapshotRoot();\n      let leaf = runtime.rootStageContext;\n      while (leaf.next) leaf = leaf.next;\n      runtime.rootStageContext = leaf.createNext('', effectiveRoot.name, effectiveRoot.id);\n      runtime.usePolicy(policy);\n    } else {\n      runtime = new ExecutionRuntime(\n        effectiveRoot.name,\n        effectiveRoot.id,\n        args.defaultValuesForContext,\n        effectiveInitialContext,\n        policy,\n      );\n    }\n\n    return new FlowchartTraverser<TOut, TScope>({\n      // Always the REAL chart; a resume only moves where the traversal STARTS, once.\n      root: fc.root,\n      ...(overrides?.resume?.start && { entry: overrides.resume.start }),\n      ...(overrides?.resume?.startPendingPauses && { pendingPauses: overrides.resume.startPendingPauses }),\n      ...(overrides?.resume && { resume: overrides.resume }),\n      stageMap: fc.stageMap,\n      scopeFactory,\n      executionRuntime: runtime,\n      readOnlyContext: readOnlyContextOverride ?? args.readOnlyContext,\n      throttlingErrorChecker: args.throttlingErrorChecker,\n      streamHandlers: args.streamHandlers,\n      scopeProtectionMode: args.scopeProtectionMode,\n      subflows: fc.subflows,\n      narrativeEnabled: narrativeFlag,\n      buildTimeStructure: fc.buildTimeStructure,\n      logger: fc.logger ?? defaultLogger,\n      signal,\n      executionEnv: env,\n      flowRecorders: this.observers.flowRecordersList(),\n      executionCounter: this._executionCounter,\n      visitCounts: this._visitCounts,\n      runId: this._currentRunId,\n      ...(maxDepth !== undefined && { maxDepth }),\n      ...(maxIterations !== undefined && { maxIterations }),\n    });\n  }\n\n  enableNarrative(options?: CombinedNarrativeRecorderOptions): void {\n    this.observers.enableNarrative(options);\n  }\n\n  /**\n   * Set a declarative redaction policy that applies to all stages.\n   * Must be called before run().\n   */\n  setRedactionPolicy(policy: RedactionPolicy): void {\n    this.redactionPolicy = policy;\n    this.redactionRule = new RedactionRule(policy);\n  }\n\n  /** The `readTracking` dial (see {@link FlowChartExecutorOptions.readTracking}). Call before run(). */\n  setReadTracking(mode: ReadTrackingMode): void {\n    this.flowChartArgs.dials = { ...this.flowChartArgs.dials, readTracking: mode };\n  }\n\n  /** The `writeTracking` dial (see {@link FlowChartExecutorOptions.writeTracking}). Call before run(). */\n  setWriteTracking(mode: WriteTrackingMode): void {\n    this.flowChartArgs.dials = { ...this.flowChartArgs.dials, writeTracking: mode };\n  }\n\n  /** The `commitValues` dial (see {@link FlowChartExecutorOptions.commitValues}). Call before run(). */\n  setCommitValues(mode: CommitValuesMode): void {\n    this.flowChartArgs.dials = { ...this.flowChartArgs.dials, commitValues: mode };\n  }\n\n  /**\n   * Returns a compliance-friendly report of all redaction activity from the\n   * most recent run. Never includes actual values.\n   */\n  getRedactionReport(): RedactionReport {\n    return this.redactionRule.report();\n  }\n\n  // ─── Pause/Resume ───\n\n  /**\n   * Returns the checkpoint from the most recent paused execution, or `undefined`\n   * if the last run completed without pausing.\n   *\n   * JSON-serializable (store it in Redis, Postgres, localStorage…) and fully\n   * DETACHED from engine state (`checkpoint.ts`): mutating or persisting it\n   * cannot affect the executor, nor a later resume a checkpoint you stored.\n   *\n   * @example\n   * ```typescript\n   * const result = await executor.run({ input });\n   * if (executor.isPaused()) {\n   *   const checkpoint = executor.getCheckpoint()!;\n   *   await redis.set(`session:${id}`, JSON.stringify(checkpoint));\n   * }\n   * ```\n   */\n  getCheckpoint(): FlowchartCheckpoint | undefined {\n    return this.lastCheckpoint;\n  }\n\n  /** Returns `true` if the most recent run() was paused (checkpoint available). */\n  isPaused(): boolean {\n    return this.lastCheckpoint !== undefined;\n  }\n\n  /**\n   * Number of commits in the run's commit log. O(1) — direct length\n   * read, no snapshot materialization. Use this to stamp commit\n   * indices on observer events (e.g., `BoundaryRecorder` storing\n   * `commitIdxBefore` / `commitIdxAfter` per domain event for\n   * `CommitRangeIndex` queries — see `footprintjs/trace`).\n   *\n   * Returns 0 before any run; after, returns the cumulative commit\n   * count across the executor's lifetime (including resumes).\n   * Always equals `getSnapshot().commitLog.length` (the log is the\n   * `EventLog`'s `executionHistory`; the snapshot serves a frozen copy).\n   */\n  getCommitCount(): number {\n    const runtime = this.traverser.getRuntime() as InstanceType<typeof ExecutionRuntime> | undefined;\n    return runtime?.executionHistory.length ?? 0;\n  }\n\n  /**\n   * Resume a paused flowchart from a checkpoint.\n   *\n   * Restores the scope state, runs the paused stage's `resumeFn` with the input\n   * (an `interrupt()` pause re-runs the stage with the answer), then continues\n   * with whatever ran after that stage on the run — its `next`, or its\n   * dispatcher's continuation, at every level of the pause path. Parallel\n   * siblings that paused together (`checkpoint.pendingPauses`) are asked in\n   * turn; the join runs after the last answer. See `ResumeEntry`.\n   *\n   * The checkpoint comes from `getCheckpoint()` or from storage. On the SAME\n   * executor, narrative/recorder state accumulates across the pause; on a\n   * FRESH executor it starts empty. A fresh `runId` either way.\n   *\n   * @example\n   * ```typescript\n   * // Process A — after a pause, persist the checkpoint:\n   * const checkpoint = executor.getCheckpoint()!;\n   * await redis.set(`session:${id}`, JSON.stringify(checkpoint));\n   *\n   * // Process B (possibly different server, same chart) — restore and resume:\n   * const restored = JSON.parse(await redis.get(`session:${id}`));\n   * const executor = new FlowChartExecutor(chart);\n   * const result = await executor.resume(restored, { approved: true });\n   * ```\n   */\n  async resume(\n    checkpoint: FlowchartCheckpoint,\n    resumeInput?: unknown,\n    options?: Pick<RunOptions, 'signal' | 'env' | 'maxDepth' | 'maxIterations'>,\n  ): Promise<ExecutorResult> {\n    this.assertIdle('resume');\n    // Every refusal happens in the plan — before any state below is touched,\n    // so a rejected checkpoint leaves the executor (and its checkpoint) as it was.\n    const plan = planResume(this.flowChartArgs.flowChart, checkpoint, resumeInput);\n    // MUST precede the counter read in `announceResume` and the traverser,\n    // which takes both counters BY REFERENCE.\n    seedCounters(plan.checkpoint, this._executionCounter, this._visitCounts);\n    this.lastCheckpoint = undefined;\n\n    // Same executor: reuse the runtime. Fresh executor: seed a NEW one from\n    // `checkpoint.sharedState`. Either way a NEW runId (a distinct logical run).\n    const existingRuntime = this._hasRunBefore\n      ? (this.traverser.getRuntime() as InstanceType<typeof ExecutionRuntime>)\n      : undefined;\n    this._hasRunBefore = true; // any path that resumes counts as a run\n    this._currentRunId = generateRunId();\n\n    this.traverser = this.createTraverser(\n      options?.signal,\n      undefined,\n      options?.env,\n      options?.maxDepth,\n      options?.maxIterations,\n      {\n        // Clone-in: `initialContext` seeds the fresh SharedMemory with a\n        // top-level-only merge — nested objects would alias the caller's checkpoint.\n        initialContext: structuredClone(plan.checkpoint.sharedState),\n        preserveRecorders: true,\n        ...(existingRuntime ? { existingRuntime } : {}),\n        resume: plan.entry,\n      },\n    );\n    // Before the traversal on purpose: `onResume` precedes `onRunStart`.\n    announceResume(plan, resumeInput, {\n      runId: this._currentRunId,\n      executionCount: this._executionCounter.value,\n      observers: this.observers,\n    });\n\n    // Set AFTER all sync validation/lookup throws above (nothing can leak the\n    // flag); no await between the top-of-method check and here, so race-free.\n    this._isExecuting = true;\n    try {\n      const result = await this.traverser.execute();\n      // Terminal flush (RFC-001 Block 8) — same boundary contract as run().\n      this.observers.deferredTier?.terminalFlush();\n      return result;\n    } catch (error: unknown) {\n      return this.pausedOrThrow(error);\n    } finally {\n      this._isExecuting = false;\n    }\n  }\n\n  /**\n   * The settle of a leg that threw: flush the deferred tier (the OUTERMOST\n   * handler — a pause re-throws through subflow traversers without exit\n   * events, so per-traverser hooks would miss it), then turn a pause into a\n   * detached checkpoint (`checkpoint.ts`) and a `PausedResult`; anything else\n   * is rethrown.\n   */\n  private pausedOrThrow(error: unknown): PausedResult {\n    this.observers.deferredTier?.terminalFlush();\n    if (isPauseSignal(error)) {\n      this.lastCheckpoint = buildPauseCheckpoint(error, this.traverser, {\n        runId: this._currentRunId,\n        executionCount: this._executionCounter.value,\n        visitCounts: this._visitCounts,\n      });\n      return { paused: true, checkpoint: this.lastCheckpoint } satisfies PausedResult;\n    }\n    throw error;\n  }\n\n  /** The re-entrancy guard: one executor = one in-flight execution. */\n  private assertIdle(method: 'run' | 'resume'): void {\n    if (this._isExecuting) {\n      throw new Error(\n        `FlowChartExecutor: ${method}() called while another run()/resume() is in flight on this ` +\n          'executor. An executor holds per-run state (runId, recorders, checkpoint) — create ' +\n          'one executor per concurrent run. See docs/guides/execution-model.md.',\n      );\n    }\n  }\n\n  // ─── Recorders (the register lives in `attach.ts`) ───\n\n  /**\n   * Attach a ScopeRecorder to observe data operations (reads, writes, commits)\n   * on every stage scope. Call before run(). **Idempotent by `id`** (replaced,\n   * never duplicated). `{ delivery: 'deferred' }` moves it off the hot path —\n   * delivered at the next microtask checkpoint; re-attaching an id on the\n   * other tier SWAPS tiers (`docs/guides/observers-deferred.md`).\n   *\n   * @example\n   * ```typescript\n   * executor.attachScopeRecorder(new MetricRecorder());\n   * executor.attachScopeRecorder(new MetricRecorder('my-metrics')); // replaces same id\n   * ```\n   */\n  attachScopeRecorder(recorder: ScopeRecorder, options?: AttachRecorderOptions): void {\n    this.observers.attachScope(recorder, options);\n  }\n\n  /** Detach all scope Recorders with the given ID — both delivery tiers. */\n  detachScopeRecorder(id: string): void {\n    this.observers.detachScope(id);\n  }\n\n  /** Returns a defensive copy of attached scope Recorders (both tiers). */\n  getScopeRecorders(): ScopeRecorder[] {\n    return this.observers.scopeList();\n  }\n\n  /**\n   * Attach a FlowRecorder to observe control flow events. Automatically\n   * enables narrative. Must be called before run(). Idempotent by `id`;\n   * `{ delivery: 'deferred' }` as for `attachScopeRecorder`.\n   */\n  attachFlowRecorder(recorder: FlowRecorder, options?: AttachRecorderOptions): void {\n    this.observers.attachFlow(recorder, options);\n  }\n\n  /** Detach all FlowRecorders with the given ID — both delivery tiers. */\n  detachFlowRecorder(id: string): void {\n    this.observers.detachFlow(id);\n  }\n\n  /** Returns a defensive copy of attached FlowRecorders (both tiers). */\n  getFlowRecorders(): FlowRecorder[] {\n    return this.observers.flowList();\n  }\n\n  /**\n   * Attach a recorder to every channel (scope, flow, emit) it has OWN `on*`\n   * methods for — preferred over single-channel calls, where forgetting one\n   * silently loses events. Idempotent by `id` across all channels; a flow\n   * method enables the narrative; `delivery` comes from the options or the\n   * recorder's own field.\n   *\n   * @example\n   * ```typescript\n   * const audit: CombinedRecorder = {\n   *   id: 'audit',\n   *   onWrite: (e) => log('scope write', e.key),\n   *   onDecision: (e) => log('routed to', e.chosen),\n   * };\n   * executor.attachCombinedRecorder(audit);\n   * ```\n   */\n  attachCombinedRecorder(recorder: CombinedRecorder, options?: AttachRecorderOptions): void {\n    this.observers.attachCombined(recorder, options);\n  }\n\n  /** Detach a combined recorder from every channel it was attached to (safe if never attached). */\n  detachCombinedRecorder(id: string): void {\n    this.detachScopeRecorder(id);\n    this.detachFlowRecorder(id);\n  }\n\n  /**\n   * Attach an `EmitRecorder` for `scope.$emit(name, payload)` events. It rides\n   * the scope list, so `onEmit` fires exactly once per event. Idempotent by `id`.\n   *\n   * @example\n   * ```typescript\n   * executor.attachEmitRecorder({\n   *   id: 'token-meter',\n   *   onEmit: (e) => {\n   *     if (e.name === 'agentfootprint.llm.tokens') trackTokens(e.payload);\n   *   },\n   * });\n   * ```\n   */\n  attachEmitRecorder(recorder: EmitRecorder, options?: AttachRecorderOptions): void {\n    this.attachScopeRecorder(recorder as ScopeRecorder, options);\n  }\n\n  /** Detach an `EmitRecorder` by id. Safe to call if never attached. */\n  detachEmitRecorder(id: string): void {\n    this.detachScopeRecorder(id);\n  }\n\n  /** Returns a defensive copy of attached recorders (both tiers) that implement `onEmit`. */\n  getEmitRecorders(): EmitRecorder[] {\n    return this.getScopeRecorders().filter(\n      (r): r is EmitRecorder => typeof (r as { onEmit?: unknown }).onEmit === 'function',\n    );\n  }\n\n  // ─── Detach (T4) ───\n  // Bare-executor entry points for fire-and-forget child charts. From inside a\n  // stage use `scope.$detachAndJoinLater(...)` / `scope.$detachAndForget(...)`,\n  // which mint refIds from the calling stage; these use `__executor__`.\n\n  /**\n   * Detach a child flowchart on the given driver and return a `DetachHandle`\n   * the caller can `wait()` on (Promise) or read `.status` from (sync). The\n   * driver is REQUIRED — there is no library default.\n   *\n   * @example\n   * ```typescript\n   * import { microtaskBatchDriver } from 'footprintjs/detach';\n   *\n   * const exec = new FlowChartExecutor(parentChart);\n   * const handle = exec.detachAndJoinLater(microtaskBatchDriver, telemetryChart, { event: 'x' });\n   * await handle.wait(); // optional\n   * ```\n   */\n  detachAndJoinLater(\n    driver: import('../detach/types.js').DetachDriver,\n    child: import('../builder/types.js').FlowChart,\n    input?: unknown,\n  ): import('../detach/types.js').DetachHandle {\n    return _detachAndJoinLater(driver, child, input, '__executor__');\n  }\n\n  /**\n   * Detach a child flowchart on the given driver and DISCARD the handle — for\n   * fire-and-forget side effects. A child's error lands on the discarded handle;\n   * for observable detach prefer `detachAndJoinLater` + `.wait().catch()`.\n   */\n  detachAndForget(\n    driver: import('../detach/types.js').DetachDriver,\n    child: import('../builder/types.js').FlowChart,\n    input?: unknown,\n  ): void {\n    _detachAndForget(driver, child, input, '__executor__');\n  }\n\n  /**\n   * Structured narrative entries (type, text, depth) — the one public narrative\n   * API; `.map(e => e.text)` for a flat `string[]`.\n   */\n  getNarrativeEntries(): CombinedNarrativeEntry[] {\n    if (this.observers.combinedRecorder) {\n      return this.observers.combinedRecorder.getEntries();\n    }\n    const flowSentences = this.traverser.getNarrative();\n    return flowSentences.map((text) => ({ type: 'stage' as const, text, depth: 0 }));\n  }\n\n  /**\n   * Execute the chart. Resolves when the run finishes — or pauses, if a\n   * pausable stage returned data (check `isPaused()` afterward).\n   *\n   * @param options `{ input, env }` — `input` is the frozen business input\n   *   (read in a stage via `scope.$getArgs()`); `env` is infrastructure context\n   *   like `{ signal, timeoutMs, traceId }` (read via `scope.$getEnv()`).\n   *\n   * After it resolves, read results off the executor:\n   * - `getSnapshot()` — full state, commit log, execution tree.\n   * - `getNarrativeEntries()` — the plain-English trace (call `enableNarrative()`\n   *   or attach a `narrative()` recorder first).\n   * - `isPaused()` — true if a stage paused; then use `getCheckpoint()` / `resume()`.\n   *\n   * One run at a time per executor — it holds per-run state (runId, recorders,\n   * checkpoint). Create one executor per concurrent run.\n   */\n  async run(options?: RunOptions): Promise<ExecutorResult> {\n    // A failed entry leaves no side effects: the guard FIRST (the in-flight\n    // run stays untouched), validation before the timeout timer exists.\n    this.assertIdle('run');\n    let validatedInput = options?.input;\n    if (validatedInput && this.flowChartArgs.flowChart.inputSchema) {\n      validatedInput = validateInput(this.flowChartArgs.flowChart.inputSchema, validatedInput);\n    }\n\n    let signal = options?.signal;\n    let timeoutId: ReturnType<typeof setTimeout> | undefined;\n    if (options?.timeoutMs && !signal) {\n      const controller = new AbortController();\n      signal = controller.signal;\n      timeoutId = setTimeout(\n        () => controller.abort(new Error(`Execution timed out after ${options.timeoutMs}ms`)),\n        options.timeoutMs,\n      );\n    }\n\n    this.observers.clearForRun(); // no cross-run accumulation\n    this.lastCheckpoint = undefined;\n    this._executionCounter = { value: 0 };\n    this._visitCounts = new Map();\n    this._currentRunId = generateRunId();\n    this._hasRunBefore = true; // a later resume() reuses this runtime\n    this.traverser = this.createTraverser(\n      signal,\n      validatedInput,\n      options?.env,\n      options?.maxDepth,\n      options?.maxIterations,\n    );\n    // After every sync throw, with no await since the guard: race-free.\n    this._isExecuting = true;\n    try {\n      const result = await this.traverser.execute();\n      // Terminal flush (RFC-001 Block 8): \"one beat behind\" never becomes \"lost at exit\".\n      this.observers.deferredTier?.terminalFlush();\n      return result;\n    } catch (error: unknown) {\n      return this.pausedOrThrow(error);\n    } finally {\n      this._isExecuting = false;\n      if (timeoutId !== undefined) clearTimeout(timeoutId);\n    }\n  }\n\n  /**\n   * Flush the deferred-observer backlog, then await async listener completions\n   * under a deadline — call before a serverless process freezes or exits.\n   * Zeros when no deferred observer was attached; `pending > 0` reports what\n   * was still outstanding at the deadline.\n   */\n  drainObservers(opts?: { timeoutMs?: number }): Promise<ObserverDrainResult> {\n    const tier = this.observers.deferredTier;\n    if (!tier) return Promise.resolve({ done: 0, failed: 0, pending: 0 });\n    return tier.drain(opts);\n  }\n\n  // ─── Introspection ───\n\n  /**\n   * Returns the runtime snapshot.\n   *\n   * @param options.redact  `true` serves `sharedState` (and each subflow's\n   *   `globalContext`) from the redacted mirror — the safe view to export. A\n   *   no-op without a redaction policy. The commit log is redacted at write\n   *   time regardless. Default `false`.\n   *\n   * **Treat `sharedState` as READ-ONLY.** In production it is a live view of\n   * engine memory; in dev mode a deep-frozen clone, so a mutation throws.\n   */\n  getSnapshot(options?: { redact?: boolean }): RuntimeSnapshot {\n    return servedSnapshot(this.traverser, this.observers, options);\n  }\n\n  /** @internal */\n  getRuntime() {\n    return this.traverser.getRuntime();\n  }\n\n  /** @internal */\n  setRootObject(path: string[], key: string, value: unknown): void {\n    this.traverser.setRootObject(path, key, value);\n  }\n\n  /** @internal */\n  getBranchIds() {\n    return this.traverser.getBranchIds();\n  }\n\n  /** @internal */\n  getRuntimeRoot(): StageNode {\n    return this.traverser.getRuntimeRoot();\n  }\n\n  /** @internal */\n  getRuntimeStructure(): SerializedPipelineStructure | undefined {\n    return this.traverser.getRuntimeStructure();\n  }\n\n  /** @internal */\n  getSubflowResults(): Map<string, SubflowResult> {\n    return this.traverser.getSubflowResults();\n  }\n\n  /**\n   * Returns the subflow manifest from an attached ManifestFlowRecorder.\n   * Returns empty array if no ManifestFlowRecorder is attached.\n   */\n  getSubflowManifest(): ManifestEntry[] {\n    const recorder = this.observers.flowRecorders.find((r) => r instanceof ManifestFlowRecorder) as\n      | ManifestFlowRecorder\n      | undefined;\n    return recorder?.getManifest() ?? [];\n  }\n\n  /**\n   * Returns the full spec for a dynamically-registered subflow.\n   * Requires an attached ManifestFlowRecorder that observed the registration.\n   */\n  getSubflowSpec(subflowId: string): unknown | undefined {\n    const recorder = this.observers.flowRecorders.find((r) => r instanceof ManifestFlowRecorder) as\n      | ManifestFlowRecorder\n      | undefined;\n    return recorder?.getSpec(subflowId);\n  }\n}\n"]}