footprintjs 9.5.0 → 9.6.0

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

@@ -0,0 +1,366 @@
+/**
+ * runner/DeferredObserverTier.ts — RFC-001 Blocks 6–9: the engine wiring of
+ * the deferred-observer pipeline.
+ *
+ * Pattern:  Thin adapter between the executor's three observer channels and
+ *           the PURE `observer-queue` module. The pure module stays
+ *           engine-free (it imports nothing from the engine — the engine
+ *           imports IT); this tier owns every engine-flavored concern:
+ *             - the `isDevMode()`-gated, deduplicated `CaptureHooks.warn`
+ *               binding (the dev-warn seam, RFC-001 §"Resolution");
+ *             - routing `DeferredDispatcher.onError` into the existing
+ *               recorder error channel (`onError` on sibling observers);
+ *             - the capture TAPS — synthetic recorders placed on the
+ *               existing inline dispatch lists so the three dispatch sites
+ *               (`ScopeFacade._invokeHook`, `ScopeFacade.emitEvent`,
+ *               `FlowRecorderDispatcher`) need NO per-site tier logic: a
+ *               tap's hook body IS `dispatcher.capture(...)`, and because
+ *               the tap sits in the same loop as inline recorders it sees
+ *               exactly the post-redaction event object inline observers
+ *               see — capture can never observe a pre-redaction value;
+ *             - the terminal flush (Block 8) with honest stranding
+ *               accounting, and the Block 9 stats surface.
+ *
+ * Role:     One instance per `FlowChartExecutor`, created LAZILY on the
+ *           first `delivery: 'deferred'` attach (zero allocation when nobody
+ *           opts in — mirrors the emit fast-path precedent). Holds the ONE
+ *           `DeferredDispatcher` (one merged queue, total order across
+ *           channels) plus the registry of deferred recorders.
+ *
+ * Delivery: a deferred recorder's hooks are invoked through the SAME
+ * `invokeRecorderHook` helper the inline tier uses (RFC-001 §9 mitigation) —
+ * one beat behind, with `envelope.payload` materialized per the capture
+ * policy (`'summary'` default — bounded, reference-free; `'clone'` — full
+ * structural copy, event-shape compatible with inline; `'ref'` — the live
+ * event object, dev-warned).
+ *
+ * Channel filter: a registration remembers which channels would have
+ * reached the recorder inline (scope-list recorders see `scope` + `emit`
+ * envelopes; flow-list recorders see `flow` envelopes) and skips the rest —
+ * same reach as the inline tier, one beat behind.
+ */
+import { DeferredDispatcher, } from '../observer-queue/index.js';
+import { EMIT_RECORDER_EVENT_METHODS, FLOW_RECORDER_EVENT_METHODS, RECORDER_EVENT_METHODS, } from '../recorder/CombinedRecorder.js';
+import { invokeRecorderHook } from '../recorder/invokeHook.js';
+import { isDevMode } from '../scope/detectCircular.js';
+/** Well-known ids of the synthetic capture taps (internal, documented for debugging). */
+export const DEFERRED_SCOPE_TAP_ID = '__deferred-scope-tap__';
+export const DEFERRED_FLOW_TAP_ID = '__deferred-flow-tap__';
+/** Channel reach of the scope-recorder list (scope events + emit events). */
+const SCOPE_LIST_CHANNELS = ['scope', 'emit'];
+/** Channel reach of the flow-recorder list. */
+const FLOW_LIST_CHANNELS = ['flow'];
+/** Map an envelope method onto the scope error-event `operation` vocabulary
+ *  (same mapping `ScopeFacade._invokeHook` uses for inline failures). */
+function operationFor(method) {
+    if (method === 'onRead')
+        return 'read';
+    if (method === 'onCommit')
+        return 'commit';
+    return 'write';
+}
+export class DeferredObserverTier {
+    dispatcher;
+    registrations = new Map();
+    appliedConfig;
+    /** Dedup memory for the dev-warn seam (one warning per unique message). */
+    warnedMessages = new Set();
+    terminalStranded = 0;
+    constructor(options) {
+        this.appliedConfig = {
+            // Attach-surface default is 'clone' (review CRITICAL-2): a recorder
+            // ported with `{ delivery: 'deferred' }` keeps receiving the SAME
+            // event shape as inline (e.key/e.value/e.runtimeStageId all intact).
+            // The module-internal envelope default stays 'summary' for raw-
+            // envelope consumers; 'summary' here is an explicit telemetry choice.
+            capture: options?.capture ?? 'clone',
+            maxQueue: options?.maxQueue,
+            overflow: options?.overflow,
+            sampleEvery: options?.sampleEvery,
+            flushBudgetMs: options?.flushBudgetMs,
+        };
+        this.dispatcher = new DeferredDispatcher({
+            maxQueue: options?.maxQueue,
+            overflow: options?.overflow,
+            sampleEvery: options?.sampleEvery,
+            capturePolicy: options?.capture ?? 'clone',
+            flushBudgetMs: options?.flushBudgetMs,
+            // The dev-warn seam (RFC-001 §"Resolution: the dev-warn seam"): the
+            // pure module invokes `warn` on every 'ref' capture and every 'clone'
+            // degradation; the tier binds it to the central isDevMode() flag and
+            // dedupes by message so a hot loop cannot spam the console.
+            hooks: { warn: (message) => this.devWarnDeduped(message) },
+            // Listener failures (sync throws AND async rejections) route into the
+            // existing recorder error channel — see routeListenerError.
+            onError: (error, ctx) => this.routeListenerError(error, ctx.listenerId, ctx.envelope, ctx.phase),
+        });
+    }
+    // ── Registry ─────────────────────────────────────────────────────────────
+    /**
+     * Register a recorder for deferred delivery on the scope-list channels
+     * (`scope` + `emit`) and/or the flow channel. Idempotent by id — same id
+     * replaces the recorder object; channel lists MERGE across calls (same as
+     * the inline tier, where `attachScopeRecorder(x)` + `attachFlowRecorder(x)`
+     * lands `x` on both lists). Later attaches passing dispatcher-level
+     * options that differ from the first attach's configuration keep the
+     * original config and dev-warn.
+     */
+    register(recorder, lists, options) {
+        this.warnOnConfigConflict(recorder.id, options);
+        const channels = this.registrations.get(recorder.id)?.channels ?? new Set();
+        if (lists.scope)
+            for (const c of SCOPE_LIST_CHANNELS)
+                channels.add(c);
+        if (lists.flow)
+            for (const c of FLOW_LIST_CHANNELS)
+                channels.add(c);
+        this.registrations.set(recorder.id, { recorder, channels });
+        this.dispatcher.addListener(recorder.id, (envelope) => {
+            const registration = this.registrations.get(recorder.id);
+            if (!registration || !registration.channels.has(envelope.channel))
+                return;
+            // SAME invoke helper as the inline tier (RFC-001 §9 mitigation) — a
+            // returned Promise lands in the dispatcher's inflight set.
+            return invokeRecorderHook(recorder, envelope.method, envelope.payload);
+        });
+    }
+    /**
+     * Remove the given channel lists from a registration (mirrors the inline
+     * tier, where `detachScopeRecorder` / `detachFlowRecorder` each clear one
+     * list). When no channels remain, the listener is fully removed.
+     */
+    removeFromLists(id, lists) {
+        const registration = this.registrations.get(id);
+        if (!registration)
+            return;
+        if (lists.scope)
+            for (const c of SCOPE_LIST_CHANNELS)
+                registration.channels.delete(c);
+        if (lists.flow)
+            for (const c of FLOW_LIST_CHANNELS)
+                registration.channels.delete(c);
+        if (registration.channels.size === 0) {
+            this.registrations.delete(id);
+            this.dispatcher.removeListener(id);
+        }
+    }
+    /** True when `id` is registered for deferred delivery (any channel). */
+    has(id) {
+        return this.registrations.has(id);
+    }
+    /** Deferred recorders whose reach includes the scope list (scope+emit). */
+    scopeListRecorders() {
+        return this.byChannel('scope');
+    }
+    /** Deferred recorders whose reach includes the flow channel. */
+    flowListRecorders() {
+        return this.byChannel('flow');
+    }
+    /** Reset deferred recorders before a fresh run (same contract as inline). */
+    clearRecorders() {
+        for (const { recorder } of this.registrations.values()) {
+            recorder.clear?.();
+        }
+    }
+    // ── Capture taps (Block 7) ───────────────────────────────────────────────
+    /**
+     * Build the synthetic scope-channel tap — a `ScopeRecorder` placed on the
+     * normal scope-recorder list whose hooks capture into the queue. Built
+     * fresh per traverser so it reflects the current registrations. Only
+     * methods some deferred recorder actually implements are present (no
+     * wasted captures). Returns `undefined` when nothing is registered for
+     * the scope list.
+     *
+     * Redaction ordering: the tap is invoked from the SAME loops as inline
+     * recorders (`_invokeHook` / `emitEvent`), which receive events AFTER the
+     * redaction decision — so a captured payload can never contain a
+     * pre-redaction value the inline tier would not have seen.
+     */
+    buildScopeTap() {
+        const recorders = this.scopeListRecorders();
+        if (recorders.length === 0)
+            return undefined;
+        const tap = { id: DEFERRED_SCOPE_TAP_ID };
+        for (const method of RECORDER_EVENT_METHODS) {
+            if (!this.anyImplements(recorders, method))
+                continue;
+            tap[method] = (event) => this.captureScopeEvent('scope', method, event);
+        }
+        for (const method of EMIT_RECORDER_EVENT_METHODS) {
+            if (!this.anyImplements(recorders, method))
+                continue;
+            tap[method] = (event) => this.captureScopeEvent('emit', method, event);
+        }
+        return tap;
+    }
+    /**
+     * Build the synthetic flow-channel tap — a `FlowRecorder` appended to the
+     * flow-recorders list handed to the traverser. Same contract as
+     * {@link buildScopeTap}.
+     */
+    buildFlowTap() {
+        const recorders = this.flowListRecorders();
+        if (recorders.length === 0)
+            return undefined;
+        const tap = { id: DEFERRED_FLOW_TAP_ID };
+        for (const method of FLOW_RECORDER_EVENT_METHODS) {
+            if (!this.anyImplements(recorders, method))
+                continue;
+            tap[method] = (event) => this.captureFlowEvent(method, event);
+        }
+        return tap;
+    }
+    /**
+     * Direct capture for executor-synthesized events that bypass the dispatch
+     * sites (e.g. the synthetic `onResume` the executor fires on resume).
+     */
+    capture(channel, method, runtimeStageId, runId, payload) {
+        this.dispatcher.capture({ channel, method, runtimeStageId, runId, payload });
+    }
+    // ── Terminal flush + drain (Block 8) ─────────────────────────────────────
+    /**
+     * Synchronously deliver everything still queued — called by the executor
+     * at the OUTERMOST run boundary (resolve, reject, pause), BEFORE `run()`
+     * returns / rethrows / the checkpoint becomes available. Inspects
+     * `flushSync`'s `remaining` (reviewer N1): `flushSync` already loops
+     * snapshot rounds up to its runaway-cascade cap, so a non-zero remainder
+     * means a pathological self-enqueueing listener — counted in
+     * `observerStats.terminalStranded` and dev-warned, never silent.
+     */
+    terminalFlush() {
+        const { remaining } = this.dispatcher.flushNow();
+        if (remaining > 0) {
+            this.terminalStranded += remaining;
+            if (isDevMode()) {
+                // eslint-disable-next-line no-console
+                console.warn(`[footprintjs] deferred observers: terminal flush hit the runaway-cascade cap with ${remaining} ` +
+                    'event(s) still queued — a listener kept enqueueing during the flush. The stranded count is ' +
+                    'surfaced on snapshot.observerStats.terminalStranded.');
+            }
+        }
+    }
+    /**
+     * Flush the backlog, then settle async listener continuations under a
+     * deadline — the serverless / graceful-shutdown pattern (RFC-001 §11).
+     */
+    drain(opts) {
+        return this.dispatcher.drain(opts);
+    }
+    // ── Stats (Block 9) ──────────────────────────────────────────────────────
+    /** The `snapshot.observerStats` payload — A4 stats + Block 8 stranding. */
+    getStats() {
+        return { ...this.dispatcher.getStats(), terminalStranded: this.terminalStranded };
+    }
+    // ── Internals ────────────────────────────────────────────────────────────
+    byChannel(channel) {
+        const out = [];
+        for (const { recorder, channels } of this.registrations.values()) {
+            if (channels.has(channel))
+                out.push(recorder);
+        }
+        return out;
+    }
+    /** Normal property lookup — invocation parity with the inline tier. */
+    anyImplements(recorders, method) {
+        return recorders.some((r) => typeof r[method] === 'function');
+    }
+    /** Scope/emit events carry their own ids (`runtimeStageId` + `pipelineId`). */
+    captureScopeEvent(channel, method, event) {
+        const e = event;
+        this.dispatcher.capture({
+            channel,
+            method,
+            runtimeStageId: e?.runtimeStageId ?? '',
+            runId: e?.pipelineId ?? '',
+            payload: event,
+        });
+    }
+    /** Flow events carry ids on `traversalContext` (absent on a few events). */
+    captureFlowEvent(method, event) {
+        const ctx = event
+            ?.traversalContext;
+        this.dispatcher.capture({
+            channel: 'flow',
+            method,
+            runtimeStageId: ctx?.runtimeStageId ?? '',
+            runId: ctx?.runId ?? '',
+            payload: event,
+        });
+    }
+    /**
+     * Route a deferred listener failure into the existing recorder error
+     * channel: every OTHER registered observer (deferred siblings first, in
+     * registration order) receives a scope-shaped `onError` event — the same
+     * contract the inline tier honors when a recorder throws mid-dispatch.
+     * The error sink must never become an error source: sink throws are
+     * swallowed (isolation is absolute).
+     */
+    routeListenerError(error, listenerId, envelope, phase) {
+        const hashIdx = envelope.runtimeStageId.lastIndexOf('#');
+        const errorEvent = {
+            stageName: '',
+            stageId: hashIdx >= 0 ? envelope.runtimeStageId.slice(0, hashIdx) : envelope.runtimeStageId,
+            runtimeStageId: envelope.runtimeStageId,
+            pipelineId: envelope.runId,
+            timestamp: Date.now(),
+            error: error instanceof Error ? error : new Error(String(error)),
+            operation: operationFor(envelope.method),
+            channel: 'scope',
+        };
+        for (const [id, { recorder, channels }] of this.registrations) {
+            if (id === listenerId)
+                continue;
+            // Inline-tier parity (review CRITICAL-1): the synthesized event is
+            // scope-typed, so it reaches ONLY recorders registered on the scope
+            // lists — a flow-only recorder never receives scope-channel errors
+            // inline and must not here either.
+            if (!channels.has('scope'))
+                continue;
+            try {
+                invokeRecorderHook(recorder, 'onError', errorEvent);
+            }
+            catch {
+                // Swallow — same rule as DeferredDispatcher.safeOnError.
+            }
+        }
+        if (isDevMode()) {
+            // eslint-disable-next-line no-console
+            console.warn(`[footprintjs] deferred observer '${listenerId}' failed (${phase}) handling ` +
+                `${envelope.channel}.${envelope.method} (seq ${envelope.seq}): ${String(error)}`);
+        }
+    }
+    /** Dispatcher-level options are first-attach-wins; differing later values dev-warn. */
+    warnOnConfigConflict(recorderId, options) {
+        if (!options)
+            return;
+        const conflicts = [];
+        const requested = {
+            capture: options.capture,
+            maxQueue: options.maxQueue,
+            overflow: options.overflow,
+            sampleEvery: options.sampleEvery,
+            flushBudgetMs: options.flushBudgetMs,
+        };
+        for (const key of Object.keys(requested)) {
+            if (requested[key] !== undefined && requested[key] !== this.appliedConfig[key]) {
+                conflicts.push(String(key));
+            }
+        }
+        if (conflicts.length > 0) {
+            this.devWarnDeduped(`[footprintjs] attach '${recorderId}': the executor's deferred-observer queue was already ` +
+                `configured by the first deferred attach — ignoring differing option(s): ${conflicts.join(', ')}. ` +
+                'One executor has ONE merged queue; configure it on the first deferred attach.');
+        }
+    }
+    /** `isDevMode()`-gated, deduplicated warner — the bound warn seam. */
+    devWarnDeduped(message) {
+        if (!isDevMode())
+            return;
+        if (this.warnedMessages.has(message))
+            return;
+        this.warnedMessages.add(message);
+        // eslint-disable-next-line no-console
+        console.warn(message);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DeferredObserverTier.js","sourceRoot":"","sources":["../../../../src/lib/runner/DeferredObserverTier.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * runner/DeferredObserverTier.ts — RFC-001 Blocks 6–9: the engine wiring of\n * the deferred-observer pipeline.\n *\n * Pattern:  Thin adapter between the executor's three observer channels and\n *           the PURE `observer-queue` module. The pure module stays\n *           engine-free (it imports nothing from the engine — the engine\n *           imports IT); this tier owns every engine-flavored concern:\n *             - the `isDevMode()`-gated, deduplicated `CaptureHooks.warn`\n *               binding (the dev-warn seam, RFC-001 §\"Resolution\");\n *             - routing `DeferredDispatcher.onError` into the existing\n *               recorder error channel (`onError` on sibling observers);\n *             - the capture TAPS — synthetic recorders placed on the\n *               existing inline dispatch lists so the three dispatch sites\n *               (`ScopeFacade._invokeHook`, `ScopeFacade.emitEvent`,\n *               `FlowRecorderDispatcher`) need NO per-site tier logic: a\n *               tap's hook body IS `dispatcher.capture(...)`, and because\n *               the tap sits in the same loop as inline recorders it sees\n *               exactly the post-redaction event object inline observers\n *               see — capture can never observe a pre-redaction value;\n *             - the terminal flush (Block 8) with honest stranding\n *               accounting, and the Block 9 stats surface.\n *\n * Role:     One instance per `FlowChartExecutor`, created LAZILY on the\n *           first `delivery: 'deferred'` attach (zero allocation when nobody\n *           opts in — mirrors the emit fast-path precedent). Holds the ONE\n *           `DeferredDispatcher` (one merged queue, total order across\n *           channels) plus the registry of deferred recorders.\n *\n * Delivery: a deferred recorder's hooks are invoked through the SAME\n * `invokeRecorderHook` helper the inline tier uses (RFC-001 §9 mitigation) —\n * one beat behind, with `envelope.payload` materialized per the capture\n * policy (`'summary'` default — bounded, reference-free; `'clone'` — full\n * structural copy, event-shape compatible with inline; `'ref'` — the live\n * event object, dev-warned).\n *\n * Channel filter: a registration remembers which channels would have\n * reached the recorder inline (scope-list recorders see `scope` + `emit`\n * envelopes; flow-list recorders see `flow` envelopes) and skips the rest —\n * same reach as the inline tier, one beat behind.\n */\n\nimport type { FlowRecorder } from '../engine/narrative/types.js';\nimport {\n  type CaptureChannel,\n  type CaptureEnvelope,\n  type CapturePolicy,\n  type DispatcherStats,\n  type DrainResult,\n  type OverflowPolicy,\n  DeferredDispatcher,\n} from '../observer-queue/index.js';\nimport {\n  EMIT_RECORDER_EVENT_METHODS,\n  FLOW_RECORDER_EVENT_METHODS,\n  RECORDER_EVENT_METHODS,\n} from '../recorder/CombinedRecorder.js';\nimport { invokeRecorderHook } from '../recorder/invokeHook.js';\nimport { isDevMode } from '../scope/detectCircular.js';\nimport type { ScopeRecorder } from '../scope/types.js';\n\n/** Delivery tier for an attached observer (RFC-001). */\nexport type ObserverDelivery = 'inline' | 'deferred';\n\n/**\n * Options bag accepted by every `attach*Recorder` call.\n *\n * `delivery: 'deferred'` opts the recorder into the bounded capture queue\n * (\"one beat behind\"); absent / `'inline'` keeps the historical synchronous\n * call — byte-identical to the pre-RFC path.\n *\n * The remaining fields configure the executor's ONE shared dispatcher and\n * are applied when the FIRST deferred attach creates it; later attaches\n * passing different values get a dev-mode warning and keep the original\n * configuration (one queue per executor — per-recorder queues would break\n * the total cross-channel order).\n */\nexport interface AttachRecorderOptions {\n  /** `'deferred'` = capture → queue → next-checkpoint delivery. Default `'inline'`. */\n  readonly delivery?: ObserverDelivery;\n  /**\n   * Payload materialization at capture time. Default `'clone'` — your\n   * recorder's hooks receive the SAME event shape as inline delivery\n   * (`structuredClone`d; `e.key`/`e.value`/`e.runtimeStageId` all work\n   * unchanged), so `{ delivery: 'deferred' }` is a drop-in port.\n   * `'summary'` — a bounded type/size/preview digest (`PayloadSummary`)\n   * instead of the event shape: cheaper capture for telemetry-only\n   * consumers that don't read domain fields. `'ref'` — pass-through by\n   * reference; the caller asserts immutability (dev-mode warns).\n   */\n  readonly capture?: CapturePolicy;\n  /** Queue bound — default 10 000. */\n  readonly maxQueue?: number;\n  /** Overflow policy at `maxQueue` — default `'drop-oldest'`. */\n  readonly overflow?: OverflowPolicy;\n  /** `'sample'` overflow only — admit 1 in this many saturated arrivals. */\n  readonly sampleEvery?: number;\n  /** Per-checkpoint flush budget, ms (A1) — default 2; `Infinity` = full drain. */\n  readonly flushBudgetMs?: number;\n}\n\n/**\n * The Block 9 observability surface — `snapshot.observerStats`. The A4\n * dispatcher stats plus the terminal-flush stranding count from Block 8.\n * Present on `RuntimeSnapshot` only when a deferred observer was attached.\n */\nexport interface ObserverStats extends DispatcherStats {\n  /**\n   * Envelopes still queued when a terminal flush hit its runaway-cascade\n   * round cap (Block 8). `0` in any sane run — a non-zero value means a\n   * listener kept enqueueing work at end-of-run and delivery was cut off\n   * (also dev-warned at the moment it happened). Never silent.\n   */\n  readonly terminalStranded: number;\n}\n\n/** Result shape of `executor.drainObservers()` — see `DrainResult`. */\nexport type ObserverDrainResult = DrainResult;\n\n/** Well-known ids of the synthetic capture taps (internal, documented for debugging). */\nexport const DEFERRED_SCOPE_TAP_ID = '__deferred-scope-tap__';\nexport const DEFERRED_FLOW_TAP_ID = '__deferred-flow-tap__';\n\n/** Channel reach of the scope-recorder list (scope events + emit events). */\nconst SCOPE_LIST_CHANNELS: readonly CaptureChannel[] = ['scope', 'emit'];\n/** Channel reach of the flow-recorder list. */\nconst FLOW_LIST_CHANNELS: readonly CaptureChannel[] = ['flow'];\n\n/** Dispatcher-level options snapshot, kept for conflict detection. */\ninterface AppliedDispatcherConfig {\n  readonly capture?: CapturePolicy;\n  readonly maxQueue?: number;\n  readonly overflow?: OverflowPolicy;\n  readonly sampleEvery?: number;\n  readonly flushBudgetMs?: number;\n}\n\ninterface DeferredRegistration {\n  readonly recorder: ScopeRecorder | FlowRecorder;\n  /** Which envelope channels reach this recorder (inline-tier parity). */\n  readonly channels: Set<CaptureChannel>;\n}\n\n/** Map an envelope method onto the scope error-event `operation` vocabulary\n *  (same mapping `ScopeFacade._invokeHook` uses for inline failures). */\nfunction operationFor(method: string): 'read' | 'write' | 'commit' {\n  if (method === 'onRead') return 'read';\n  if (method === 'onCommit') return 'commit';\n  return 'write';\n}\n\nexport class DeferredObserverTier {\n  private readonly dispatcher: DeferredDispatcher;\n  private readonly registrations = new Map<string, DeferredRegistration>();\n  private readonly appliedConfig: AppliedDispatcherConfig;\n  /** Dedup memory for the dev-warn seam (one warning per unique message). */\n  private readonly warnedMessages = new Set<string>();\n  private terminalStranded = 0;\n\n  constructor(options?: AttachRecorderOptions) {\n    this.appliedConfig = {\n      // Attach-surface default is 'clone' (review CRITICAL-2): a recorder\n      // ported with `{ delivery: 'deferred' }` keeps receiving the SAME\n      // event shape as inline (e.key/e.value/e.runtimeStageId all intact).\n      // The module-internal envelope default stays 'summary' for raw-\n      // envelope consumers; 'summary' here is an explicit telemetry choice.\n      capture: options?.capture ?? 'clone',\n      maxQueue: options?.maxQueue,\n      overflow: options?.overflow,\n      sampleEvery: options?.sampleEvery,\n      flushBudgetMs: options?.flushBudgetMs,\n    };\n    this.dispatcher = new DeferredDispatcher({\n      maxQueue: options?.maxQueue,\n      overflow: options?.overflow,\n      sampleEvery: options?.sampleEvery,\n      capturePolicy: options?.capture ?? 'clone',\n      flushBudgetMs: options?.flushBudgetMs,\n      // The dev-warn seam (RFC-001 §\"Resolution: the dev-warn seam\"): the\n      // pure module invokes `warn` on every 'ref' capture and every 'clone'\n      // degradation; the tier binds it to the central isDevMode() flag and\n      // dedupes by message so a hot loop cannot spam the console.\n      hooks: { warn: (message) => this.devWarnDeduped(message) },\n      // Listener failures (sync throws AND async rejections) route into the\n      // existing recorder error channel — see routeListenerError.\n      onError: (error, ctx) => this.routeListenerError(error, ctx.listenerId, ctx.envelope, ctx.phase),\n    });\n  }\n\n  // ── Registry ─────────────────────────────────────────────────────────────\n\n  /**\n   * Register a recorder for deferred delivery on the scope-list channels\n   * (`scope` + `emit`) and/or the flow channel. Idempotent by id — same id\n   * replaces the recorder object; channel lists MERGE across calls (same as\n   * the inline tier, where `attachScopeRecorder(x)` + `attachFlowRecorder(x)`\n   * lands `x` on both lists). Later attaches passing dispatcher-level\n   * options that differ from the first attach's configuration keep the\n   * original config and dev-warn.\n   */\n  register(\n    recorder: ScopeRecorder | FlowRecorder,\n    lists: { scope?: boolean; flow?: boolean },\n    options?: AttachRecorderOptions,\n  ): void {\n    this.warnOnConfigConflict(recorder.id, options);\n    const channels = this.registrations.get(recorder.id)?.channels ?? new Set<CaptureChannel>();\n    if (lists.scope) for (const c of SCOPE_LIST_CHANNELS) channels.add(c);\n    if (lists.flow) for (const c of FLOW_LIST_CHANNELS) channels.add(c);\n    this.registrations.set(recorder.id, { recorder, channels });\n    this.dispatcher.addListener(recorder.id, (envelope) => {\n      const registration = this.registrations.get(recorder.id);\n      if (!registration || !registration.channels.has(envelope.channel)) return;\n      // SAME invoke helper as the inline tier (RFC-001 §9 mitigation) — a\n      // returned Promise lands in the dispatcher's inflight set.\n      return invokeRecorderHook(recorder, envelope.method, envelope.payload) as void | Promise<void>;\n    });\n  }\n\n  /**\n   * Remove the given channel lists from a registration (mirrors the inline\n   * tier, where `detachScopeRecorder` / `detachFlowRecorder` each clear one\n   * list). When no channels remain, the listener is fully removed.\n   */\n  removeFromLists(id: string, lists: { scope?: boolean; flow?: boolean }): void {\n    const registration = this.registrations.get(id);\n    if (!registration) return;\n    if (lists.scope) for (const c of SCOPE_LIST_CHANNELS) registration.channels.delete(c);\n    if (lists.flow) for (const c of FLOW_LIST_CHANNELS) registration.channels.delete(c);\n    if (registration.channels.size === 0) {\n      this.registrations.delete(id);\n      this.dispatcher.removeListener(id);\n    }\n  }\n\n  /** True when `id` is registered for deferred delivery (any channel). */\n  has(id: string): boolean {\n    return this.registrations.has(id);\n  }\n\n  /** Deferred recorders whose reach includes the scope list (scope+emit). */\n  scopeListRecorders(): ScopeRecorder[] {\n    return this.byChannel('scope') as ScopeRecorder[];\n  }\n\n  /** Deferred recorders whose reach includes the flow channel. */\n  flowListRecorders(): FlowRecorder[] {\n    return this.byChannel('flow') as FlowRecorder[];\n  }\n\n  /** Reset deferred recorders before a fresh run (same contract as inline). */\n  clearRecorders(): void {\n    for (const { recorder } of this.registrations.values()) {\n      (recorder as { clear?: () => void }).clear?.();\n    }\n  }\n\n  // ── Capture taps (Block 7) ───────────────────────────────────────────────\n\n  /**\n   * Build the synthetic scope-channel tap — a `ScopeRecorder` placed on the\n   * normal scope-recorder list whose hooks capture into the queue. Built\n   * fresh per traverser so it reflects the current registrations. Only\n   * methods some deferred recorder actually implements are present (no\n   * wasted captures). Returns `undefined` when nothing is registered for\n   * the scope list.\n   *\n   * Redaction ordering: the tap is invoked from the SAME loops as inline\n   * recorders (`_invokeHook` / `emitEvent`), which receive events AFTER the\n   * redaction decision — so a captured payload can never contain a\n   * pre-redaction value the inline tier would not have seen.\n   */\n  buildScopeTap(): ScopeRecorder | undefined {\n    const recorders = this.scopeListRecorders();\n    if (recorders.length === 0) return undefined;\n    const tap: Record<string, unknown> = { id: DEFERRED_SCOPE_TAP_ID };\n    for (const method of RECORDER_EVENT_METHODS) {\n      if (!this.anyImplements(recorders, method)) continue;\n      tap[method] = (event: unknown) => this.captureScopeEvent('scope', method, event);\n    }\n    for (const method of EMIT_RECORDER_EVENT_METHODS) {\n      if (!this.anyImplements(recorders, method)) continue;\n      tap[method] = (event: unknown) => this.captureScopeEvent('emit', method, event);\n    }\n    return tap as unknown as ScopeRecorder;\n  }\n\n  /**\n   * Build the synthetic flow-channel tap — a `FlowRecorder` appended to the\n   * flow-recorders list handed to the traverser. Same contract as\n   * {@link buildScopeTap}.\n   */\n  buildFlowTap(): FlowRecorder | undefined {\n    const recorders = this.flowListRecorders();\n    if (recorders.length === 0) return undefined;\n    const tap: Record<string, unknown> = { id: DEFERRED_FLOW_TAP_ID };\n    for (const method of FLOW_RECORDER_EVENT_METHODS) {\n      if (!this.anyImplements(recorders, method)) continue;\n      tap[method] = (event: unknown) => this.captureFlowEvent(method, event);\n    }\n    return tap as unknown as FlowRecorder;\n  }\n\n  /**\n   * Direct capture for executor-synthesized events that bypass the dispatch\n   * sites (e.g. the synthetic `onResume` the executor fires on resume).\n   */\n  capture(channel: CaptureChannel, method: string, runtimeStageId: string, runId: string, payload: unknown): void {\n    this.dispatcher.capture({ channel, method, runtimeStageId, runId, payload });\n  }\n\n  // ── Terminal flush + drain (Block 8) ─────────────────────────────────────\n\n  /**\n   * Synchronously deliver everything still queued — called by the executor\n   * at the OUTERMOST run boundary (resolve, reject, pause), BEFORE `run()`\n   * returns / rethrows / the checkpoint becomes available. Inspects\n   * `flushSync`'s `remaining` (reviewer N1): `flushSync` already loops\n   * snapshot rounds up to its runaway-cascade cap, so a non-zero remainder\n   * means a pathological self-enqueueing listener — counted in\n   * `observerStats.terminalStranded` and dev-warned, never silent.\n   */\n  terminalFlush(): void {\n    const { remaining } = this.dispatcher.flushNow();\n    if (remaining > 0) {\n      this.terminalStranded += remaining;\n      if (isDevMode()) {\n        // eslint-disable-next-line no-console\n        console.warn(\n          `[footprintjs] deferred observers: terminal flush hit the runaway-cascade cap with ${remaining} ` +\n            'event(s) still queued — a listener kept enqueueing during the flush. The stranded count is ' +\n            'surfaced on snapshot.observerStats.terminalStranded.',\n        );\n      }\n    }\n  }\n\n  /**\n   * Flush the backlog, then settle async listener continuations under a\n   * deadline — the serverless / graceful-shutdown pattern (RFC-001 §11).\n   */\n  drain(opts?: { timeoutMs?: number }): Promise<ObserverDrainResult> {\n    return this.dispatcher.drain(opts);\n  }\n\n  // ── Stats (Block 9) ──────────────────────────────────────────────────────\n\n  /** The `snapshot.observerStats` payload — A4 stats + Block 8 stranding. */\n  getStats(): ObserverStats {\n    return { ...this.dispatcher.getStats(), terminalStranded: this.terminalStranded };\n  }\n\n  // ── Internals ────────────────────────────────────────────────────────────\n\n  private byChannel(channel: CaptureChannel): Array<ScopeRecorder | FlowRecorder> {\n    const out: Array<ScopeRecorder | FlowRecorder> = [];\n    for (const { recorder, channels } of this.registrations.values()) {\n      if (channels.has(channel)) out.push(recorder);\n    }\n    return out;\n  }\n\n  /** Normal property lookup — invocation parity with the inline tier. */\n  private anyImplements(recorders: Array<ScopeRecorder | FlowRecorder>, method: string): boolean {\n    return recorders.some((r) => typeof (r as unknown as Record<string, unknown>)[method] === 'function');\n  }\n\n  /** Scope/emit events carry their own ids (`runtimeStageId` + `pipelineId`). */\n  private captureScopeEvent(channel: CaptureChannel, method: string, event: unknown): void {\n    const e = event as { runtimeStageId?: string; pipelineId?: string } | undefined;\n    this.dispatcher.capture({\n      channel,\n      method,\n      runtimeStageId: e?.runtimeStageId ?? '',\n      runId: e?.pipelineId ?? '',\n      payload: event,\n    });\n  }\n\n  /** Flow events carry ids on `traversalContext` (absent on a few events). */\n  private captureFlowEvent(method: string, event: unknown): void {\n    const ctx = (event as { traversalContext?: { runtimeStageId?: string; runId?: string } } | undefined)\n      ?.traversalContext;\n    this.dispatcher.capture({\n      channel: 'flow',\n      method,\n      runtimeStageId: ctx?.runtimeStageId ?? '',\n      runId: ctx?.runId ?? '',\n      payload: event,\n    });\n  }\n\n  /**\n   * Route a deferred listener failure into the existing recorder error\n   * channel: every OTHER registered observer (deferred siblings first, in\n   * registration order) receives a scope-shaped `onError` event — the same\n   * contract the inline tier honors when a recorder throws mid-dispatch.\n   * The error sink must never become an error source: sink throws are\n   * swallowed (isolation is absolute).\n   */\n  private routeListenerError(\n    error: unknown,\n    listenerId: string,\n    envelope: CaptureEnvelope,\n    phase: 'sync' | 'async',\n  ): void {\n    const hashIdx = envelope.runtimeStageId.lastIndexOf('#');\n    const errorEvent = {\n      stageName: '',\n      stageId: hashIdx >= 0 ? envelope.runtimeStageId.slice(0, hashIdx) : envelope.runtimeStageId,\n      runtimeStageId: envelope.runtimeStageId,\n      pipelineId: envelope.runId,\n      timestamp: Date.now(),\n      error: error instanceof Error ? error : new Error(String(error)),\n      operation: operationFor(envelope.method),\n      channel: 'scope' as const,\n    };\n    for (const [id, { recorder, channels }] of this.registrations) {\n      if (id === listenerId) continue;\n      // Inline-tier parity (review CRITICAL-1): the synthesized event is\n      // scope-typed, so it reaches ONLY recorders registered on the scope\n      // lists — a flow-only recorder never receives scope-channel errors\n      // inline and must not here either.\n      if (!channels.has('scope')) continue;\n      try {\n        invokeRecorderHook(recorder, 'onError', errorEvent);\n      } catch {\n        // Swallow — same rule as DeferredDispatcher.safeOnError.\n      }\n    }\n    if (isDevMode()) {\n      // eslint-disable-next-line no-console\n      console.warn(\n        `[footprintjs] deferred observer '${listenerId}' failed (${phase}) handling ` +\n          `${envelope.channel}.${envelope.method} (seq ${envelope.seq}): ${String(error)}`,\n      );\n    }\n  }\n\n  /** Dispatcher-level options are first-attach-wins; differing later values dev-warn. */\n  private warnOnConfigConflict(recorderId: string, options?: AttachRecorderOptions): void {\n    if (!options) return;\n    const conflicts: string[] = [];\n    const requested: AppliedDispatcherConfig = {\n      capture: options.capture,\n      maxQueue: options.maxQueue,\n      overflow: options.overflow,\n      sampleEvery: options.sampleEvery,\n      flushBudgetMs: options.flushBudgetMs,\n    };\n    for (const key of Object.keys(requested) as Array<keyof AppliedDispatcherConfig>) {\n      if (requested[key] !== undefined && requested[key] !== this.appliedConfig[key]) {\n        conflicts.push(String(key));\n      }\n    }\n    if (conflicts.length > 0) {\n      this.devWarnDeduped(\n        `[footprintjs] attach '${recorderId}': the executor's deferred-observer queue was already ` +\n          `configured by the first deferred attach — ignoring differing option(s): ${conflicts.join(', ')}. ` +\n          'One executor has ONE merged queue; configure it on the first deferred attach.',\n      );\n    }\n  }\n\n  /** `isDevMode()`-gated, deduplicated warner — the bound warn seam. */\n  private devWarnDeduped(message: string): void {\n    if (!isDevMode()) return;\n    if (this.warnedMessages.has(message)) return;\n    this.warnedMessages.add(message);\n    // eslint-disable-next-line no-console\n    console.warn(message);\n  }\n}\n"]}

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

@@ -121,4 +121,4 @@ export class ExecutionRuntime {
         };
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ExecutionRuntime.js","sourceRoot":"","sources":["../../../../src/lib/runner/ExecutionRuntime.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ExecutionRuntime — The runtime environment for one flowchart execution.\n *\n * Wires up the three memory primitives into a single container:\n *   - SharedMemory (the heap — shared state across all stages)\n *   - StageContext  (the call stack — per-stage execution tree)\n *   - EventLog      (the transaction log — commit history for replay)\n *\n * The engine (FlowchartTraverser) receives this as its runtime parameter.\n * After execution, consumers query it for the full execution state.\n */\n\nimport { EventLog } from '../memory/EventLog.js';\nimport { SharedMemory } from '../memory/SharedMemory.js';\nimport { StageContext } from '../memory/StageContext.js';\nimport type { CommitBundle, ReadTrackingMode, StageSnapshot, WriteTrackingMode } from '../memory/types.js';\n\n/** Snapshot of a single recorder's collected data. */\nexport interface RecorderSnapshot {\n  id: string;\n  name: string;\n  /** ScopeRecorder type and pattern description (e.g., \"Translator (KeyedStore) — per-step token usage\"). */\n  description?: string;\n  /** Preferred read-time operation — hints the UI about which view to show prominently. */\n  preferredOperation?: 'translate' | 'accumulate' | 'aggregate';\n  data: unknown;\n}\n\nexport type RuntimeSnapshot = {\n  sharedState: Record<string, unknown>;\n  executionTree: StageSnapshot;\n  commitLog: CommitBundle[];\n  /** Per-subflow execution results (keyed by subflowId). */\n  subflowResults?: Record<string, unknown>;\n  /** Snapshot data from recorders that implement toSnapshot(). */\n  recorders?: RecorderSnapshot[];\n};\n\nexport class ExecutionRuntime {\n  public globalStore: SharedMemory;\n  /**\n   * Parallel redacted mirror of `globalStore`. Populated during traversal via\n   * `StageContext.commit()` using the already-computed redacted patches.\n   * Only exists when `enableRedactedMirror()` has been called — typically by\n   * `FlowChartExecutor` when a `RedactionPolicy` is configured. Otherwise\n   * undefined and zero cost.\n   *\n   * Read via `getSnapshot({ redact: true })`.\n   */\n  public redactedStore?: SharedMemory;\n  public rootStageContext: StageContext;\n  public executionHistory: EventLog;\n  /** Original root for getSnapshot() — set before resume changes rootStageContext. */\n  private _snapshotRoot?: StageContext;\n  private _initialState: unknown;\n  private _defaultValues: unknown;\n\n  constructor(rootName: string, rootId: string, defaultValues?: unknown, initialState?: unknown) {\n    this._initialState = initialState;\n    this._defaultValues = defaultValues;\n    this.executionHistory = new EventLog(initialState);\n    this.globalStore = new SharedMemory(defaultValues, initialState);\n    this.rootStageContext = new StageContext('', rootName, rootId, this.globalStore, '', this.executionHistory);\n  }\n\n  /**\n   * Opt in to maintaining a parallel redacted mirror of `globalStore`. After\n   * this call, every `StageContext.commit()` in the run writes the redacted\n   * patches (the same ones fed to the event log) into `redactedStore` in\n   * addition to the raw ones written to `globalStore`.\n   *\n   * The mirror is created lazily and propagated into all child / next\n   * contexts, so it correctly reflects subflow-scope writes. When no\n   * `RedactionPolicy` is configured, callers should skip this — unused\n   * allocation, no functional difference in the snapshot.\n   */\n  enableRedactedMirror(): void {\n    if (this.redactedStore) return; // idempotent\n    this.redactedStore = new SharedMemory(\n      this._defaultValues,\n      // Seed with the same initial state as the raw store so the mirror\n      // starts from a scrubbed-nothing baseline; subsequent commits apply\n      // the redacted patches on top.\n      this._initialState,\n    );\n    this.rootStageContext.useRedactedMirror(this.redactedStore);\n  }\n\n  /**\n   * Set the read-tracking policy (#14) on the root stage context. Descendant\n   * contexts inherit via `createNext`/`createChild`; subflow root contexts\n   * inherit from their parent-mount context via `SubflowExecutor`. Called by\n   * `FlowChartExecutor.createTraverser()` when the executor's policy is not\n   * the default `'full'` — including the resume path, where it is applied to\n   * the freshly-created continuation root.\n   */\n  useReadTracking(mode: ReadTrackingMode): void {\n    this.rootStageContext.useReadTracking(mode);\n  }\n\n  /**\n   * Set the write-tracking policy (#13c-A) on the root stage context — the\n   * sibling of {@link useReadTracking}, with identical plumbing: descendant\n   * contexts inherit via `createNext`/`createChild`; subflow root contexts\n   * inherit from their parent-mount context via `SubflowExecutor`. Called by\n   * `FlowChartExecutor.createTraverser()` when the executor's policy is not\n   * the default `'full'` — including the resume path, where it is applied to\n   * the freshly-created continuation root.\n   */\n  useWriteTracking(mode: WriteTrackingMode): void {\n    this.rootStageContext.useWriteTracking(mode);\n  }\n\n  /** Preserve the current rootStageContext for snapshots before changing it for resume. */\n  preserveSnapshotRoot(): void {\n    if (!this._snapshotRoot) {\n      this._snapshotRoot = this.rootStageContext;\n    }\n  }\n\n  getPipelines(): string[] {\n    const state = this.globalStore.getState();\n    return state.pipelines ? Object.keys(state.pipelines as Record<string, unknown>) : [];\n  }\n\n  setRootObject(path: string[], key: string, value: unknown) {\n    this.rootStageContext.setObject(path, key, value);\n  }\n\n  /**\n   * Return the runtime snapshot.\n   *\n   * @param options.redact  When `true`, returns `sharedState` from the\n   *   parallel redacted mirror (if one was enabled). This is the safe view\n   *   for sharing traces externally — paste into a viewer, ship to support,\n   *   etc. When the mirror was never enabled, falls back to raw `globalStore`\n   *   and a dev-mode warning is emitted (silent in production).\n   *\n   *   Default `false` preserves the runtime view — necessary for pause /\n   *   resume (resumption must replay against the real values, not\n   *   '[REDACTED]').\n   *\n   * Other fields (`executionTree`, `commitLog`) are the same either way —\n   * the commit log is already redacted at write-time, and the execution\n   * tree only carries structural metadata.\n   */\n  getSnapshot(options?: { redact?: boolean }): RuntimeSnapshot {\n    const snapshotRoot = this._snapshotRoot ?? this.rootStageContext;\n    const useRedacted = options?.redact === true && this.redactedStore !== undefined;\n    return {\n      sharedState: useRedacted ? this.redactedStore!.getState() : this.globalStore.getState(),\n      executionTree: snapshotRoot.getSnapshot(),\n      commitLog: this.executionHistory.list(),\n    };\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ExecutionRuntime.js","sourceRoot":"","sources":["../../../../src/lib/runner/ExecutionRuntime.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ExecutionRuntime — The runtime environment for one flowchart execution.\n *\n * Wires up the three memory primitives into a single container:\n *   - SharedMemory (the heap — shared state across all stages)\n *   - StageContext  (the call stack — per-stage execution tree)\n *   - EventLog      (the transaction log — commit history for replay)\n *\n * The engine (FlowchartTraverser) receives this as its runtime parameter.\n * After execution, consumers query it for the full execution state.\n */\n\nimport { EventLog } from '../memory/EventLog.js';\nimport { SharedMemory } from '../memory/SharedMemory.js';\nimport { StageContext } from '../memory/StageContext.js';\nimport type { CommitBundle, ReadTrackingMode, StageSnapshot, WriteTrackingMode } from '../memory/types.js';\nimport type { ObserverStats } from './DeferredObserverTier.js';\n\n/** Snapshot of a single recorder's collected data. */\nexport interface RecorderSnapshot {\n  id: string;\n  name: string;\n  /** ScopeRecorder type and pattern description (e.g., \"Translator (KeyedStore) — per-step token usage\"). */\n  description?: string;\n  /** Preferred read-time operation — hints the UI about which view to show prominently. */\n  preferredOperation?: 'translate' | 'accumulate' | 'aggregate';\n  data: unknown;\n}\n\nexport type RuntimeSnapshot = {\n  sharedState: Record<string, unknown>;\n  executionTree: StageSnapshot;\n  commitLog: CommitBundle[];\n  /** Per-subflow execution results (keyed by subflowId). */\n  subflowResults?: Record<string, unknown>;\n  /** Snapshot data from recorders that implement toSnapshot(). */\n  recorders?: RecorderSnapshot[];\n  /**\n   * Deferred-observer accounting (RFC-001 Block 9) — queue depth, drops,\n   * flush/budget counters, per-listener time attribution, and the\n   * terminal-flush stranding count. ABSENT unless a recorder was attached\n   * with `{ delivery: 'deferred' }` on this executor (zero-cost discipline).\n   */\n  observerStats?: ObserverStats;\n};\n\nexport class ExecutionRuntime {\n  public globalStore: SharedMemory;\n  /**\n   * Parallel redacted mirror of `globalStore`. Populated during traversal via\n   * `StageContext.commit()` using the already-computed redacted patches.\n   * Only exists when `enableRedactedMirror()` has been called — typically by\n   * `FlowChartExecutor` when a `RedactionPolicy` is configured. Otherwise\n   * undefined and zero cost.\n   *\n   * Read via `getSnapshot({ redact: true })`.\n   */\n  public redactedStore?: SharedMemory;\n  public rootStageContext: StageContext;\n  public executionHistory: EventLog;\n  /** Original root for getSnapshot() — set before resume changes rootStageContext. */\n  private _snapshotRoot?: StageContext;\n  private _initialState: unknown;\n  private _defaultValues: unknown;\n\n  constructor(rootName: string, rootId: string, defaultValues?: unknown, initialState?: unknown) {\n    this._initialState = initialState;\n    this._defaultValues = defaultValues;\n    this.executionHistory = new EventLog(initialState);\n    this.globalStore = new SharedMemory(defaultValues, initialState);\n    this.rootStageContext = new StageContext('', rootName, rootId, this.globalStore, '', this.executionHistory);\n  }\n\n  /**\n   * Opt in to maintaining a parallel redacted mirror of `globalStore`. After\n   * this call, every `StageContext.commit()` in the run writes the redacted\n   * patches (the same ones fed to the event log) into `redactedStore` in\n   * addition to the raw ones written to `globalStore`.\n   *\n   * The mirror is created lazily and propagated into all child / next\n   * contexts, so it correctly reflects subflow-scope writes. When no\n   * `RedactionPolicy` is configured, callers should skip this — unused\n   * allocation, no functional difference in the snapshot.\n   */\n  enableRedactedMirror(): void {\n    if (this.redactedStore) return; // idempotent\n    this.redactedStore = new SharedMemory(\n      this._defaultValues,\n      // Seed with the same initial state as the raw store so the mirror\n      // starts from a scrubbed-nothing baseline; subsequent commits apply\n      // the redacted patches on top.\n      this._initialState,\n    );\n    this.rootStageContext.useRedactedMirror(this.redactedStore);\n  }\n\n  /**\n   * Set the read-tracking policy (#14) on the root stage context. Descendant\n   * contexts inherit via `createNext`/`createChild`; subflow root contexts\n   * inherit from their parent-mount context via `SubflowExecutor`. Called by\n   * `FlowChartExecutor.createTraverser()` when the executor's policy is not\n   * the default `'full'` — including the resume path, where it is applied to\n   * the freshly-created continuation root.\n   */\n  useReadTracking(mode: ReadTrackingMode): void {\n    this.rootStageContext.useReadTracking(mode);\n  }\n\n  /**\n   * Set the write-tracking policy (#13c-A) on the root stage context — the\n   * sibling of {@link useReadTracking}, with identical plumbing: descendant\n   * contexts inherit via `createNext`/`createChild`; subflow root contexts\n   * inherit from their parent-mount context via `SubflowExecutor`. Called by\n   * `FlowChartExecutor.createTraverser()` when the executor's policy is not\n   * the default `'full'` — including the resume path, where it is applied to\n   * the freshly-created continuation root.\n   */\n  useWriteTracking(mode: WriteTrackingMode): void {\n    this.rootStageContext.useWriteTracking(mode);\n  }\n\n  /** Preserve the current rootStageContext for snapshots before changing it for resume. */\n  preserveSnapshotRoot(): void {\n    if (!this._snapshotRoot) {\n      this._snapshotRoot = this.rootStageContext;\n    }\n  }\n\n  getPipelines(): string[] {\n    const state = this.globalStore.getState();\n    return state.pipelines ? Object.keys(state.pipelines as Record<string, unknown>) : [];\n  }\n\n  setRootObject(path: string[], key: string, value: unknown) {\n    this.rootStageContext.setObject(path, key, value);\n  }\n\n  /**\n   * Return the runtime snapshot.\n   *\n   * @param options.redact  When `true`, returns `sharedState` from the\n   *   parallel redacted mirror (if one was enabled). This is the safe view\n   *   for sharing traces externally — paste into a viewer, ship to support,\n   *   etc. When the mirror was never enabled, falls back to raw `globalStore`\n   *   and a dev-mode warning is emitted (silent in production).\n   *\n   *   Default `false` preserves the runtime view — necessary for pause /\n   *   resume (resumption must replay against the real values, not\n   *   '[REDACTED]').\n   *\n   * Other fields (`executionTree`, `commitLog`) are the same either way —\n   * the commit log is already redacted at write-time, and the execution\n   * tree only carries structural metadata.\n   */\n  getSnapshot(options?: { redact?: boolean }): RuntimeSnapshot {\n    const snapshotRoot = this._snapshotRoot ?? this.rootStageContext;\n    const useRedacted = options?.redact === true && this.redactedStore !== undefined;\n    return {\n      sharedState: useRedacted ? this.redactedStore!.getState() : this.globalStore.getState(),\n      executionTree: snapshotRoot.getSnapshot(),\n      commitLog: this.executionHistory.list(),\n    };\n  }\n}\n"]}