footprintjs 10.0.1 → 10.2.0

package/dist/lib/runner/recordSink.js

@@ -0,0 +1,302 @@
+"use strict";
+/**
+ * runner/recordSink.ts — the run's side of the crash-safe record (design §3.5, packet P6).
+ *
+ * foottrace owns the port (`RecordSink`, `foottrace/write`): a log built with a sink hands it every entry AS IT
+ * LANDS — `opened`, `commit`, `note`, `closed` — and counts what the sink did not take. This file is what the
+ * EXECUTOR adds around an app's adapter, one {@link RunRecord} per run:
+ *
+ *   - THE ONE LAW, before any byte leaves: the `opened` base is the run's served form of it (the redaction rule's
+ *     `retainState`, the mirror's seed — so a policy key seeded by `initialContext` or a checkpoint never reaches
+ *     the sink), and the `opened` / `closed` meta are boundary records (`retainBoundary`). A commit is the log's own
+ *     bundle, already scrubbed at commit; an attempt note carries the served `AttemptRecord` (no `raw`).
+ *   - ACCOUNTING: every entry handed to the adapter is counted, every loss too (`getSnapshot().sink`), with a
+ *     dev-mode warning on the first loss of a run. The adapter's own `onFailure` hears a dispatched entry's loss
+ *     with that same served entry and a served error, isolated. A refusal before dispatch is counted without
+ *     forwarding Foottrace's unserved entry.
+ *   - THE FAILURE MODE (owner ruling Q3): `'report'` (default) — the run goes on; `'fail'` — the first lost entry
+ *     aborts the run's signal with a {@link RecordSinkError}, and a run that finished with a loss rejects with it.
+ *   - FLUSH: `'auto'` (default) — `run()` / `resume()` await the adapter's `flush()` after the closing entry;
+ *     `'manual'` — the app calls `executor.flushRecord()`.
+ *
+ * Every adapter method is called synchronously from the log; whatever the adapter throws or rejects with is the
+ * log's to count (`EventLog · sinkFailures`), never the run's — so nothing here throws to the engine.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunRecord = exports.resolveRecordSink = exports.RecordSinkError = void 0;
+const write_1 = require("foottrace/write");
+const devMode_js_1 = require("../devMode.js");
+const errorInfo_js_1 = require("../errors/errorInfo.js");
+const redaction_js_1 = require("../memory/redaction.js");
+/**
+ * A run with `sink: { onFailure: 'fail' }` lost an entry: the record the app asked to be kept is not whole.
+ * `cause` is the adapter's own error.
+ */
+class RecordSinkError extends Error {
+    cause;
+    name = 'RecordSinkError';
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+    }
+}
+exports.RecordSinkError = RecordSinkError;
+const METHODS = ['opened', 'commit', 'note', 'closed'];
+function isAdapter(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    return METHODS.every((m) => typeof value[m] === 'function');
+}
+/**
+ * Resolve the executor's `sink` option, or refuse it with a `TypeError` naming what is wrong — a wiring mistake
+ * the app makes once, so it fails at construction, never mid-run.
+ */
+function resolveRecordSink(option) {
+    if (option === undefined)
+        return undefined;
+    if (isAdapter(option))
+        return { adapter: option, onFailure: 'report', flush: 'auto' };
+    if (option !== null && typeof option === 'object' && Object.hasOwn(option, 'adapter')) {
+        const { adapter, onFailure = 'report', flush = 'auto' } = option;
+        if (!isAdapter(adapter)) {
+            throw new TypeError('FlowChartExecutor: sink.adapter must be a RecordSink (opened, commit, note, closed)');
+        }
+        if (onFailure !== 'report' && onFailure !== 'fail') {
+            throw new TypeError("FlowChartExecutor: sink.onFailure must be 'report' or 'fail'");
+        }
+        if (flush !== 'auto' && flush !== 'manual') {
+            throw new TypeError("FlowChartExecutor: sink.flush must be 'auto' or 'manual'");
+        }
+        return { adapter, onFailure, flush };
+    }
+    throw new TypeError('FlowChartExecutor: sink must be a RecordSink (opened, commit, note, closed) or { adapter, onFailure?, flush? }');
+}
+exports.resolveRecordSink = resolveRecordSink;
+/**
+ * One run's record sink: the sink every log of the run writes to (root and mounts), its accounting and its
+ * failure mode. A same-executor resume keeps it (the root log goes on); a fresh run makes a new one.
+ */
+class RunRecord {
+    resolved;
+    /** Hand this to every `EventLog` of the run. */
+    sink;
+    entries = 0;
+    failed = 0;
+    lastError;
+    warned = false;
+    rule;
+    /** Aborted at the first loss under `'fail'` — composed into the leg's signal; fresh per leg ({@link beginLeg}). */
+    stopper;
+    failure;
+    /** Opaque error identities only: no raw entry or adapter error is enumerable on the transport error. */
+    invocationFailures = new WeakMap();
+    constructor(resolved) {
+        this.resolved = resolved;
+        if (resolved.onFailure === 'fail')
+            this.stopper = new AbortController();
+        const adapter = resolved.adapter;
+        const handed = () => {
+            this.entries += 1;
+        };
+        this.sink = {
+            opened: (entry) => {
+                handed();
+                const rule = this.rule;
+                const served = {
+                    ...entry,
+                    initialState: rule ? rule.retainState(entry.initialState, write_1.LOG_PLACEHOLDER) : entry.initialState,
+                    ...(entry.meta === undefined ? {} : { meta: this.serve(entry.meta) }),
+                };
+                return this.invoke({ ...served, kind: 'opened' }, () => adapter.opened(served), rule);
+            },
+            commit: (entry) => {
+                handed();
+                return this.invoke({ ...entry, kind: 'commit' }, () => adapter.commit(entry), this.rule);
+            },
+            note: (entry) => {
+                handed();
+                return this.invoke({ address: entry.address, at: entry.at, kind: 'note', note: entry.kind, data: entry.data }, () => adapter.note(entry), this.rule);
+            },
+            closed: (entry) => {
+                handed();
+                const served = { ...entry, ...(entry.meta === undefined ? {} : { meta: this.serve(entry.meta) }) };
+                return this.invoke({ ...served, kind: 'closed' }, () => adapter.closed(served), this.rule);
+            },
+            onFailure: (failure) => {
+                const invocation = failure.error !== null && (typeof failure.error === 'object' || typeof failure.error === 'function')
+                    ? this.invocationFailures.get(failure.error)
+                    : undefined;
+                // Before admission (e.g. a meta-copy refusal), no dispatched served entry exists. Count the loss and
+                // apply the failure mode, but never hand the adapter Foottrace's original, unserved entry.
+                if (invocation === undefined)
+                    this.lost(failure.error, undefined, this.errorView(failure.error, this.rule));
+                else
+                    this.lost(invocation.cause, invocation.entry, invocation.view);
+            },
+        };
+    }
+    /** Capture the served entry now; an asynchronous failure keeps this leg's rule, not a later resume's rule. */
+    invoke(entry, call, rule) {
+        const failed = (cause) => {
+            const envelope = new Error('record sink: adapter invocation failed');
+            this.invocationFailures.set(envelope, { entry, cause, view: this.errorView(cause, rule) });
+            throw envelope;
+        };
+        try {
+            const returned = call();
+            // Void adapters keep their synchronous path; only an object/function can be a thenable. settleOnce
+            // observes native promises through Promise.prototype.then and guards hostile thenables too.
+            if (returned === null || (typeof returned !== 'object' && typeof returned !== 'function'))
+                return returned;
+            return settleOnce(returned, () => undefined, failed);
+        }
+        catch (cause) {
+            return failed(cause);
+        }
+    }
+    /** A sink error is the diagnostic errors.recordSinkError; raw causes belong only to the caller's exception. */
+    errorView(error, rule) {
+        const text = (0, errorInfo_js_1.thrownText)(error);
+        const retained = rule
+            ? rule.retainStageError(error, text, rule.retainDiagnostic(['errors', 'recordSinkError'], text))
+            : { message: text, structuredError: (0, errorInfo_js_1.extractErrorInfo)(error) };
+        const served = { ...retained.structuredError };
+        Reflect.deleteProperty(served, 'raw');
+        return {
+            text: retained.message,
+            error: served,
+            masked: retained.message !== text || retained.structuredError.raw !== error,
+            rule,
+        };
+    }
+    /**
+     * A same-executor resume starts a new leg on the same record: the counts go on (one log, one record), but the
+     * failure mode is the LEG's — a loss in an earlier leg (which already failed that leg) does not stop this one —
+     * and the dev-mode warning may fire again.
+     */
+    beginLeg() {
+        if (this.resolved.onFailure === 'fail')
+            this.stopper = new AbortController();
+        this.failure = undefined;
+        this.warned = false;
+    }
+    /** The leg's redaction rule — a resume builds a new one; the next `opened` / `closed` is served under it. */
+    useRule(rule) {
+        this.rule = rule;
+    }
+    /** Aborts at the first loss under `onFailure: 'fail'`; absent otherwise. */
+    get stopSignal() {
+        return this.stopper?.signal;
+    }
+    get flushMode() {
+        return this.resolved.flush;
+    }
+    /** The loss that fails the run under `'fail'`; absent while nothing was lost (and always under `'report'`). */
+    get fatal() {
+        return this.failure;
+    }
+    stats() {
+        return {
+            entries: this.entries,
+            failed: this.failed,
+            ...(this.lastError === undefined ? {} : { lastError: this.lastError }),
+        };
+    }
+    /**
+     * Await the adapter's `flush()`, at most `timeoutMs` when given. A flush that throws or rejects is a loss
+     * (counted, and fatal under `'fail'`); one still running at the deadline is `pending` and keeps running — and,
+     * with `pendingIsLoss` (the run's own flush), counted as a loss too, so a flush that never settles cannot hold a
+     * run open, and cannot pass for one that landed. Nothing here throws: a hostile adapter (a throwing `flush`
+     * getter, a promise with its own `then`) is a loss, never the run's error.
+     */
+    async flush(timeoutMs, pendingIsLoss = false) {
+        const adapter = this.resolved.adapter;
+        const rule = this.rule;
+        let settled;
+        let givenUp = false; // a flush already counted as a loss at the deadline is not counted again when it rejects
+        try {
+            const flush = adapter.flush; // read once: a getter runs once, inside the guard
+            if (typeof flush !== 'function')
+                return { done: true, failed: false, pending: false };
+            settled = settleOnce(flush.call(adapter), () => ({ done: true, failed: false, pending: false }), (error) => {
+                if (!givenUp)
+                    this.lost(error, undefined, this.errorView(error, rule));
+                return { done: false, failed: true, pending: false };
+            });
+        }
+        catch (error) {
+            this.lost(error, undefined, this.errorView(error, rule));
+            return { done: false, failed: true, pending: false };
+        }
+        if (timeoutMs === undefined || !Number.isFinite(timeoutMs))
+            return settled;
+        let timer;
+        const pending = new Promise((resolve) => {
+            timer = setTimeout(() => resolve({ done: false, failed: false, pending: true }), Math.max(0, timeoutMs));
+        });
+        try {
+            const result = await Promise.race([settled, pending]);
+            if (result.pending && pendingIsLoss) {
+                givenUp = true;
+                const error = new Error(`record sink: flush() did not settle within ${Math.max(0, timeoutMs)}ms`);
+                this.lost(error, undefined, this.errorView(error, rule));
+            }
+            return result;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    /** The meta as served: a boundary record, scrubbed by key name at every depth (an inert rule copies nothing). */
+    serve(meta) {
+        return this.rule ? this.rule.retainBoundary(meta, write_1.LOG_PLACEHOLDER) : meta;
+    }
+    /** One loss: counted, warned once per run, told with a safe dispatched entry when available, fatal under 'fail'. */
+    lost(error, entry, view) {
+        this.failed += 1;
+        const text = view.text;
+        this.lastError = text;
+        if ((0, devMode_js_1.isDevMode)() && !this.warned) {
+            this.warned = true;
+            // eslint-disable-next-line no-console
+            console.warn(`[footprint] record sink: an entry was not stored (${text}). The run goes on; ` +
+                'getSnapshot().sink counts every loss.');
+        }
+        // The failure mode first: nothing the adapter's own listener does can skip it.
+        if (this.stopper !== undefined && this.failure === undefined) {
+            this.failure = new RecordSinkError(`record sink: an entry was not stored — ${text}`, error);
+            if (view.masked) {
+                // The caller keeps the real cause, but observers of this new wrapper must inherit its remembered mask.
+                view.rule?.retainStageError(this.failure, this.failure.message, redaction_js_1.SCOPE_PLACEHOLDER);
+                if (this.rule !== view.rule)
+                    this.rule?.retainStageError(this.failure, this.failure.message, redaction_js_1.SCOPE_PLACEHOLDER);
+            }
+            this.stopper.abort(this.failure);
+        }
+        if (entry !== undefined)
+            tellAdapter(this.resolved.adapter, { entry, error: view.error });
+    }
+}
+exports.RunRecord = RunRecord;
+/** The adapter's own `onFailure`, isolated: a throwing getter, a throw or a rejection there changes nothing. */
+function tellAdapter(adapter, failure) {
+    try {
+        const listener = adapter.onFailure;
+        if (typeof listener !== 'function')
+            return;
+        settleOnce(listener.call(adapter, failure), () => undefined, () => undefined);
+    }
+    catch {
+        // A listener that fails is the adapter's own business: the loss is already counted.
+    }
+}
+/**
+ * `value`, settled ONCE into `onValue` / `onError` — never through the value's own `then`: a native promise is
+ * watched through the real `Promise.prototype.then` (an own `then` on it is not trusted, so its rejection is always
+ * handled), any other thenable adopted into a fresh promise. A plain value is a fulfilment.
+ */
+function settleOnce(value, onValue, onError) {
+    const adopted = value instanceof Promise ? value : new Promise((resolve) => resolve(value));
+    return Promise.prototype.then.call(adopted, onValue, onError);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recordSink.js","sourceRoot":"","sources":["../../../src/lib/runner/recordSink.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * runner/recordSink.ts — the run's side of the crash-safe record (design §3.5, packet P6).\n *\n * foottrace owns the port (`RecordSink`, `foottrace/write`): a log built with a sink hands it every entry AS IT\n * LANDS — `opened`, `commit`, `note`, `closed` — and counts what the sink did not take. This file is what the\n * EXECUTOR adds around an app's adapter, one {@link RunRecord} per run:\n *\n *   - THE ONE LAW, before any byte leaves: the `opened` base is the run's served form of it (the redaction rule's\n *     `retainState`, the mirror's seed — so a policy key seeded by `initialContext` or a checkpoint never reaches\n *     the sink), and the `opened` / `closed` meta are boundary records (`retainBoundary`). A commit is the log's own\n *     bundle, already scrubbed at commit; an attempt note carries the served `AttemptRecord` (no `raw`).\n *   - ACCOUNTING: every entry handed to the adapter is counted, every loss too (`getSnapshot().sink`), with a\n *     dev-mode warning on the first loss of a run. The adapter's own `onFailure` hears a dispatched entry's loss\n *     with that same served entry and a served error, isolated. A refusal before dispatch is counted without\n *     forwarding Foottrace's unserved entry.\n *   - THE FAILURE MODE (owner ruling Q3): `'report'` (default) — the run goes on; `'fail'` — the first lost entry\n *     aborts the run's signal with a {@link RecordSinkError}, and a run that finished with a loss rejects with it.\n *   - FLUSH: `'auto'` (default) — `run()` / `resume()` await the adapter's `flush()` after the closing entry;\n *     `'manual'` — the app calls `executor.flushRecord()`.\n *\n * Every adapter method is called synchronously from the log; whatever the adapter throws or rejects with is the\n * log's to count (`EventLog · sinkFailures`), never the run's — so nothing here throws to the engine.\n */\n\nimport type { Meta } from 'foottrace';\nimport type { RecordEntry, RecordSink } from 'foottrace/write';\nimport { LOG_PLACEHOLDER } from 'foottrace/write';\n\nimport { isDevMode } from '../devMode.js';\nimport { extractErrorInfo, thrownText } from '../errors/errorInfo.js';\nimport type { RedactionRule } from '../memory/redaction.js';\nimport { SCOPE_PLACEHOLDER } from '../memory/redaction.js';\nimport type { RecordSinkStats } from './ExecutionRuntime.js';\n\n/** What a lost entry does to the run: `'report'` counts it and goes on; `'fail'` fails the run. */\nexport type RecordSinkFailureMode = 'report' | 'fail';\n\n/** When the adapter's `flush()` runs: after each run's closing entry (`'auto'`), or when the app asks. */\nexport type RecordSinkFlushMode = 'auto' | 'manual';\n\n/**\n * The executor's `sink` option in its long form. The short form is the adapter itself.\n *\n * @example\n * ```typescript\n * new FlowChartExecutor(chart, { sink: { adapter: fileSink('/var/footprint/run.jsonl'), onFailure: 'fail' } });\n * ```\n */\nexport interface RecordSinkOptions {\n  /** Where the entries go — `fileSink(path)` (`footprintjs/sinks`), `memorySink()` (`foottrace/write`), or yours. */\n  readonly adapter: RecordSink;\n  /** `'report'` (default): a lost entry is counted and the run goes on. `'fail'`: the first one fails the run. */\n  readonly onFailure?: RecordSinkFailureMode;\n  /** `'auto'` (default): `run()` awaits the adapter's `flush()` after the closing entry. `'manual'`: `flushRecord()`. */\n  readonly flush?: RecordSinkFlushMode;\n}\n\n/** The executor's `sink` option: an adapter, or {@link RecordSinkOptions}. */\nexport type RecordSinkOption = RecordSink | RecordSinkOptions;\n\n/** What `executor.flushRecord()` resolves with — the `drainObservers` shape. */\nexport interface RecordFlushResult {\n  /** The adapter's flush finished (or there was nothing to flush). */\n  readonly done: boolean;\n  /** The adapter's flush threw or rejected — counted on `getSnapshot().sink`. */\n  readonly failed: boolean;\n  /** The flush had not settled when `timeoutMs` ran out. */\n  readonly pending: boolean;\n}\n\n/**\n * A run with `sink: { onFailure: 'fail' }` lost an entry: the record the app asked to be kept is not whole.\n * `cause` is the adapter's own error.\n */\nexport class RecordSinkError extends Error {\n  override readonly name = 'RecordSinkError';\n  constructor(message: string, readonly cause: unknown) {\n    super(message);\n  }\n}\n\n/** The option resolved once, at construction. */\nexport interface ResolvedRecordSink {\n  readonly adapter: RecordSink;\n  readonly onFailure: RecordSinkFailureMode;\n  readonly flush: RecordSinkFlushMode;\n}\n\nconst METHODS = ['opened', 'commit', 'note', 'closed'] as const;\n\ninterface SinkErrorView {\n  readonly text: string;\n  readonly error: unknown;\n  readonly masked: boolean;\n  readonly rule?: RedactionRule;\n}\n\ninterface InvocationFailure {\n  readonly entry: RecordEntry;\n  readonly cause: unknown;\n  readonly view: SinkErrorView;\n}\n\nfunction isAdapter(value: unknown): value is RecordSink {\n  if (value === null || typeof value !== 'object') return false;\n  return METHODS.every((m) => typeof (value as Record<string, unknown>)[m] === 'function');\n}\n\n/**\n * Resolve the executor's `sink` option, or refuse it with a `TypeError` naming what is wrong — a wiring mistake\n * the app makes once, so it fails at construction, never mid-run.\n */\nexport function resolveRecordSink(option: unknown): ResolvedRecordSink | undefined {\n  if (option === undefined) return undefined;\n  if (isAdapter(option)) return { adapter: option, onFailure: 'report', flush: 'auto' };\n  if (option !== null && typeof option === 'object' && Object.hasOwn(option, 'adapter')) {\n    const { adapter, onFailure = 'report', flush = 'auto' } = option as Partial<RecordSinkOptions>;\n    if (!isAdapter(adapter)) {\n      throw new TypeError('FlowChartExecutor: sink.adapter must be a RecordSink (opened, commit, note, closed)');\n    }\n    if (onFailure !== 'report' && onFailure !== 'fail') {\n      throw new TypeError(\"FlowChartExecutor: sink.onFailure must be 'report' or 'fail'\");\n    }\n    if (flush !== 'auto' && flush !== 'manual') {\n      throw new TypeError(\"FlowChartExecutor: sink.flush must be 'auto' or 'manual'\");\n    }\n    return { adapter, onFailure, flush };\n  }\n  throw new TypeError(\n    'FlowChartExecutor: sink must be a RecordSink (opened, commit, note, closed) or { adapter, onFailure?, flush? }',\n  );\n}\n\n/**\n * One run's record sink: the sink every log of the run writes to (root and mounts), its accounting and its\n * failure mode. A same-executor resume keeps it (the root log goes on); a fresh run makes a new one.\n */\nexport class RunRecord {\n  /** Hand this to every `EventLog` of the run. */\n  readonly sink: RecordSink;\n  private entries = 0;\n  private failed = 0;\n  private lastError?: string;\n  private warned = false;\n  private rule?: RedactionRule;\n  /** Aborted at the first loss under `'fail'` — composed into the leg's signal; fresh per leg ({@link beginLeg}). */\n  private stopper?: AbortController;\n  private failure?: RecordSinkError;\n  /** Opaque error identities only: no raw entry or adapter error is enumerable on the transport error. */\n  private readonly invocationFailures = new WeakMap<object, InvocationFailure>();\n\n  constructor(private readonly resolved: ResolvedRecordSink) {\n    if (resolved.onFailure === 'fail') this.stopper = new AbortController();\n    const adapter = resolved.adapter;\n    const handed = (): void => {\n      this.entries += 1;\n    };\n    this.sink = {\n      opened: (entry) => {\n        handed();\n        const rule = this.rule;\n        const served = {\n          ...entry,\n          initialState: rule ? rule.retainState(entry.initialState, LOG_PLACEHOLDER) : entry.initialState,\n          ...(entry.meta === undefined ? {} : { meta: this.serve(entry.meta) }),\n        };\n        return this.invoke({ ...served, kind: 'opened' }, () => adapter.opened(served), rule);\n      },\n      commit: (entry) => {\n        handed();\n        return this.invoke({ ...entry, kind: 'commit' }, () => adapter.commit(entry), this.rule);\n      },\n      note: (entry) => {\n        handed();\n        return this.invoke(\n          { address: entry.address, at: entry.at, kind: 'note', note: entry.kind, data: entry.data },\n          () => adapter.note(entry),\n          this.rule,\n        );\n      },\n      closed: (entry) => {\n        handed();\n        const served = { ...entry, ...(entry.meta === undefined ? {} : { meta: this.serve(entry.meta) }) };\n        return this.invoke({ ...served, kind: 'closed' }, () => adapter.closed(served), this.rule);\n      },\n      onFailure: (failure) => {\n        const invocation =\n          failure.error !== null && (typeof failure.error === 'object' || typeof failure.error === 'function')\n            ? this.invocationFailures.get(failure.error)\n            : undefined;\n        // Before admission (e.g. a meta-copy refusal), no dispatched served entry exists. Count the loss and\n        // apply the failure mode, but never hand the adapter Foottrace's original, unserved entry.\n        if (invocation === undefined) this.lost(failure.error, undefined, this.errorView(failure.error, this.rule));\n        else this.lost(invocation.cause, invocation.entry, invocation.view);\n      },\n    };\n  }\n\n  /** Capture the served entry now; an asynchronous failure keeps this leg's rule, not a later resume's rule. */\n  private invoke(entry: RecordEntry, call: () => unknown, rule: RedactionRule | undefined): unknown {\n    const failed = (cause: unknown): never => {\n      const envelope = new Error('record sink: adapter invocation failed');\n      this.invocationFailures.set(envelope, { entry, cause, view: this.errorView(cause, rule) });\n      throw envelope;\n    };\n    try {\n      const returned = call();\n      // Void adapters keep their synchronous path; only an object/function can be a thenable. settleOnce\n      // observes native promises through Promise.prototype.then and guards hostile thenables too.\n      if (returned === null || (typeof returned !== 'object' && typeof returned !== 'function')) return returned;\n      return settleOnce(returned, () => undefined, failed);\n    } catch (cause) {\n      return failed(cause);\n    }\n  }\n\n  /** A sink error is the diagnostic errors.recordSinkError; raw causes belong only to the caller's exception. */\n  private errorView(error: unknown, rule: RedactionRule | undefined): SinkErrorView {\n    const text = thrownText(error);\n    const retained = rule\n      ? rule.retainStageError(error, text, rule.retainDiagnostic(['errors', 'recordSinkError'], text))\n      : { message: text, structuredError: extractErrorInfo(error) };\n    const served = { ...retained.structuredError };\n    Reflect.deleteProperty(served, 'raw');\n    return {\n      text: retained.message,\n      error: served,\n      masked: retained.message !== text || retained.structuredError.raw !== error,\n      rule,\n    };\n  }\n\n  /**\n   * A same-executor resume starts a new leg on the same record: the counts go on (one log, one record), but the\n   * failure mode is the LEG's — a loss in an earlier leg (which already failed that leg) does not stop this one —\n   * and the dev-mode warning may fire again.\n   */\n  beginLeg(): void {\n    if (this.resolved.onFailure === 'fail') this.stopper = new AbortController();\n    this.failure = undefined;\n    this.warned = false;\n  }\n\n  /** The leg's redaction rule — a resume builds a new one; the next `opened` / `closed` is served under it. */\n  useRule(rule: RedactionRule | undefined): void {\n    this.rule = rule;\n  }\n\n  /** Aborts at the first loss under `onFailure: 'fail'`; absent otherwise. */\n  get stopSignal(): AbortSignal | undefined {\n    return this.stopper?.signal;\n  }\n\n  get flushMode(): RecordSinkFlushMode {\n    return this.resolved.flush;\n  }\n\n  /** The loss that fails the run under `'fail'`; absent while nothing was lost (and always under `'report'`). */\n  get fatal(): RecordSinkError | undefined {\n    return this.failure;\n  }\n\n  stats(): RecordSinkStats {\n    return {\n      entries: this.entries,\n      failed: this.failed,\n      ...(this.lastError === undefined ? {} : { lastError: this.lastError }),\n    };\n  }\n\n  /**\n   * Await the adapter's `flush()`, at most `timeoutMs` when given. A flush that throws or rejects is a loss\n   * (counted, and fatal under `'fail'`); one still running at the deadline is `pending` and keeps running — and,\n   * with `pendingIsLoss` (the run's own flush), counted as a loss too, so a flush that never settles cannot hold a\n   * run open, and cannot pass for one that landed. Nothing here throws: a hostile adapter (a throwing `flush`\n   * getter, a promise with its own `then`) is a loss, never the run's error.\n   */\n  async flush(timeoutMs?: number, pendingIsLoss = false): Promise<RecordFlushResult> {\n    const adapter = this.resolved.adapter;\n    const rule = this.rule;\n    let settled: Promise<RecordFlushResult>;\n    let givenUp = false; // a flush already counted as a loss at the deadline is not counted again when it rejects\n    try {\n      const flush: unknown = adapter.flush; // read once: a getter runs once, inside the guard\n      if (typeof flush !== 'function') return { done: true, failed: false, pending: false };\n      settled = settleOnce(\n        flush.call(adapter),\n        (): RecordFlushResult => ({ done: true, failed: false, pending: false }),\n        (error): RecordFlushResult => {\n          if (!givenUp) this.lost(error, undefined, this.errorView(error, rule));\n          return { done: false, failed: true, pending: false };\n        },\n      );\n    } catch (error) {\n      this.lost(error, undefined, this.errorView(error, rule));\n      return { done: false, failed: true, pending: false };\n    }\n    if (timeoutMs === undefined || !Number.isFinite(timeoutMs)) return settled;\n    let timer: ReturnType<typeof setTimeout> | undefined;\n    const pending = new Promise<RecordFlushResult>((resolve) => {\n      timer = setTimeout(() => resolve({ done: false, failed: false, pending: true }), Math.max(0, timeoutMs));\n    });\n    try {\n      const result = await Promise.race([settled, pending]);\n      if (result.pending && pendingIsLoss) {\n        givenUp = true;\n        const error = new Error(`record sink: flush() did not settle within ${Math.max(0, timeoutMs)}ms`);\n        this.lost(error, undefined, this.errorView(error, rule));\n      }\n      return result;\n    } finally {\n      clearTimeout(timer);\n    }\n  }\n\n  /** The meta as served: a boundary record, scrubbed by key name at every depth (an inert rule copies nothing). */\n  serve(meta: Meta): Meta {\n    return this.rule ? this.rule.retainBoundary(meta, LOG_PLACEHOLDER) : meta;\n  }\n\n  /** One loss: counted, warned once per run, told with a safe dispatched entry when available, fatal under 'fail'. */\n  private lost(error: unknown, entry: RecordEntry | undefined, view: SinkErrorView): void {\n    this.failed += 1;\n    const text = view.text;\n    this.lastError = text;\n    if (isDevMode() && !this.warned) {\n      this.warned = true;\n      // eslint-disable-next-line no-console\n      console.warn(\n        `[footprint] record sink: an entry was not stored (${text}). The run goes on; ` +\n          'getSnapshot().sink counts every loss.',\n      );\n    }\n    // The failure mode first: nothing the adapter's own listener does can skip it.\n    if (this.stopper !== undefined && this.failure === undefined) {\n      this.failure = new RecordSinkError(`record sink: an entry was not stored — ${text}`, error);\n      if (view.masked) {\n        // The caller keeps the real cause, but observers of this new wrapper must inherit its remembered mask.\n        view.rule?.retainStageError(this.failure, this.failure.message, SCOPE_PLACEHOLDER);\n        if (this.rule !== view.rule) this.rule?.retainStageError(this.failure, this.failure.message, SCOPE_PLACEHOLDER);\n      }\n      this.stopper.abort(this.failure);\n    }\n    if (entry !== undefined) tellAdapter(this.resolved.adapter, { entry, error: view.error });\n  }\n}\n\n/** The adapter's own `onFailure`, isolated: a throwing getter, a throw or a rejection there changes nothing. */\nfunction tellAdapter(adapter: RecordSink, failure: { readonly entry: RecordEntry; readonly error: unknown }): void {\n  try {\n    const listener: unknown = adapter.onFailure;\n    if (typeof listener !== 'function') return;\n    settleOnce(\n      listener.call(adapter, failure),\n      () => undefined,\n      () => undefined,\n    );\n  } catch {\n    // A listener that fails is the adapter's own business: the loss is already counted.\n  }\n}\n\n/**\n * `value`, settled ONCE into `onValue` / `onError` — never through the value's own `then`: a native promise is\n * watched through the real `Promise.prototype.then` (an own `then` on it is not trusted, so its rejection is always\n * handled), any other thenable adopted into a fresh promise. A plain value is a fulfilment.\n */\nfunction settleOnce<T>(value: unknown, onValue: () => T, onError: (error: unknown) => T): Promise<T> {\n  const adopted: Promise<unknown> = value instanceof Promise ? value : new Promise((resolve) => resolve(value));\n  return Promise.prototype.then.call(adopted, onValue, onError) as Promise<T>;\n}\n"]}

package/dist/lib/runner/resume.js

@@ -21,6 +21,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.announceResume = exports.seedCounters = exports.planResume = void 0;
 const foottrace_1 = require("foottrace");
+const effect_js_1 = require("../attempt/effect.js");
 const ResumeEntry_js_1 = require("../engine/handlers/ResumeEntry.js");
 const traversalContext_js_1 = require("../engine/traversalContext.js");
 const interrupt_js_1 = require("../pause/interrupt.js");
@@ -60,6 +61,17 @@ function planResume(fc, stored, resumeInput) {
         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.');
     }
+    // A keyless touching stage is never re-run (P3) — a checkpoint from another version of the chart included.
+    const rerunRefusal = isInterruptResume ? (0, effect_js_1.interruptProblem)(pausedNode.touches) : undefined;
+    if (rerunRefusal !== undefined) {
+        throw new Error(`Cannot resume: stage '${pausedNode.name}' (${pausedNode.id}) ${rerunRefusal}`);
+    }
+    // A carried key is adopted only by a stage that declares a key rule (P3): a checkpoint must not hand a key to a
+    // stage that makes none — a key replayed into another operation. Named by field, never quoted.
+    if (checkpoint.idempotencyKey !== undefined && pausedNode.touches?.idempotencyKey === undefined) {
+        throw new Error(`Cannot resume: the checkpoint carries an idempotencyKey, but stage '${pausedNode.name}' (${pausedNode.id}) ` +
+            'declares no idempotency key rule — the chart may have changed since the checkpoint was created.');
+    }
     const resumeStageFn = resumeHalfOf(fc, pausedNode, isInterruptResume, 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
@@ -74,6 +86,12 @@ function planResume(fc, stored, resumeInput) {
     // own `next`, else its dispatcher's continuation — is attached by
     // `ResumeEntry.plan`, from the chart.
     const standIn = standInFor(pausedNode, resumeStageFn, isInterruptResume);
+    // A touching stage resumes under the key it paused under (P3), carried by the checkpoint — never one its rule
+    // would recompute from this leg's input (the input does not cross a resume).
+    // The key is the operational value only: served under the run's rule like a key of unknown sources.
+    const carriedKey = checkpoint.idempotencyKey;
+    if (standIn.touches && carriedKey !== undefined)
+        standIn.touches = (0, effect_js_1.carriedTouches)(standIn.touches.system, carriedKey);
     // Where the resume re-enters, planned against the chart as built:
     //
     //   • TOP-LEVEL PAUSE (subflowPath empty): the resumed traversal starts
@@ -156,7 +174,7 @@ exports.seedCounters = seedCounters;
  */
 function announceResume(plan, resumeInput, run) {
     const { checkpoint, pausedNode, entry } = plan;
-    const { observers } = run;
+    const { observers, correlation } = run;
     const hasInput = resumeInput !== undefined;
     const stepsBeforeStandIn = entry.stepsBeforeStandIn ?? checkpoint.subflowPath.length;
     const resumeRuntimeStageId = (0, foottrace_1.buildRuntimeStageId)(pausedNode.id, run.executionCount + stepsBeforeStandIn);
@@ -172,6 +190,7 @@ function announceResume(plan, resumeInput, run) {
             runtimeStageId: resumeRuntimeStageId,
             subflowPath: checkpoint.subflowPath,
             resumedFrom,
+            correlation,
         }),
         channel: 'flow',
     };
@@ -187,6 +206,7 @@ function announceResume(plan, resumeInput, run) {
         pipelineId: '',
         timestamp: Date.now(),
         channel: 'scope',
+        ...(correlation && { correlation }),
     };
     (0, hooks_js_1.fire)(observers.scopeRecorders, 'onResume', scopeResumeEvent, (error, _recorder, hook) => 
     // The scope channel's policy (as `ScopeFacade` routes a stage's hook failure): the throw
@@ -304,4 +324,4 @@ function dfsFind(node, targetId, visited = new Set()) {
         return dfsFind(node.next, targetId, visited);
     return undefined;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resume.js","sourceRoot":"","sources":["../../../src/lib/runner/resume.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;GAkBG;;;AAEH,yCAAgD;AAGhD,sEAAgE;AAEhE,uEAAuE;AAEvE,wDAA+D;AAC/D,kDAAsD;AAEtD,gDAAsD;AACtD,mDAAiF;AAajF,mGAAmG;AACnG,MAAM,mBAAmB,GAAG,IAAA,wBAAa,EAAC,mBAAmB,CAAC,CAAC;AAE/D;;;;GAIG;AACH,SAAgB,UAAU,CACxB,EAA2B,EAC3B,MAA2B,EAC3B,WAAoB;IAEpB,wEAAwE;IACxE,uEAAuE;IACvE,MAAM,UAAU,GAAG,IAAA,4BAAgB,EAAC,MAAM,CAAC,CAAC;IAE5C,MAAM,UAAU,GAAG,eAAe,CAAC,EAAE,EAAE,UAAU,CAAC,aAAa,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC;IACzF,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,MAAM,IAAI,KAAK,CACb,yBAAyB,UAAU,CAAC,aAAa,4BAA4B;YAC3E,8DAA8D,CACjE,CAAC;IACJ,CAAC;IACD,2DAA2D;IAC3D,EAAE;IACF,uEAAuE;IACvE,4EAA4E;IAC5E,0EAA0E;IAC1E,4EAA4E;IAC5E,yEAAyE;IACzE,0DAA0D;IAC1D,yDAAyD;IACzD,EAAE;IACF,sEAAsE;IACtE,8EAA8E;IAC9E,MAAM,iBAAiB,GAAG,UAAU,CAAC,QAAQ,KAAK,WAAW,CAAC;IAC9D,IAAI,CAAC,UAAU,CAAC,QAAQ,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAC/C,MAAM,IAAI,KAAK,CACb,yBAAyB,UAAU,CAAC,IAAI,MAAM,UAAU,CAAC,EAAE,qBAAqB;YAC9E,wGAAwG,CAC3G,CAAC;IACJ,CAAC;IACD,MAAM,aAAa,GAAG,YAAY,CAAC,EAAE,EAAE,UAAU,EAAE,iBAAiB,EAAE,WAAW,CAAC,CAAC;IAEnF,gEAAgE;IAChE,0EAA0E;IAC1E,0EAA0E;IAC1E,2EAA2E;IAC3E,2EAA2E;IAC3E,0EAA0E;IAC1E,kEAAkE;IAClE,wEAAwE;IACxE,qEAAqE;IACrE,wEAAwE;IACxE,kEAAkE;IAClE,sCAAsC;IACtC,MAAM,OAAO,GAAG,UAAU,CAAC,UAAU,EAAE,aAAa,EAAE,iBAAiB,CAAC,CAAC;IAEzE,kEAAkE;IAClE,EAAE;IACF,wEAAwE;IACxE,uBAAuB;IACvB,yEAAyE;IACzE,sEAAsE;IACtE,yEAAyE;IACzE,iEAAiE;IACjE,yEAAyE;IACzE,0EAA0E;IAC1E,iDAAiD;IACjD,0EAA0E;IAC1E,wEAAwE;IACxE,wEAAwE;IACxE,uDAAuD;IACvD,gEAAgE;IAChE,wEAAwE;IACxE,mDAAmD;IACnD,EAAE;IACF,wEAAwE;IACxE,sEAAsE;IACtE,yEAAyE;IACzE,wEAAwE;IACxE,cAAc;IACd,EAAE;IACF,wEAAwE;IACxE,qEAAqE;IACrE,0EAA0E;IAC1E,wEAAwE;IACxE,kEAAkE;IAClE,sBAAsB;IACtB,MAAM,KAAK,GAAG,4BAAW,CAAC,IAAI,CAAe;QAC3C,IAAI,EAAE,EAAE,CAAC,IAAI;QACb,QAAQ,EAAE,EAAE,CAAC,QAAQ;QACrB,IAAI,EAAE,UAAU,CAAC,WAAW;QAC5B,QAAQ,EAAE,eAAe,CAAC,UAAU,CAAC,aAAa,CAAC;QACnD,OAAO;QACP,GAAG,CAAC,UAAU,CAAC,aAAa,KAAK,SAAS,IAAI,EAAE,aAAa,EAAE,eAAe,CAAC,UAAU,CAAC,aAAa,CAAC,EAAE,CAAC;KAC5G,CAAC,CAAC;IACH,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC;AAC3C,CAAC;AA3FD,gCA2FC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,YAAY,CAC1B,UAA+B,EAC/B,gBAAmC,EACnC,WAAgC;IAEhC,IAAI,UAAU,CAAC,cAAc,KAAK,SAAS,EAAE,CAAC;QAC5C,gBAAgB,CAAC,KAAK,GAAG,UAAU,CAAC,cAAc,CAAC;IACrD,CAAC;IACD,IAAI,UAAU,CAAC,WAAW,EAAE,CAAC;QAC3B,WAAW,CAAC,KAAK,EAAE,CAAC;QACpB,KAAK,MAAM,CAAC,OAAO,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,EAAE,CAAC;YACtE,WAAW,CAAC,GAAG,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAClC,CAAC;IACH,CAAC;AACH,CAAC;AAdD,oCAcC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,cAAc,CAC5B,IAA8B,EAC9B,WAAoB,EACpB,GAAkG;IAElG,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC;IAC/C,MAAM,EAAE,SAAS,EAAE,GAAG,GAAG,CAAC;IAC1B,MAAM,QAAQ,GAAG,WAAW,KAAK,SAAS,CAAC;IAC3C,MAAM,kBAAkB,GAAG,KAAK,CAAC,kBAAkB,IAAI,UAAU,CAAC,WAAW,CAAC,MAAM,CAAC;IACrF,MAAM,oBAAoB,GAAG,IAAA,+BAAmB,EAAC,UAAU,CAAC,EAAE,EAAE,GAAG,CAAC,cAAc,GAAG,kBAAkB,CAAC,CAAC;IACzG,MAAM,WAAW,GAAG,YAAY,CAAC,UAAU,CAAC,CAAC;IAC7C,MAAM,eAAe,GAAG;QACtB,SAAS,EAAE,UAAU,CAAC,IAAI;QAC1B,OAAO,EAAE,UAAU,CAAC,EAAE;QACtB,QAAQ;QACR,gBAAgB,EAAE,IAAA,4CAAsB,EAAC;YACvC,KAAK,EAAE,GAAG,CAAC,KAAK;YAChB,OAAO,EAAE,UAAU,CAAC,EAAE;YACtB,SAAS,EAAE,UAAU,CAAC,IAAI;YAC1B,cAAc,EAAE,oBAAoB;YACpC,WAAW,EAAE,UAAU,CAAC,WAAW;YACnC,WAAW;SACZ,CAAC;QACF,OAAO,EAAE,MAAe;KACzB,CAAC;IACF,6FAA6F;IAC7F,0FAA0F;IAC1F,IAAA,eAAI,EAAC,SAAS,CAAC,mBAAmB,EAAE,EAAE,UAAU,EAAE,eAAe,EAAE,mBAAmB,CAAC,CAAC;IAExF,MAAM,gBAAgB,GAAG;QACvB,SAAS,EAAE,UAAU,CAAC,IAAI;QAC1B,OAAO,EAAE,UAAU,CAAC,EAAE;QACtB,cAAc,EAAE,oBAAoB;QACpC,QAAQ;QACR,GAAG,CAAC,WAAW,IAAI,EAAE,WAAW,EAAE,CAAC;QACnC,UAAU,EAAE,EAAE;QACd,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;QACrB,OAAO,EAAE,OAAgB;KAC1B,CAAC;IACF,IAAA,eAAI,EAAC,SAAS,CAAC,cAAc,EAAE,UAAU,EAAE,gBAAgB,EAAE,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE;IACtF,yFAAyF;IACzF,4EAA4E;IAC5E,IAAA,eAAI,EAAC,SAAS,CAAC,cAAc,EAAE,SAAS,EAAE,IAAA,+BAAoB,EAAC,gBAAgB,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,CAC/F,CAAC;IAEF,sEAAsE;IACtE,iEAAiE;IACjE,IAAI,SAAS,CAAC,YAAY,EAAE,CAAC;QAC3B,SAAS,CAAC,YAAY,CAAC,OAAO,CAAC,MAAM,EAAE,UAAU,EAAE,oBAAoB,EAAE,GAAG,CAAC,KAAK,EAAE,eAAe,CAAC,CAAC;QACrG,SAAS,CAAC,YAAY,CAAC,OAAO,CAC5B,OAAO,EACP,UAAU,EACV,gBAAgB,CAAC,cAAc,EAC/B,gBAAgB,CAAC,UAAU,EAC3B,gBAAgB,CACjB,CAAC;IACJ,CAAC;AACH,CAAC;AAzDD,wCAyDC;AAED;;;;;;GAMG;AACH,SAAS,YAAY,CACnB,EAA2B,EAC3B,UAAmC,EACnC,iBAA0B,EAC1B,WAAoB;IAEpB,IAAI,iBAAiB,EAAE,CAAC;QACtB,MAAM,UAAU,GAAG,UAAU,CAAC,EAAE,IAAI,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QACvG,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,MAAM,IAAI,KAAK,CACb,yBAAyB,UAAU,CAAC,IAAI,MAAM,UAAU,CAAC,EAAE,mCAAmC;gBAC5F,4FAA4F;gBAC5F,cAAc,CACjB,CAAC;QACJ,CAAC;QACD,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,EAAE;YACxC,IAAA,qCAAsB,EAAC,KAAK,EAAE,WAAW,CAAC,CAAC;YAC3C,OAAO,UAAU,CAAC,KAAK,EAAE,OAAO,EAAE,cAAc,CAAC,CAAC;QACpD,CAAC,CAAC;IACJ,CAAC;IACD,MAAM,QAAQ,GAAG,UAAU,CAAC,QAAS,CAAC;IACtC,OAAO,CAAC,KAAa,EAAE,EAAE;QACvB,OAAO,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAyB,CAAC;IAC9D,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAS,UAAU,CACjB,UAAmC,EACnC,EAA+B,EAC/B,iBAA0B;IAE1B,MAAM,OAAO,GAA4B,EAAE,GAAG,UAAU,EAAE,EAAE,EAAE,CAAC;IAC/D,OAAO,OAAO,CAAC,QAAQ,CAAC;IACxB,OAAO,OAAO,CAAC,UAAU,CAAC;IAC1B,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACvB,OAAO,OAAO,CAAC,KAAK,CAAC;QACrB,OAAO,OAAO,CAAC,WAAW,CAAC;QAC3B,OAAO,OAAO,CAAC,QAAQ,CAAC;IAC1B,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;GAMG;AACH,SAAS,YAAY,CAAC,UAA+B;IACnD,MAAM,MAAM,GAAY,UAAU,CAAC,eAAe,CAAC;IACnD,OAAO,IAAA,4BAAiB,EAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,cAAc,EAAE,MAAM,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;AAChH,CAAC;AAED;;;GAGG;AACH,SAAS,eAAe,CACtB,EAA2B,EAC3B,OAAe,EACf,WAA8B;IAE9B,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAC/D,IAAI,WAAgD,CAAC;IACrD,KAAK,MAAM,IAAI,IAAI,WAAW,EAAE,CAAC;QAC/B,MAAM,OAAO,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,CAAC;QACpC,IAAI,CAAC,OAAO;YAAE,OAAO,SAAS,CAAC;QAC/B,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAC7B,CAAC;IACD,IAAI,CAAC,WAAW;QAAE,OAAO,SAAS,CAAC;IACnC,OAAO,OAAO,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;AACvC,CAAC;AAED,sFAAsF;AACtF,SAAS,OAAO,CACd,IAA6B,EAC7B,QAAgB,EAChB,UAAU,IAAI,GAAG,EAAU;IAE3B,sFAAsF;IACtF,IAAI,IAAI,CAAC,SAAS;QAAE,OAAO,SAAS,CAAC;IACrC,IAAI,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAAE,OAAO,SAAS,CAAC;IAC3C,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACrB,IAAI,IAAI,CAAC,EAAE,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC;IACtC,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;QAClB,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAClC,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;YAChD,IAAI,KAAK;gBAAE,OAAO,KAAK,CAAC;QAC1B,CAAC;IACH,CAAC;IACD,IAAI,IAAI,CAAC,IAAI;QAAE,OAAO,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC5D,OAAO,SAAS,CAAC;AACnB,CAAC","sourcesContent":["/**\n * resume — how `FlowChartExecutor.resume()` plans and announces a re-entry (F9).\n *\n * Three steps, in the order the executor takes them:\n *\n *   1. {@link planResume} — decode the checkpoint (the ONE codec,\n *      `pause/record.ts`), find the paused stage in the chart as built, build\n *      the resume half and the paused stage's stand-in, and plan the one-shot\n *      re-entry (`ResumeEntry.plan`). Every refusal happens HERE, before any\n *      executor state is touched.\n *   2. {@link seedCounters} — carry the pause-time execution counter and visit\n *      counts into the run's shared counters (mutated, never replaced).\n *   3. {@link announceResume} — fire the executor-made `onResume` on the flow\n *      and scope channels (and capture it for the deferred tier), BEFORE the\n *      traversal so it precedes `onRunStart`.\n *\n * The executor owns the per-run state between the steps (the runId, the\n * runtime, the traverser); this module never holds any.\n */\n\nimport { buildRuntimeStageId } from 'foottrace';\n\nimport type { FlowChart } from '../builder/types.js';\nimport { ResumeEntry } from '../engine/handlers/ResumeEntry.js';\nimport type { ResumeLink } from '../engine/narrative/types.js';\nimport { resumeTraversalContext } from '../engine/traversalContext.js';\nimport type { StageFunction, StageNode } from '../engine/types.js';\nimport { provideInterruptAnswer } from '../pause/interrupt.js';\nimport { decodeCheckpoint } from '../pause/record.js';\nimport type { FlowchartCheckpoint } from '../pause/types.js';\nimport { isPausedExecution } from '../pause/types.js';\nimport { fire, recorderFailureEvent, warnInDevMode } from '../recorder/hooks.js';\nimport type { RunObservers } from './attach.js';\n\n/** Everything a resume decided before any executor state was touched. */\nexport interface ResumePlan<TOut, TScope> {\n  /** The decoded checkpoint (upcast and checked). */\n  readonly checkpoint: FlowchartCheckpoint;\n  /** The paused stage's REAL node in the chart. */\n  readonly pausedNode: StageNode<TOut, TScope>;\n  /** Where the resumed traversal starts, and what each subflow on the path takes on its first entry. */\n  readonly entry: ResumeEntry<TOut, TScope>;\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 * Plan the resume against the chart as built. Throws — leaving the executor\n * untouched — when the checkpoint is malformed, the paused stage is gone, it\n * cannot be resumed, or its path does not fit this chart.\n */\nexport function planResume<TOut, TScope>(\n  fc: FlowChart<TOut, TScope>,\n  stored: FlowchartCheckpoint,\n  resumeInput: unknown,\n): ResumePlan<TOut, TScope> {\n  // Decode the checkpoint (may come from untrusted external storage, from\n  // any release) — the ONE codec: upcast, then check every pause record.\n  const checkpoint = decodeCheckpoint(stored);\n\n  const pausedNode = findNodeInGraph(fc, 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  const resumeStageFn = resumeHalfOf(fc, pausedNode, isInterruptResume, resumeInput);\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 entry = 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  return { checkpoint, pausedNode, entry };\n}\n\n/**\n * Seed the run's shared execution counter + per-stage visit counts from the\n * checkpoint, so runtimeStageIds stay unique and loopIteration monotonic\n * across a CROSS-executor resume (a fresh executor starts both at 0/empty).\n *\n * MUTATE, never REPLACE: both are shared by reference into the traverser\n * (and, transitively, every subflow traverser). Both fields are optional on\n * the checkpoint (older persisted checkpoints omit them) — seeding is skipped\n * when absent. Same-executor resume is idempotent: at pause the values\n * already equal the checkpoint's.\n */\nexport function seedCounters(\n  checkpoint: FlowchartCheckpoint,\n  executionCounter: { value: number },\n  visitCounts: Map<string, number>,\n): void {\n  if (checkpoint.executionCount !== undefined) {\n    executionCounter.value = checkpoint.executionCount;\n  }\n  if (checkpoint.visitCounts) {\n    visitCounts.clear();\n    for (const [stageId, count] of Object.entries(checkpoint.visitCounts)) {\n      visitCounts.set(stageId, count);\n    }\n  }\n}\n\n/**\n * Fire the executor-made `onResume` on every recorder (flow + scope), stamped\n * with the resumed leg's NEW runId — consumers detect \"a fresh logical run\"\n * by the same runId change they use for `onRunStart`. The stamp is built by\n * the one constructor (`engine/traversalContext.ts`): it names the REAL\n * 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 is\n * the counter plus the path's length — the event and the stand-in's commit\n * name the same execution. The one shape where the index cannot be known up\n * front — a degraded checkpoint missing an OUTER subflow's capture, whose\n * opening stages then re-run — names the planned position.\n */\nexport function announceResume<TOut, TScope>(\n  plan: ResumePlan<TOut, TScope>,\n  resumeInput: unknown,\n  run: { readonly runId: string; readonly executionCount: number; readonly observers: RunObservers },\n): void {\n  const { checkpoint, pausedNode, entry } = plan;\n  const { observers } = run;\n  const hasInput = resumeInput !== undefined;\n  const stepsBeforeStandIn = entry.stepsBeforeStandIn ?? checkpoint.subflowPath.length;\n  const resumeRuntimeStageId = buildRuntimeStageId(pausedNode.id, run.executionCount + stepsBeforeStandIn);\n  const resumedFrom = resumeLinkOf(checkpoint);\n  const flowResumeEvent = {\n    stageName: pausedNode.name,\n    stageId: pausedNode.id,\n    hasInput,\n    traversalContext: resumeTraversalContext({\n      runId: run.runId,\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  fire(observers.inlineFlowListeners(), '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(observers.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(observers.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 (observers.deferredTier) {\n    observers.deferredTier.capture('flow', 'onResume', resumeRuntimeStageId, run.runId, flowResumeEvent);\n    observers.deferredTier.capture(\n      'scope',\n      'onResume',\n      scopeResumeEvent.runtimeStageId,\n      scopeResumeEvent.pipelineId,\n      scopeResumeEvent,\n    );\n  }\n}\n\n/**\n * The resume half — what the paused stage's stand-in runs. `interrupt()`:\n * the stage's own function, with the answer deposited for THIS scope first\n * (keyed by scope identity — safe when several branches resume at once).\n * `addPausableFunction`: the declared `resumeFn(scope, input)`, wrapped to\n * the `StageFunction` shape.\n */\nfunction resumeHalfOf<TOut, TScope>(\n  fc: FlowChart<TOut, TScope>,\n  pausedNode: StageNode<TOut, TScope>,\n  isInterruptResume: boolean,\n  resumeInput: unknown,\n): StageFunction<TOut, TScope> {\n  if (isInterruptResume) {\n    const originalFn = pausedNode.fn ?? fc.stageMap.get(pausedNode.id) ?? fc.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    return (scope, breakFn, streamCallback) => {\n      provideInterruptAnswer(scope, resumeInput);\n      return originalFn(scope, breakFn, streamCallback);\n    };\n  }\n  const resumeFn = pausedNode.resumeFn!;\n  return (scope: TScope) => {\n    return resumeFn(scope, resumeInput) as TOut | Promise<TOut>;\n  };\n}\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/**\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 * Find a StageNode in the compiled graph by ID, drilling into registered\n * subflows along `subflowPath` and searching from the last subflow's root.\n */\nfunction findNodeInGraph<TOut, TScope>(\n  fc: FlowChart<TOut, TScope>,\n  stageId: string,\n  subflowPath: readonly string[],\n): StageNode<TOut, TScope> | undefined {\n  if (subflowPath.length === 0) return dfsFind(fc.root, stageId);\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 dfsFind(subflowRoot, stageId);\n}\n\n/** DFS search for a node by ID in the StageNode graph. Cycle-safe via visited set. */\nfunction dfsFind<TOut, TScope>(\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 = dfsFind(child, targetId, visited);\n      if (found) return found;\n    }\n  }\n  if (node.next) return dfsFind(node.next, targetId, visited);\n  return undefined;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resume.js","sourceRoot":"","sources":["../../../src/lib/runner/resume.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * resume — how `FlowChartExecutor.resume()` plans and announces a re-entry (F9).\n *\n * Three steps, in the order the executor takes them:\n *\n *   1. {@link planResume} — decode the checkpoint (the ONE codec,\n *      `pause/record.ts`), find the paused stage in the chart as built, build\n *      the resume half and the paused stage's stand-in, and plan the one-shot\n *      re-entry (`ResumeEntry.plan`). Every refusal happens HERE, before any\n *      executor state is touched.\n *   2. {@link seedCounters} — carry the pause-time execution counter and visit\n *      counts into the run's shared counters (mutated, never replaced).\n *   3. {@link announceResume} — fire the executor-made `onResume` on the flow\n *      and scope channels (and capture it for the deferred tier), BEFORE the\n *      traversal so it precedes `onRunStart`.\n *\n * The executor owns the per-run state between the steps (the runId, the\n * runtime, the traverser); this module never holds any.\n */\n\nimport { buildRuntimeStageId } from 'foottrace';\n\nimport { carriedTouches, interruptProblem } from '../attempt/effect.js';\nimport type { RunCorrelation } from '../attempt/types.js';\nimport type { FlowChart } from '../builder/types.js';\nimport { ResumeEntry } from '../engine/handlers/ResumeEntry.js';\nimport type { ResumeLink } from '../engine/narrative/types.js';\nimport { resumeTraversalContext } from '../engine/traversalContext.js';\nimport type { StageFunction, StageNode } from '../engine/types.js';\nimport { provideInterruptAnswer } from '../pause/interrupt.js';\nimport { decodeCheckpoint } from '../pause/record.js';\nimport type { FlowchartCheckpoint } from '../pause/types.js';\nimport { isPausedExecution } from '../pause/types.js';\nimport { fire, recorderFailureEvent, warnInDevMode } from '../recorder/hooks.js';\nimport type { RunObservers } from './attach.js';\n\n/** Everything a resume decided before any executor state was touched. */\nexport interface ResumePlan<TOut, TScope> {\n  /** The decoded checkpoint (upcast and checked). */\n  readonly checkpoint: FlowchartCheckpoint;\n  /** The paused stage's REAL node in the chart. */\n  readonly pausedNode: StageNode<TOut, TScope>;\n  /** Where the resumed traversal starts, and what each subflow on the path takes on its first entry. */\n  readonly entry: ResumeEntry<TOut, TScope>;\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 * Plan the resume against the chart as built. Throws — leaving the executor\n * untouched — when the checkpoint is malformed, the paused stage is gone, it\n * cannot be resumed, or its path does not fit this chart.\n */\nexport function planResume<TOut, TScope>(\n  fc: FlowChart<TOut, TScope>,\n  stored: FlowchartCheckpoint,\n  resumeInput: unknown,\n): ResumePlan<TOut, TScope> {\n  // Decode the checkpoint (may come from untrusted external storage, from\n  // any release) — the ONE codec: upcast, then check every pause record.\n  const checkpoint = decodeCheckpoint(stored);\n\n  const pausedNode = findNodeInGraph(fc, 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  // A keyless touching stage is never re-run (P3) — a checkpoint from another version of the chart included.\n  const rerunRefusal = isInterruptResume ? interruptProblem(pausedNode.touches) : undefined;\n  if (rerunRefusal !== undefined) {\n    throw new Error(`Cannot resume: stage '${pausedNode.name}' (${pausedNode.id}) ${rerunRefusal}`);\n  }\n  // A carried key is adopted only by a stage that declares a key rule (P3): a checkpoint must not hand a key to a\n  // stage that makes none — a key replayed into another operation. Named by field, never quoted.\n  if (checkpoint.idempotencyKey !== undefined && pausedNode.touches?.idempotencyKey === undefined) {\n    throw new Error(\n      `Cannot resume: the checkpoint carries an idempotencyKey, but stage '${pausedNode.name}' (${pausedNode.id}) ` +\n        'declares no idempotency key rule — the chart may have changed since the checkpoint was created.',\n    );\n  }\n  const resumeStageFn = resumeHalfOf(fc, pausedNode, isInterruptResume, resumeInput);\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  // A touching stage resumes under the key it paused under (P3), carried by the checkpoint — never one its rule\n  // would recompute from this leg's input (the input does not cross a resume).\n  // The key is the operational value only: served under the run's rule like a key of unknown sources.\n  const carriedKey = checkpoint.idempotencyKey;\n  if (standIn.touches && carriedKey !== undefined) standIn.touches = carriedTouches(standIn.touches.system, carriedKey);\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 entry = 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  return { checkpoint, pausedNode, entry };\n}\n\n/**\n * Seed the run's shared execution counter + per-stage visit counts from the\n * checkpoint, so runtimeStageIds stay unique and loopIteration monotonic\n * across a CROSS-executor resume (a fresh executor starts both at 0/empty).\n *\n * MUTATE, never REPLACE: both are shared by reference into the traverser\n * (and, transitively, every subflow traverser). Both fields are optional on\n * the checkpoint (older persisted checkpoints omit them) — seeding is skipped\n * when absent. Same-executor resume is idempotent: at pause the values\n * already equal the checkpoint's.\n */\nexport function seedCounters(\n  checkpoint: FlowchartCheckpoint,\n  executionCounter: { value: number },\n  visitCounts: Map<string, number>,\n): void {\n  if (checkpoint.executionCount !== undefined) {\n    executionCounter.value = checkpoint.executionCount;\n  }\n  if (checkpoint.visitCounts) {\n    visitCounts.clear();\n    for (const [stageId, count] of Object.entries(checkpoint.visitCounts)) {\n      visitCounts.set(stageId, count);\n    }\n  }\n}\n\n/**\n * Fire the executor-made `onResume` on every recorder (flow + scope), stamped\n * with the resumed leg's NEW runId — consumers detect \"a fresh logical run\"\n * by the same runId change they use for `onRunStart`. The stamp is built by\n * the one constructor (`engine/traversalContext.ts`): it names the REAL\n * 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 is\n * the counter plus the path's length — the event and the stand-in's commit\n * name the same execution. The one shape where the index cannot be known up\n * front — a degraded checkpoint missing an OUTER subflow's capture, whose\n * opening stages then re-run — names the planned position.\n */\nexport function announceResume<TOut, TScope>(\n  plan: ResumePlan<TOut, TScope>,\n  resumeInput: unknown,\n  run: {\n    readonly runId: string;\n    readonly executionCount: number;\n    readonly observers: RunObservers;\n    /** The RESUMED leg's correlation (from `resume()`'s env) — on both events, like every event of the leg. */\n    readonly correlation?: RunCorrelation;\n  },\n): void {\n  const { checkpoint, pausedNode, entry } = plan;\n  const { observers, correlation } = run;\n  const hasInput = resumeInput !== undefined;\n  const stepsBeforeStandIn = entry.stepsBeforeStandIn ?? checkpoint.subflowPath.length;\n  const resumeRuntimeStageId = buildRuntimeStageId(pausedNode.id, run.executionCount + stepsBeforeStandIn);\n  const resumedFrom = resumeLinkOf(checkpoint);\n  const flowResumeEvent = {\n    stageName: pausedNode.name,\n    stageId: pausedNode.id,\n    hasInput,\n    traversalContext: resumeTraversalContext({\n      runId: run.runId,\n      stageId: pausedNode.id,\n      stageName: pausedNode.name,\n      runtimeStageId: resumeRuntimeStageId,\n      subflowPath: checkpoint.subflowPath,\n      resumedFrom,\n      correlation,\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  fire(observers.inlineFlowListeners(), '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    ...(correlation && { correlation }),\n  };\n  fire(observers.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(observers.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 (observers.deferredTier) {\n    observers.deferredTier.capture('flow', 'onResume', resumeRuntimeStageId, run.runId, flowResumeEvent);\n    observers.deferredTier.capture(\n      'scope',\n      'onResume',\n      scopeResumeEvent.runtimeStageId,\n      scopeResumeEvent.pipelineId,\n      scopeResumeEvent,\n    );\n  }\n}\n\n/**\n * The resume half — what the paused stage's stand-in runs. `interrupt()`:\n * the stage's own function, with the answer deposited for THIS scope first\n * (keyed by scope identity — safe when several branches resume at once).\n * `addPausableFunction`: the declared `resumeFn(scope, input)`, wrapped to\n * the `StageFunction` shape.\n */\nfunction resumeHalfOf<TOut, TScope>(\n  fc: FlowChart<TOut, TScope>,\n  pausedNode: StageNode<TOut, TScope>,\n  isInterruptResume: boolean,\n  resumeInput: unknown,\n): StageFunction<TOut, TScope> {\n  if (isInterruptResume) {\n    const originalFn = pausedNode.fn ?? fc.stageMap.get(pausedNode.id) ?? fc.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    return (scope, breakFn, streamCallback) => {\n      provideInterruptAnswer(scope, resumeInput);\n      return originalFn(scope, breakFn, streamCallback);\n    };\n  }\n  const resumeFn = pausedNode.resumeFn!;\n  return (scope: TScope) => {\n    return resumeFn(scope, resumeInput) as TOut | Promise<TOut>;\n  };\n}\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/**\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 * Find a StageNode in the compiled graph by ID, drilling into registered\n * subflows along `subflowPath` and searching from the last subflow's root.\n */\nfunction findNodeInGraph<TOut, TScope>(\n  fc: FlowChart<TOut, TScope>,\n  stageId: string,\n  subflowPath: readonly string[],\n): StageNode<TOut, TScope> | undefined {\n  if (subflowPath.length === 0) return dfsFind(fc.root, stageId);\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 dfsFind(subflowRoot, stageId);\n}\n\n/** DFS search for a node by ID in the StageNode graph. Cycle-safe via visited set. */\nfunction dfsFind<TOut, TScope>(\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 = dfsFind(child, targetId, visited);\n      if (found) return found;\n    }\n  }\n  if (node.next) return dfsFind(node.next, targetId, visited);\n  return undefined;\n}\n"]}