footprintjs 10.2.1 → 10.4.0

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

@@ -0,0 +1,36 @@
+import { readStoredRecord } from 'foottrace';
+import { copyHistoryData, HistoryDataError } from '../capture/historyData.js';
+import { admitStoredCapture } from './storedCaptureAdmission.js';
+/** Only inert bounded data reaches the generic record reader. The outer iterable remains host-owned. */
+function* inertEntries(entries, maxBytes) {
+    let remaining = maxBytes * 4;
+    for (const entry of entries) {
+        const copied = copyHistoryData(entry, remaining);
+        remaining -= new TextEncoder().encode(JSON.stringify(copied)).length;
+        yield copied;
+    }
+}
+/**
+ * Read authorized stored entries using Foottrace's sequence/gap checks, then validate FootPrint's opaque metadata.
+ * A receipt is a host-adapter assertion, not a signature. Callers still own storage authorization and trust.
+ * Never performs causal analysis or upgrades partial native capture to complete.
+ */
+export async function readStoredCapture(entries, options) {
+    const unknown = (reason) => ({ status: 'unknown', reason });
+    try {
+        const maxBytes = options.maxBytes ?? 1024 * 1024;
+        if (!Number.isSafeInteger(maxBytes) || maxBytes < 1 || maxBytes > 8 * 1024 * 1024)
+            return unknown('reader-limit');
+        const stored = readStoredRecord(inertEntries(entries, maxBytes), options.limits);
+        const log = stored.root(options.runId);
+        if (!log)
+            return unknown('root-missing');
+        if (!log.complete || log.gaps.length || stored.unread.length)
+            return unknown('history-incomplete');
+        return await admitStoredCapture(log, options.runId, maxBytes);
+    }
+    catch (error) {
+        return unknown(error instanceof HistoryDataError && error.code === 'too-large' ? 'history-too-large' : 'history-refused');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVhZFN0b3JlZENhcHR1cmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3J1bm5lci9yZWFkU3RvcmVkQ2FwdHVyZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFFN0MsT0FBTyxFQUFFLGVBQWUsRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBSzlFLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBc0JqRSx3R0FBd0c7QUFDeEcsUUFBUSxDQUFDLENBQUMsWUFBWSxDQUFDLE9BQTBCLEVBQUUsUUFBZ0I7SUFDakUsSUFBSSxTQUFTLEdBQUcsUUFBUSxHQUFHLENBQUMsQ0FBQztJQUM3QixLQUFLLE1BQU0sS0FBSyxJQUFJLE9BQU8sRUFBRSxDQUFDO1FBQzVCLE1BQU0sTUFBTSxHQUFHLGVBQWUsQ0FBQyxLQUFLLEVBQUUsU0FBUyxDQUFDLENBQUM7UUFDakQsU0FBUyxJQUFJLElBQUksV0FBVyxFQUFFLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUM7UUFDckUsTUFBTSxNQUFNLENBQUM7SUFDZixDQUFDO0FBQ0gsQ0FBQztBQUVEOzs7O0dBSUc7QUFDSCxNQUFNLENBQUMsS0FBSyxVQUFVLGlCQUFpQixDQUNyQyxPQUEwQixFQUMxQixPQUEwRTtJQUUxRSxNQUFNLE9BQU8sR0FBRyxDQUFDLE1BQWMsRUFBdUIsRUFBRSxDQUFDLENBQUMsRUFBRSxNQUFNLEVBQUUsU0FBUyxFQUFFLE1BQU0sRUFBRSxDQUFDLENBQUM7SUFDekYsSUFBSSxDQUFDO1FBQ0gsTUFBTSxRQUFRLEdBQUcsT0FBTyxDQUFDLFFBQVEsSUFBSSxJQUFJLEdBQUcsSUFBSSxDQUFDO1FBQ2pELElBQUksQ0FBQyxNQUFNLENBQUMsYUFBYSxDQUFDLFFBQVEsQ0FBQyxJQUFJLFFBQVEsR0FBRyxDQUFDLElBQUksUUFBUSxHQUFHLENBQUMsR0FBRyxJQUFJLEdBQUcsSUFBSTtZQUFFLE9BQU8sT0FBTyxDQUFDLGNBQWMsQ0FBQyxDQUFDO1FBQ2xILE1BQU0sTUFBTSxHQUFHLGdCQUFnQixDQUFDLFlBQVksQ0FBQyxPQUFPLEVBQUUsUUFBUSxDQUFDLEVBQUUsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQ2pGLE1BQU0sR0FBRyxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQ3ZDLElBQUksQ0FBQyxHQUFHO1lBQUUsT0FBTyxPQUFPLENBQUMsY0FBYyxDQUFDLENBQUM7UUFDekMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxRQUFRLElBQUksR0FBRyxDQUFDLElBQUksQ0FBQyxNQUFNLElBQUksTUFBTSxDQUFDLE1BQU0sQ0FBQyxNQUFNO1lBQUUsT0FBTyxPQUFPLENBQUMsb0JBQW9CLENBQUMsQ0FBQztRQUNuRyxPQUFPLE1BQU0sa0JBQWtCLENBQUMsR0FBRyxFQUFFLE9BQU8sQ0FBQyxLQUFLLEVBQUUsUUFBUSxDQUFDLENBQUM7SUFDaEUsQ0FBQztJQUFDLE9BQU8sS0FBSyxFQUFFLENBQUM7UUFDZixPQUFPLE9BQU8sQ0FDWixLQUFLLFlBQVksZ0JBQWdCLElBQUksS0FBSyxDQUFDLElBQUksS0FBSyxXQUFXLENBQUMsQ0FBQyxDQUFDLG1CQUFtQixDQUFDLENBQUMsQ0FBQyxpQkFBaUIsQ0FDMUcsQ0FBQztJQUNKLENBQUM7QUFDSCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBDb21taXRCdW5kbGUsIFN0b3JlZFJlY29yZExpbWl0cyB9IGZyb20gJ2Zvb3R0cmFjZSc7XG5pbXBvcnQgeyByZWFkU3RvcmVkUmVjb3JkIH0gZnJvbSAnZm9vdHRyYWNlJztcblxuaW1wb3J0IHsgY29weUhpc3RvcnlEYXRhLCBIaXN0b3J5RGF0YUVycm9yIH0gZnJvbSAnLi4vY2FwdHVyZS9oaXN0b3J5RGF0YS5qcyc7XG5pbXBvcnQgdHlwZSB7IENhcHR1cmVIaXN0b3J5UmVjZWlwdCB9IGZyb20gJy4uL2NhcHR1cmUvaGlzdG9yeVR5cGVzLmpzJztcbmltcG9ydCB0eXBlIHsgTmF0aXZlQ2FwdHVyZU5vdGUgfSBmcm9tICcuLi9jYXB0dXJlL25hdGl2ZUNvdmVyYWdlLmpzJztcbmltcG9ydCB0eXBlIHsgU3RhZ2VTbmFwc2hvdCB9IGZyb20gJy4uL21lbW9yeS9mcmFtZVR5cGVzLmpzJztcbmltcG9ydCB0eXBlIHsgUmVjb3JkZXJTbmFwc2hvdCB9IGZyb20gJy4vRXhlY3V0aW9uUnVudGltZS5qcyc7XG5pbXBvcnQgeyBhZG1pdFN0b3JlZENhcHR1cmUgfSBmcm9tICcuL3N0b3JlZENhcHR1cmVBZG1pc3Npb24uanMnO1xuXG4vKiogRW5naW5lIGhpc3Rvcnkgd2hvc2Ugc3RvcmFnZSBldmlkZW5jZSBtYXRjaGVkLiBDaGFubmVscyBhbmQgbmF0aXZlIGxpbWl0YXRpb25zIHJldGFpbiB0aGVpciBvcmlnaW5hbCBtZWFuaW5ncy4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgU3RvcmVkQ2FwdHVyZUhpc3Rvcnkge1xuICByZWFkb25seSBydW5JZDogc3RyaW5nO1xuICByZWFkb25seSBjYXB0dXJlOiBOYXRpdmVDYXB0dXJlTm90ZTtcbiAgcmVhZG9ubHkgZXhlY3V0aW9uVHJlZTogU3RhZ2VTbmFwc2hvdDtcbiAgLyoqXG4gICAqIFNvcnRlZCBsaXRlcmFsIHBhdGhzIG9mIG93biB1bmRlZmluZWQgc3RhZ2VSZWFkcy9zdGFnZVdyaXRlcyBlbnRyaWVzIG9taXR0ZWQgYnkgSlNPTi5cbiAgICogUmVhZCBhbG9uZ3NpZGUgZXhlY3V0aW9uVHJlZTsgdGhpcyBpcyBub3QgcHJvb2YgdGhhdCB0aGUgdW5kZXJseWluZyBzdGF0ZSBrZXkgbmV2ZXIgZXhpc3RlZC5cbiAgICogQXQgbW9zdCA0MDk2IHBhdGhzIG9mIDI1NiBzZWdtZW50cywgd2l0aGluIHRoZSBldmlkZW5jZSBieXRlIGxpbWl0LiBObyBlbnRyaWVzIGFyZSB0cnVuY2F0ZWQuXG4gICAqL1xuICByZWFkb25seSBhYnNlbnQ/OiByZWFkb25seSAocmVhZG9ubHkgc3RyaW5nW10pW107XG4gIHJlYWRvbmx5IHJlY29yZGVycz86IHJlYWRvbmx5IFJlY29yZGVyU25hcHNob3RbXTtcbiAgcmVhZG9ubHkgY29tbWl0TG9nOiByZWFkb25seSBDb21taXRCdW5kbGVbXTtcbiAgcmVhZG9ubHkgaW5pdGlhbFN0YXRlPzogUmVjb3JkPHN0cmluZywgdW5rbm93bj47XG4gIHJlYWRvbmx5IHJlY2VpcHQ6IENhcHR1cmVIaXN0b3J5UmVjZWlwdDtcbn1cbmV4cG9ydCB0eXBlIFN0b3JlZENhcHR1cmVSZXN1bHQgPVxuICB8IHsgcmVhZG9ubHkgc3RhdHVzOiAnYWNrbm93bGVkZ2VkJzsgcmVhZG9ubHkgaGlzdG9yeTogU3RvcmVkQ2FwdHVyZUhpc3RvcnkgfVxuICB8IHsgcmVhZG9ubHkgc3RhdHVzOiAndW5rbm93bic7IHJlYWRvbmx5IHJlYXNvbjogc3RyaW5nOyByZWFkb25seSBoaXN0b3J5PzogbmV2ZXIgfTtcblxuLyoqIE9ubHkgaW5lcnQgYm91bmRlZCBkYXRhIHJlYWNoZXMgdGhlIGdlbmVyaWMgcmVjb3JkIHJlYWRlci4gVGhlIG91dGVyIGl0ZXJhYmxlIHJlbWFpbnMgaG9zdC1vd25lZC4gKi9cbmZ1bmN0aW9uKiBpbmVydEVudHJpZXMoZW50cmllczogSXRlcmFibGU8dW5rbm93bj4sIG1heEJ5dGVzOiBudW1iZXIpOiBJdGVyYWJsZTx1bmtub3duPiB7XG4gIGxldCByZW1haW5pbmcgPSBtYXhCeXRlcyAqIDQ7XG4gIGZvciAoY29uc3QgZW50cnkgb2YgZW50cmllcykge1xuICAgIGNvbnN0IGNvcGllZCA9IGNvcHlIaXN0b3J5RGF0YShlbnRyeSwgcmVtYWluaW5nKTtcbiAgICByZW1haW5pbmcgLT0gbmV3IFRleHRFbmNvZGVyKCkuZW5jb2RlKEpTT04uc3RyaW5naWZ5KGNvcGllZCkpLmxlbmd0aDtcbiAgICB5aWVsZCBjb3BpZWQ7XG4gIH1cbn1cblxuLyoqXG4gKiBSZWFkIGF1dGhvcml6ZWQgc3RvcmVkIGVudHJpZXMgdXNpbmcgRm9vdHRyYWNlJ3Mgc2VxdWVuY2UvZ2FwIGNoZWNrcywgdGhlbiB2YWxpZGF0ZSBGb290UHJpbnQncyBvcGFxdWUgbWV0YWRhdGEuXG4gKiBBIHJlY2VpcHQgaXMgYSBob3N0LWFkYXB0ZXIgYXNzZXJ0aW9uLCBub3QgYSBzaWduYXR1cmUuIENhbGxlcnMgc3RpbGwgb3duIHN0b3JhZ2UgYXV0aG9yaXphdGlvbiBhbmQgdHJ1c3QuXG4gKiBOZXZlciBwZXJmb3JtcyBjYXVzYWwgYW5hbHlzaXMgb3IgdXBncmFkZXMgcGFydGlhbCBuYXRpdmUgY2FwdHVyZSB0byBjb21wbGV0ZS5cbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIHJlYWRTdG9yZWRDYXB0dXJlKFxuICBlbnRyaWVzOiBJdGVyYWJsZTx1bmtub3duPixcbiAgb3B0aW9uczogeyBydW5JZDogc3RyaW5nOyBsaW1pdHM/OiBTdG9yZWRSZWNvcmRMaW1pdHM7IG1heEJ5dGVzPzogbnVtYmVyIH0sXG4pOiBQcm9taXNlPFN0b3JlZENhcHR1cmVSZXN1bHQ+IHtcbiAgY29uc3QgdW5rbm93biA9IChyZWFzb246IHN0cmluZyk6IFN0b3JlZENhcHR1cmVSZXN1bHQgPT4gKHsgc3RhdHVzOiAndW5rbm93bicsIHJlYXNvbiB9KTtcbiAgdHJ5IHtcbiAgICBjb25zdCBtYXhCeXRlcyA9IG9wdGlvbnMubWF4Qnl0ZXMgPz8gMTAyNCAqIDEwMjQ7XG4gICAgaWYgKCFOdW1iZXIuaXNTYWZlSW50ZWdlcihtYXhCeXRlcykgfHwgbWF4Qnl0ZXMgPCAxIHx8IG1heEJ5dGVzID4gOCAqIDEwMjQgKiAxMDI0KSByZXR1cm4gdW5rbm93bigncmVhZGVyLWxpbWl0Jyk7XG4gICAgY29uc3Qgc3RvcmVkID0gcmVhZFN0b3JlZFJlY29yZChpbmVydEVudHJpZXMoZW50cmllcywgbWF4Qnl0ZXMpLCBvcHRpb25zLmxpbWl0cyk7XG4gICAgY29uc3QgbG9nID0gc3RvcmVkLnJvb3Qob3B0aW9ucy5ydW5JZCk7XG4gICAgaWYgKCFsb2cpIHJldHVybiB1bmtub3duKCdyb290LW1pc3NpbmcnKTtcbiAgICBpZiAoIWxvZy5jb21wbGV0ZSB8fCBsb2cuZ2Fwcy5sZW5ndGggfHwgc3RvcmVkLnVucmVhZC5sZW5ndGgpIHJldHVybiB1bmtub3duKCdoaXN0b3J5LWluY29tcGxldGUnKTtcbiAgICByZXR1cm4gYXdhaXQgYWRtaXRTdG9yZWRDYXB0dXJlKGxvZywgb3B0aW9ucy5ydW5JZCwgbWF4Qnl0ZXMpO1xuICB9IGNhdGNoIChlcnJvcikge1xuICAgIHJldHVybiB1bmtub3duKFxuICAgICAgZXJyb3IgaW5zdGFuY2VvZiBIaXN0b3J5RGF0YUVycm9yICYmIGVycm9yLmNvZGUgPT09ICd0b28tbGFyZ2UnID8gJ2hpc3RvcnktdG9vLWxhcmdlJyA6ICdoaXN0b3J5LXJlZnVzZWQnLFxuICAgICk7XG4gIH1cbn1cbiJdfQ==

package/dist/esm/lib/runner/recordSink.d.ts

@@ -23,6 +23,7 @@
  */
 import type { Meta } from 'foottrace';
 import type { RecordSink } from 'foottrace/write';
+import type { CaptureHistoryOptions, CaptureHistoryStatus } from '../capture/historyTypes.js';
 import type { RedactionRule } from '../memory/redaction.js';
 import type { RecordSinkStats } from './ExecutionRuntime.js';
 /** What a lost entry does to the run: `'report'` counts it and goes on; `'fail'` fails the run. */
@@ -44,6 +45,8 @@ export interface RecordSinkOptions {
     readonly onFailure?: RecordSinkFailureMode;
     /** `'auto'` (default): `run()` awaits the adapter's `flush()` after the closing entry. `'manual'`: `flushRecord()`. */
     readonly flush?: RecordSinkFlushMode;
+    /** Opt-in capture evidence and explicit host acknowledgement; ordinary flush never implies durability. */
+    readonly capture?: CaptureHistoryOptions;
 }
 /** The executor's `sink` option: an adapter, or {@link RecordSinkOptions}. */
 export type RecordSinkOption = RecordSink | RecordSinkOptions;
@@ -70,6 +73,7 @@ export interface ResolvedRecordSink {
     readonly adapter: RecordSink;
     readonly onFailure: RecordSinkFailureMode;
     readonly flush: RecordSinkFlushMode;
+    readonly capture?: CaptureHistoryOptions;
 }
 /**
  * Resolve the executor's `sink` option, or refuse it with a `TypeError` naming what is wrong — a wiring mistake
@@ -92,6 +96,8 @@ export declare class RunRecord {
     /** Aborted at the first loss under `'fail'` — composed into the leg's signal; fresh per leg ({@link beginLeg}). */
     private stopper?;
     private failure?;
+    private capturePending;
+    private captureStatus?;
     /** Opaque error identities only: no raw entry or adapter error is enumerable on the transport error. */
     private readonly invocationFailures;
     constructor(resolved: ResolvedRecordSink);
@@ -113,6 +119,11 @@ export declare class RunRecord {
     /** The loss that fails the run under `'fail'`; absent while nothing was lost (and always under `'report'`). */
     get fatal(): RecordSinkError | undefined;
     stats(): RecordSinkStats;
+    get captureOptions(): CaptureHistoryOptions | undefined;
+    get pendingCaptureDeliveries(): number;
+    captureResult(result: CaptureHistoryStatus): void;
+    /** Same served seed as opened; a history digest never sees a seeded policy secret. */
+    captureInitialState(state: Record<string, unknown>): Record<string, unknown>;
     /**
      * 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,

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

@@ -53,7 +53,7 @@ export function resolveRecordSink(option) {
     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;
+        const { adapter, onFailure = 'report', flush = 'auto', capture } = option;
         if (!isAdapter(adapter)) {
             throw new TypeError('FlowChartExecutor: sink.adapter must be a RecordSink (opened, commit, note, closed)');
         }
@@ -63,7 +63,25 @@ export function resolveRecordSink(option) {
         if (flush !== 'auto' && flush !== 'manual') {
             throw new TypeError("FlowChartExecutor: sink.flush must be 'auto' or 'manual'");
         }
-        return { adapter, onFailure, flush };
+        if (capture !== undefined) {
+            if (!capture || typeof capture.acknowledge !== 'function')
+                throw new TypeError('sink.capture requires acknowledge');
+            for (const [key, max] of [
+                ['maxBytes', 8 * 1024 * 1024],
+                ['timeoutMs', 30_000],
+            ]) {
+                const value = capture[key];
+                if (value !== undefined && (!Number.isSafeInteger(value) || value < 1 || value > max))
+                    throw new RangeError(`sink.capture.${key} must be a positive whole number at most ${max}`);
+            }
+        }
+        const fixedCapture = capture &&
+            Object.freeze({
+                acknowledge: capture.acknowledge.bind(capture),
+                ...(capture.maxBytes !== undefined && { maxBytes: capture.maxBytes }),
+                ...(capture.timeoutMs !== undefined && { timeoutMs: capture.timeoutMs }),
+            });
+        return { adapter, onFailure, flush, ...(fixedCapture && { capture: fixedCapture }) };
     }
     throw new TypeError('FlowChartExecutor: sink must be a RecordSink (opened, commit, note, closed) or { adapter, onFailure?, flush? }');
 }
@@ -83,6 +101,8 @@ export class RunRecord {
     /** Aborted at the first loss under `'fail'` — composed into the leg's signal; fresh per leg ({@link beginLeg}). */
     stopper;
     failure;
+    capturePending = 0;
+    captureStatus;
     /** Opaque error identities only: no raw entry or adapter error is enumerable on the transport error. */
     invocationFailures = new WeakMap();
     constructor(resolved) {
@@ -143,7 +163,15 @@ export class RunRecord {
             // 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);
+            if (!this.resolved.capture)
+                return settleOnce(returned, () => undefined, failed);
+            this.capturePending++;
+            return settleOnce(returned, () => {
+                this.capturePending--;
+            }, (cause) => {
+                this.capturePending--;
+                return failed(cause);
+            });
         }
         catch (cause) {
             return failed(cause);
@@ -174,6 +202,7 @@ export class RunRecord {
             this.stopper = new AbortController();
         this.failure = undefined;
         this.warned = false;
+        this.captureStatus = undefined;
     }
     /** The leg's redaction rule — a resume builds a new one; the next `opened` / `closed` is served under it. */
     useRule(rule) {
@@ -195,8 +224,22 @@ export class RunRecord {
             entries: this.entries,
             failed: this.failed,
             ...(this.lastError === undefined ? {} : { lastError: this.lastError }),
+            ...(this.captureStatus && { capture: this.captureStatus }),
         };
     }
+    get captureOptions() {
+        return this.resolved.capture;
+    }
+    get pendingCaptureDeliveries() {
+        return this.capturePending;
+    }
+    captureResult(result) {
+        this.captureStatus = Object.freeze(result);
+    }
+    /** Same served seed as opened; a history digest never sees a seeded policy secret. */
+    captureInitialState(state) {
+        return this.rule ? this.rule.retainState(state, LOG_PLACEHOLDER) : state;
+    }
     /**
      * 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,
@@ -293,4 +336,4 @@ 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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recordSink.js","sourceRoot":"","sources":["../../../../src/lib/runner/recordSink.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAIH,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGlD,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEtE,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAyC3D;;;GAGG;AACH,MAAM,OAAO,eAAgB,SAAQ,KAAK;IAEF;IADpB,IAAI,GAAG,iBAAiB,CAAC;IAC3C,YAAY,OAAe,EAAW,KAAc;QAClD,KAAK,CAAC,OAAO,CAAC,CAAC;QADqB,UAAK,GAAL,KAAK,CAAS;IAEpD,CAAC;CACF;AAUD,MAAM,OAAO,GAAG,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAU,CAAC;AAehE,SAAS,SAAS,CAAC,KAAc;IAC/B,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IAC9D,OAAO,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAQ,KAAiC,CAAC,CAAC,CAAC,KAAK,UAAU,CAAC,CAAC;AAC3F,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,iBAAiB,CAAC,MAAe;IAC/C,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IAC3C,IAAI,SAAS,CAAC,MAAM,CAAC;QAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IACtF,IAAI,MAAM,KAAK,IAAI,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,EAAE,CAAC;QACtF,MAAM,EAAE,OAAO,EAAE,SAAS,GAAG,QAAQ,EAAE,KAAK,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,MAAoC,CAAC;QACxG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC;YACxB,MAAM,IAAI,SAAS,CAAC,qFAAqF,CAAC,CAAC;QAC7G,CAAC;QACD,IAAI,SAAS,KAAK,QAAQ,IAAI,SAAS,KAAK,MAAM,EAAE,CAAC;YACnD,MAAM,IAAI,SAAS,CAAC,8DAA8D,CAAC,CAAC;QACtF,CAAC;QACD,IAAI,KAAK,KAAK,MAAM,IAAI,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC3C,MAAM,IAAI,SAAS,CAAC,0DAA0D,CAAC,CAAC;QAClF,CAAC;QACD,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YAC1B,IAAI,CAAC,OAAO,IAAI,OAAO,OAAO,CAAC,WAAW,KAAK,UAAU;gBACvD,MAAM,IAAI,SAAS,CAAC,mCAAmC,CAAC,CAAC;YAC3D,KAAK,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,IAAI;gBACvB,CAAC,UAAU,EAAE,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC;gBAC7B,CAAC,WAAW,EAAE,MAAM,CAAC;aACb,EAAE,CAAC;gBACX,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;gBAC3B,IAAI,KAAK,KAAK,SAAS,IAAI,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI,KAAK,GAAG,GAAG,CAAC;oBACnF,MAAM,IAAI,UAAU,CAAC,gBAAgB,GAAG,4CAA4C,GAAG,EAAE,CAAC,CAAC;YAC/F,CAAC;QACH,CAAC;QACD,MAAM,YAAY,GAChB,OAAO;YACP,MAAM,CAAC,MAAM,CAAC;gBACZ,WAAW,EAAE,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC;gBAC9C,GAAG,CAAC,OAAO,CAAC,QAAQ,KAAK,SAAS,IAAI,EAAE,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAAE,CAAC;gBACrE,GAAG,CAAC,OAAO,CAAC,SAAS,KAAK,SAAS,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC,SAAS,EAAE,CAAC;aACzE,CAAC,CAAC;QACL,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,GAAG,CAAC,YAAY,IAAI,EAAE,OAAO,EAAE,YAAY,EAAE,CAAC,EAAE,CAAC;IACvF,CAAC;IACD,MAAM,IAAI,SAAS,CACjB,gHAAgH,CACjH,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,MAAM,OAAO,SAAS;IAgBS;IAf7B,gDAAgD;IACvC,IAAI,CAAa;IAClB,OAAO,GAAG,CAAC,CAAC;IACZ,MAAM,GAAG,CAAC,CAAC;IACX,SAAS,CAAU;IACnB,MAAM,GAAG,KAAK,CAAC;IACf,IAAI,CAAiB;IAC7B,mHAAmH;IAC3G,OAAO,CAAmB;IAC1B,OAAO,CAAmB;IAC1B,cAAc,GAAG,CAAC,CAAC;IACnB,aAAa,CAAwB;IAC7C,wGAAwG;IACvF,kBAAkB,GAAG,IAAI,OAAO,EAA6B,CAAC;IAE/E,YAA6B,QAA4B;QAA5B,aAAQ,GAAR,QAAQ,CAAoB;QACvD,IAAI,QAAQ,CAAC,SAAS,KAAK,MAAM;YAAE,IAAI,CAAC,OAAO,GAAG,IAAI,eAAe,EAAE,CAAC;QACxE,MAAM,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC;QACjC,MAAM,MAAM,GAAG,GAAS,EAAE;YACxB,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC;QACpB,CAAC,CAAC;QACF,IAAI,CAAC,IAAI,GAAG;YACV,MAAM,EAAE,CAAC,KAAK,EAAE,EAAE;gBAChB,MAAM,EAAE,CAAC;gBACT,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;gBACvB,MAAM,MAAM,GAAG;oBACb,GAAG,KAAK;oBACR,YAAY,EAAE,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,YAAY,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,YAAY;oBAC/F,GAAG,CAAC,KAAK,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;iBACtE,CAAC;gBACF,OAAO,IAAI,CAAC,MAAM,CAAC,EAAE,GAAG,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,CAAC;YACxF,CAAC;YACD,MAAM,EAAE,CAAC,KAAK,EAAE,EAAE;gBAChB,MAAM,EAAE,CAAC;gBACT,OAAO,IAAI,CAAC,MAAM,CAAC,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;YAC3F,CAAC;YACD,IAAI,EAAE,CAAC,KAAK,EAAE,EAAE;gBACd,MAAM,EAAE,CAAC;gBACT,OAAO,IAAI,CAAC,MAAM,CAChB,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,EAC1F,GAAG,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,EACzB,IAAI,CAAC,IAAI,CACV,CAAC;YACJ,CAAC;YACD,MAAM,EAAE,CAAC,KAAK,EAAE,EAAE;gBAChB,MAAM,EAAE,CAAC;gBACT,MAAM,MAAM,GAAG,EAAE,GAAG,KAAK,EAAE,GAAG,CAAC,KAAK,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC;gBACnG,OAAO,IAAI,CAAC,MAAM,CAAC,EAAE,GAAG,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;YAC7F,CAAC;YACD,SAAS,EAAE,CAAC,OAAO,EAAE,EAAE;gBACrB,MAAM,UAAU,GACd,OAAO,CAAC,KAAK,KAAK,IAAI,IAAI,CAAC,OAAO,OAAO,CAAC,KAAK,KAAK,QAAQ,IAAI,OAAO,OAAO,CAAC,KAAK,KAAK,UAAU,CAAC;oBAClG,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC;oBAC5C,CAAC,CAAC,SAAS,CAAC;gBAChB,qGAAqG;gBACrG,2FAA2F;gBAC3F,IAAI,UAAU,KAAK,SAAS;oBAAE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;;oBACvG,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,UAAU,CAAC,KAAK,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC;YACtE,CAAC;SACF,CAAC;IACJ,CAAC;IAED,8GAA8G;IACtG,MAAM,CAAC,KAAkB,EAAE,IAAmB,EAAE,IAA+B;QACrF,MAAM,MAAM,GAAG,CAAC,KAAc,EAAS,EAAE;YACvC,MAAM,QAAQ,GAAG,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;YACrE,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,QAAQ,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC;YAC3F,MAAM,QAAQ,CAAC;QACjB,CAAC,CAAC;QACF,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,IAAI,EAAE,CAAC;YACxB,mGAAmG;YACnG,4FAA4F;YAC5F,IAAI,QAAQ,KAAK,IAAI,IAAI,CAAC,OAAO,QAAQ,KAAK,QAAQ,IAAI,OAAO,QAAQ,KAAK,UAAU,CAAC;gBAAE,OAAO,QAAQ,CAAC;YAC3G,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO;gBAAE,OAAO,UAAU,CAAC,QAAQ,EAAE,GAAG,EAAE,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;YACjF,IAAI,CAAC,cAAc,EAAE,CAAC;YACtB,OAAO,UAAU,CACf,QAAQ,EACR,GAAG,EAAE;gBACH,IAAI,CAAC,cAAc,EAAE,CAAC;YACxB,CAAC,EACD,CAAC,KAAK,EAAE,EAAE;gBACR,IAAI,CAAC,cAAc,EAAE,CAAC;gBACtB,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;YACvB,CAAC,CACF,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;QACvB,CAAC;IACH,CAAC;IAED,+GAA+G;IACvG,SAAS,CAAC,KAAc,EAAE,IAA+B;QAC/D,MAAM,IAAI,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;QAC/B,MAAM,QAAQ,GAAG,IAAI;YACnB,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,gBAAgB,CAAC,CAAC,QAAQ,EAAE,iBAAiB,CAAC,EAAE,IAAI,CAAC,CAAC;YAChG,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,eAAe,EAAE,gBAAgB,CAAC,KAAK,CAAC,EAAE,CAAC;QAChE,MAAM,MAAM,GAAG,EAAE,GAAG,QAAQ,CAAC,eAAe,EAAE,CAAC;QAC/C,OAAO,CAAC,cAAc,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QACtC,OAAO;YACL,IAAI,EAAE,QAAQ,CAAC,OAAO;YACtB,KAAK,EAAE,MAAM;YACb,MAAM,EAAE,QAAQ,CAAC,OAAO,KAAK,IAAI,IAAI,QAAQ,CAAC,eAAe,CAAC,GAAG,KAAK,KAAK;YAC3E,IAAI;SACL,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACH,QAAQ;QACN,IAAI,IAAI,CAAC,QAAQ,CAAC,SAAS,KAAK,MAAM;YAAE,IAAI,CAAC,OAAO,GAAG,IAAI,eAAe,EAAE,CAAC;QAC7E,IAAI,CAAC,OAAO,GAAG,SAAS,CAAC;QACzB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,IAAI,CAAC,aAAa,GAAG,SAAS,CAAC;IACjC,CAAC;IAED,6GAA6G;IAC7G,OAAO,CAAC,IAA+B;QACrC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;IAED,4EAA4E;IAC5E,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC;IAC9B,CAAC;IAED,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;IAC7B,CAAC;IAED,+GAA+G;IAC/G,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,KAAK;QACH,OAAO;YACL,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,GAAG,CAAC,IAAI,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,CAAC;YACtE,GAAG,CAAC,IAAI,CAAC,aAAa,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,aAAa,EAAE,CAAC;SAC3D,CAAC;IACJ,CAAC;IAED,IAAI,cAAc;QAChB,OAAO,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC;IAC/B,CAAC;IAED,IAAI,wBAAwB;QAC1B,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IAED,aAAa,CAAC,MAA4B;QACxC,IAAI,CAAC,aAAa,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAC7C,CAAC;IAED,sFAAsF;IACtF,mBAAmB,CAAC,KAA8B;QAChD,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,CAAE,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,eAAe,CAA6B,CAAC,CAAC,CAAC,KAAK,CAAC;IACxG,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,KAAK,CAAC,SAAkB,EAAE,aAAa,GAAG,KAAK;QACnD,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC;QACtC,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACvB,IAAI,OAAmC,CAAC;QACxC,IAAI,OAAO,GAAG,KAAK,CAAC,CAAC,yFAAyF;QAC9G,IAAI,CAAC;YACH,MAAM,KAAK,GAAY,OAAO,CAAC,KAAK,CAAC,CAAC,kDAAkD;YACxF,IAAI,OAAO,KAAK,KAAK,UAAU;gBAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;YACtF,OAAO,GAAG,UAAU,CAClB,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,EACnB,GAAsB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,EACxE,CAAC,KAAK,EAAqB,EAAE;gBAC3B,IAAI,CAAC,OAAO;oBAAE,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC;gBACvE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;YACvD,CAAC,CACF,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC;YACzD,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;QACvD,CAAC;QACD,IAAI,SAAS,KAAK,SAAS,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC;YAAE,OAAO,OAAO,CAAC;QAC3E,IAAI,KAAgD,CAAC;QACrD,MAAM,OAAO,GAAG,IAAI,OAAO,CAAoB,CAAC,OAAO,EAAE,EAAE;YACzD,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC;QAC3G,CAAC,CAAC,CAAC;QACH,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;YACtD,IAAI,MAAM,CAAC,OAAO,IAAI,aAAa,EAAE,CAAC;gBACpC,OAAO,GAAG,IAAI,CAAC;gBACf,MAAM,KAAK,GAAG,IAAI,KAAK,CAAC,8CAA8C,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;gBAClG,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC;YAC3D,CAAC;YACD,OAAO,MAAM,CAAC;QAChB,CAAC;gBAAS,CAAC;YACT,YAAY,CAAC,KAAK,CAAC,CAAC;QACtB,CAAC;IACH,CAAC;IAED,iHAAiH;IACjH,KAAK,CAAC,IAAU;QACd,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAC5E,CAAC;IAED,oHAAoH;IAC5G,IAAI,CAAC,KAAc,EAAE,KAA8B,EAAE,IAAmB;QAC9E,IAAI,CAAC,MAAM,IAAI,CAAC,CAAC;QACjB,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACvB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,IAAI,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YAChC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;YACnB,sCAAsC;YACtC,OAAO,CAAC,IAAI,CACV,qDAAqD,IAAI,sBAAsB;gBAC7E,uCAAuC,CAC1C,CAAC;QACJ,CAAC;QACD,+EAA+E;QAC/E,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;YAC7D,IAAI,CAAC,OAAO,GAAG,IAAI,eAAe,CAAC,0CAA0C,IAAI,EAAE,EAAE,KAAK,CAAC,CAAC;YAC5F,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;gBAChB,uGAAuG;gBACvG,IAAI,CAAC,IAAI,EAAE,gBAAgB,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,iBAAiB,CAAC,CAAC;gBACnF,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI;oBAAE,IAAI,CAAC,IAAI,EAAE,gBAAgB,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,iBAAiB,CAAC,CAAC;YAClH,CAAC;YACD,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACnC,CAAC;QACD,IAAI,KAAK,KAAK,SAAS;YAAE,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;IAC5F,CAAC;CACF;AAED,gHAAgH;AAChH,SAAS,WAAW,CAAC,OAAmB,EAAE,OAAiE;IACzG,IAAI,CAAC;QACH,MAAM,QAAQ,GAAY,OAAO,CAAC,SAAS,CAAC;QAC5C,IAAI,OAAO,QAAQ,KAAK,UAAU;YAAE,OAAO;QAC3C,UAAU,CACR,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,EAC/B,GAAG,EAAE,CAAC,SAAS,EACf,GAAG,EAAE,CAAC,SAAS,CAChB,CAAC;IACJ,CAAC;IAAC,MAAM,CAAC;QACP,oFAAoF;IACtF,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,SAAS,UAAU,CAAI,KAAc,EAAE,OAAgB,EAAE,OAA8B;IACrF,MAAM,OAAO,GAAqB,KAAK,YAAY,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;IAC9G,OAAO,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAe,CAAC;AAC9E,CAAC","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 type { CaptureHistoryOptions, CaptureHistoryStatus } from '../capture/historyTypes.js';\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  /** Opt-in capture evidence and explicit host acknowledgement; ordinary flush never implies durability. */\n  readonly capture?: CaptureHistoryOptions;\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  readonly capture?: CaptureHistoryOptions;\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', capture } = 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    if (capture !== undefined) {\n      if (!capture || typeof capture.acknowledge !== 'function')\n        throw new TypeError('sink.capture requires acknowledge');\n      for (const [key, max] of [\n        ['maxBytes', 8 * 1024 * 1024],\n        ['timeoutMs', 30_000],\n      ] as const) {\n        const value = capture[key];\n        if (value !== undefined && (!Number.isSafeInteger(value) || value < 1 || value > max))\n          throw new RangeError(`sink.capture.${key} must be a positive whole number at most ${max}`);\n      }\n    }\n    const fixedCapture =\n      capture &&\n      Object.freeze({\n        acknowledge: capture.acknowledge.bind(capture),\n        ...(capture.maxBytes !== undefined && { maxBytes: capture.maxBytes }),\n        ...(capture.timeoutMs !== undefined && { timeoutMs: capture.timeoutMs }),\n      });\n    return { adapter, onFailure, flush, ...(fixedCapture && { capture: fixedCapture }) };\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  private capturePending = 0;\n  private captureStatus?: CaptureHistoryStatus;\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      if (!this.resolved.capture) return settleOnce(returned, () => undefined, failed);\n      this.capturePending++;\n      return settleOnce(\n        returned,\n        () => {\n          this.capturePending--;\n        },\n        (cause) => {\n          this.capturePending--;\n          return failed(cause);\n        },\n      );\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    this.captureStatus = undefined;\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      ...(this.captureStatus && { capture: this.captureStatus }),\n    };\n  }\n\n  get captureOptions(): CaptureHistoryOptions | undefined {\n    return this.resolved.capture;\n  }\n\n  get pendingCaptureDeliveries(): number {\n    return this.capturePending;\n  }\n\n  captureResult(result: CaptureHistoryStatus): void {\n    this.captureStatus = Object.freeze(result);\n  }\n\n  /** Same served seed as opened; a history digest never sees a seeded policy secret. */\n  captureInitialState(state: Record<string, unknown>): Record<string, unknown> {\n    return this.rule ? (this.rule.retainState(state, LOG_PLACEHOLDER) as Record<string, unknown>) : state;\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/esm/lib/runner/snapshot.d.ts

@@ -5,7 +5,9 @@
  * served subflow results (each subflow's own mirror under `redact: true`), one
  * recorder row per recorder id, and the deferred tier's accounting.
  */
+import type { FlowRecorder } from '../engine/narrative/types.js';
 import type { FlowchartTraverser } from '../engine/traversal/FlowchartTraverser.js';
+import type { ScopeRecorder } from '../scope/types.js';
 import type { RunObservers } from './attach.js';
 import type { RecorderSnapshot, RecordSinkStats, RuntimeSnapshot } from './ExecutionRuntime.js';
 /**
@@ -38,4 +40,4 @@ export declare function servedSnapshot(traverser: FlowchartTraverser<any, any>,
  * recorder cannot smuggle an `id` of its own choosing into the snapshot (the
  * id is the executor's, and consumers index by it).
  */
-export declare function collectRecorderSnapshots(observers: RunObservers): RecorderSnapshot[];
+export declare function collectRecorderSnapshots(observers: RunObservers, collected?: (recorder: ScopeRecorder | FlowRecorder, row: RecorderSnapshot) => void, includeCapture?: boolean): RecorderSnapshot[];

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

@@ -36,7 +36,21 @@ export function servedSnapshot(traverser, observers, options, sink) {
         // engine/handlers/servedSubflowResults.ts). Plain: the records as they are.
         snapshot.subflowResults = servedSubflowResults(sfResults, options?.redact === true);
     }
-    const recorderSnapshots = collectRecorderSnapshots(observers);
+    let recorderSnapshots;
+    const acknowledged = [];
+    const runtime = traverser.getRuntime();
+    const inlineFlow = runtime.capture ? new Set(observers.flowRecorders) : undefined;
+    try {
+        recorderSnapshots = collectRecorderSnapshots(observers, inlineFlow &&
+            ((recorder, row) => {
+                if (inlineFlow.has(recorder) && row.capture?.runId === snapshot.runId)
+                    acknowledged.push(row.capture);
+            }), runtime.capture !== undefined);
+    }
+    catch (error) {
+        runtime.capture?.limit('recorder-snapshot-failed');
+        throw error;
+    }
     if (recorderSnapshots.length > 0) {
         snapshot.recorders = recorderSnapshots;
     }
@@ -50,6 +64,21 @@ export function servedSnapshot(traverser, observers, options, sink) {
     // started.
     if (sink !== undefined)
         snapshot.sink = sink;
+    if (runtime.capture) {
+        const control = acknowledged.length === 0
+            ? 'unknown'
+            : acknowledged.every((ack) => ack.control === 'captured')
+                ? 'captured'
+                : acknowledged.some((ack) => ack.control === 'partial')
+                    ? 'partial'
+                    : 'unknown';
+        if (runtime.rootStageContext.getPolicy().redaction?.isInert() === false)
+            runtime.capture.limit('redaction-active');
+        return {
+            ...snapshot,
+            capture: runtime.captureSnapshot(snapshot.commitLog.length, control, options?.redact === true),
+        };
+    }
     return snapshot;
 }
 /**
@@ -88,14 +117,16 @@ function servedLog(snapshot) {
  * recorder cannot smuggle an `id` of its own choosing into the snapshot (the
  * id is the executor's, and consumers index by it).
  */
-export function collectRecorderSnapshots(observers) {
+export function collectRecorderSnapshots(observers, collected, includeCapture = false) {
     const out = [];
     const seen = new Set();
     const collect = (r) => {
         if (!r.toSnapshot || seen.has(r.id))
             return;
         seen.add(r.id);
-        out.push(copyBundle(r.id, r.toSnapshot()));
+        const row = copyBundle(r.id, r.toSnapshot(), includeCapture);
+        out.push(row);
+        collected?.(r, row);
     };
     for (const r of observers.scopeRecorders)
         collect(r);
@@ -109,4 +140,4 @@ export function collectRecorderSnapshots(observers) {
     }
     return out;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"snapshot.js","sourceRoot":"","sources":["../../../../src/lib/runner/snapshot.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * snapshot — what `FlowChartExecutor.getSnapshot()` serves (F9).\n *\n * The traverser's runtime snapshot, plus what only the executor knows: the\n * served subflow results (each subflow's own mirror under `redact: true`), one\n * recorder row per recorder id, and the deferred tier's accounting.\n */\n\nimport type { CommitBundle } from 'foottrace';\nimport { serveRecord } from 'foottrace';\nimport { deepFreeze } from 'foottrace/write';\n\nimport { isDevMode } from '../devMode.js';\nimport { servedSubflowResults } from '../engine/handlers/servedSubflowResults.js';\nimport type { FlowRecorder } from '../engine/narrative/types.js';\nimport type { FlowchartTraverser } from '../engine/traversal/FlowchartTraverser.js';\nimport { copyBundle } from '../recorder/snapshot.js';\nimport type { ScopeRecorder } from '../scope/types.js';\nimport type { RunObservers } from './attach.js';\nimport type { RecorderSnapshot, RecordSinkStats, RuntimeSnapshot } from './ExecutionRuntime.js';\n\n/**\n * The served snapshot. `sharedState` is the LIVE view in production (zero\n * copy); in dev mode it is a deep-frozen CLONE, so a consumer mutation throws\n * instead of corrupting engine state.\n */\nexport function servedSnapshot(\n  traverser: FlowchartTraverser<any, any>,\n  observers: RunObservers,\n  options?: { redact?: boolean },\n  sink?: RecordSinkStats,\n): RuntimeSnapshot {\n  const snapshot = servedLog(traverser.getSnapshot(options) as RuntimeSnapshot);\n  if (isDevMode()) {\n    // Dev-mode mutation guard: freeze a CLONE, never the live engine\n    // state — `snapshot.sharedState` IS SharedMemory's current generation,\n    // whose unchanged subtrees every later generation shares\n    // (copy-on-write, 9.29.0).\n    // Production stays zero-copy; clone-always is a measured decision\n    // deferred until the bench says it's affordable (BACKLOG #8).\n    // NOTE: deepFreeze (capture/freeze.ts — the one walk) cannot reach\n    // Map/Set INTERNALS (`map.set()` on the frozen clone won't throw) and\n    // skips typed arrays. The CLONE still isolates the engine.\n    snapshot.sharedState = deepFreeze(structuredClone(snapshot.sharedState));\n  }\n  const sfResults = traverser.getSubflowResults();\n  if (sfResults.size > 0) {\n    // Under `redact: true` each subflow's `globalContext` is its own mirror\n    // (9.20.0) — served, never written into the record (see\n    // engine/handlers/servedSubflowResults.ts). Plain: the records as they are.\n    snapshot.subflowResults = servedSubflowResults(sfResults, options?.redact === true);\n  }\n\n  const recorderSnapshots = collectRecorderSnapshots(observers);\n  if (recorderSnapshots.length > 0) {\n    snapshot.recorders = recorderSnapshots;\n  }\n\n  // RFC-001 Block 9: the deferred-observer accounting surface. Present\n  // ONLY when a deferred observer was attached on this executor —\n  // zero-cost discipline for everyone else.\n  if (observers.deferredTier) {\n    snapshot.observerStats = observers.deferredTier.getStats();\n  }\n\n  // The crash-safe record's accounting (10.1, P6): present ONLY for an executor built with a `sink`, once a run\n  // started.\n  if (sink !== undefined) snapshot.sink = sink;\n\n  return snapshot;\n}\n\n/**\n * The commit log and the fold base as a reader may hold them (9.44.2): a record freezing sealed whole\n * is served as itself; one holding what freezing cannot seal — a Date, a Map, a buffer … — as a copy\n * of its open paths, the reader's own (`capture/freeze.ts · serveRecord`). Here, at the public door:\n * the engine's own snapshot of a log (a subflow mount's) is not served, so the run pays nothing.\n */\nfunction servedLog(snapshot: RuntimeSnapshot): RuntimeSnapshot {\n  const { initialState } = snapshot;\n  return {\n    ...snapshot,\n    commitLog: Object.freeze(snapshot.commitLog.map(serveRecord)) as CommitBundle[],\n    ...(initialState === undefined ? {} : { initialState: serveRecord(initialState) }),\n  };\n}\n\n/**\n * Collect `toSnapshot()` bundles from every attached recorder — ONE entry\n * per recorder id, across all channels and both delivery tiers.\n *\n * The dedupe is load-bearing, not tidiness. A recorder that implements a\n * shared-name hook (`onError` / `onPause` / `onResume` — declared on BOTH\n * the scope and flow interfaces) is legitimately registered on BOTH inline\n * lists by `attachCombinedRecorder`, and that is by design: each channel\n * calls the hook with its own payload variant. `MetricRecorder.onPause` is\n * the everyday case. Walking the lists without a shared `seen` set turned\n * that into a DUPLICATED snapshot entry (same id twice), which breaks every\n * consumer that indexes `snapshot.recorders` by id.\n *\n * Ordering is scope list → flow list → deferred tier, and the FIRST bundle\n * for an id wins. A recorder with no `toSnapshot` never claims an id, so it\n * cannot shadow a same-id recorder that does have one.\n *\n * The row is REBUILT field by field by the one copier (`recorder/snapshot.ts\n * · copyBundle`, shared with `CompositeRecorder`) rather than spread, so a\n * recorder cannot smuggle an `id` of its own choosing into the snapshot (the\n * id is the executor's, and consumers index by it).\n */\nexport function collectRecorderSnapshots(observers: RunObservers): RecorderSnapshot[] {\n  const out: RecorderSnapshot[] = [];\n  const seen = new Set<string>();\n  const collect = (r: ScopeRecorder | FlowRecorder): void => {\n    if (!r.toSnapshot || seen.has(r.id)) return;\n    seen.add(r.id);\n    out.push(copyBundle(r.id, r.toSnapshot()));\n  };\n  for (const r of observers.scopeRecorders) collect(r);\n  for (const r of observers.flowRecorders) collect(r);\n  if (observers.deferredTier) {\n    for (const r of observers.deferredTier.scopeListRecorders()) collect(r);\n    for (const r of observers.deferredTier.flowListRecorders()) collect(r);\n  }\n  return out;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"snapshot.js","sourceRoot":"","sources":["../../../../src/lib/runner/snapshot.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * snapshot — what `FlowChartExecutor.getSnapshot()` serves (F9).\n *\n * The traverser's runtime snapshot, plus what only the executor knows: the\n * served subflow results (each subflow's own mirror under `redact: true`), one\n * recorder row per recorder id, and the deferred tier's accounting.\n */\n\nimport type { CommitBundle } from 'foottrace';\nimport { serveRecord } from 'foottrace';\nimport { deepFreeze } from 'foottrace/write';\n\nimport type { RecorderCaptureAcknowledgement } from '../capture/nativeCoverage.js';\nimport { isDevMode } from '../devMode.js';\nimport { servedSubflowResults } from '../engine/handlers/servedSubflowResults.js';\nimport type { FlowRecorder } from '../engine/narrative/types.js';\nimport type { FlowchartTraverser } from '../engine/traversal/FlowchartTraverser.js';\nimport { copyBundle } from '../recorder/snapshot.js';\nimport type { ScopeRecorder } from '../scope/types.js';\nimport type { RunObservers } from './attach.js';\nimport type { RecorderSnapshot, RecordSinkStats, RuntimeSnapshot } from './ExecutionRuntime.js';\n\n/**\n * The served snapshot. `sharedState` is the LIVE view in production (zero\n * copy); in dev mode it is a deep-frozen CLONE, so a consumer mutation throws\n * instead of corrupting engine state.\n */\nexport function servedSnapshot(\n  traverser: FlowchartTraverser<any, any>,\n  observers: RunObservers,\n  options?: { redact?: boolean },\n  sink?: RecordSinkStats,\n): RuntimeSnapshot {\n  const snapshot = servedLog(traverser.getSnapshot(options) as RuntimeSnapshot);\n  if (isDevMode()) {\n    // Dev-mode mutation guard: freeze a CLONE, never the live engine\n    // state — `snapshot.sharedState` IS SharedMemory's current generation,\n    // whose unchanged subtrees every later generation shares\n    // (copy-on-write, 9.29.0).\n    // Production stays zero-copy; clone-always is a measured decision\n    // deferred until the bench says it's affordable (BACKLOG #8).\n    // NOTE: deepFreeze (capture/freeze.ts — the one walk) cannot reach\n    // Map/Set INTERNALS (`map.set()` on the frozen clone won't throw) and\n    // skips typed arrays. The CLONE still isolates the engine.\n    snapshot.sharedState = deepFreeze(structuredClone(snapshot.sharedState));\n  }\n  const sfResults = traverser.getSubflowResults();\n  if (sfResults.size > 0) {\n    // Under `redact: true` each subflow's `globalContext` is its own mirror\n    // (9.20.0) — served, never written into the record (see\n    // engine/handlers/servedSubflowResults.ts). Plain: the records as they are.\n    snapshot.subflowResults = servedSubflowResults(sfResults, options?.redact === true);\n  }\n\n  let recorderSnapshots: RecorderSnapshot[];\n  const acknowledged: RecorderCaptureAcknowledgement[] = [];\n  const runtime = traverser.getRuntime() as import('./ExecutionRuntime.js').ExecutionRuntime;\n  const inlineFlow = runtime.capture ? new Set(observers.flowRecorders) : undefined;\n  try {\n    recorderSnapshots = collectRecorderSnapshots(\n      observers,\n      inlineFlow &&\n        ((recorder, row) => {\n          if (inlineFlow.has(recorder as FlowRecorder) && row.capture?.runId === snapshot.runId)\n            acknowledged.push(row.capture);\n        }),\n      runtime.capture !== undefined,\n    );\n  } catch (error) {\n    runtime.capture?.limit('recorder-snapshot-failed');\n    throw error;\n  }\n  if (recorderSnapshots.length > 0) {\n    snapshot.recorders = recorderSnapshots;\n  }\n\n  // RFC-001 Block 9: the deferred-observer accounting surface. Present\n  // ONLY when a deferred observer was attached on this executor —\n  // zero-cost discipline for everyone else.\n  if (observers.deferredTier) {\n    snapshot.observerStats = observers.deferredTier.getStats();\n  }\n\n  // The crash-safe record's accounting (10.1, P6): present ONLY for an executor built with a `sink`, once a run\n  // started.\n  if (sink !== undefined) snapshot.sink = sink;\n\n  if (runtime.capture) {\n    const control =\n      acknowledged.length === 0\n        ? 'unknown'\n        : acknowledged.every((ack) => ack.control === 'captured')\n        ? 'captured'\n        : acknowledged.some((ack) => ack.control === 'partial')\n        ? 'partial'\n        : 'unknown';\n    if (runtime.rootStageContext.getPolicy().redaction?.isInert() === false) runtime.capture.limit('redaction-active');\n    return {\n      ...snapshot,\n      capture: runtime.captureSnapshot(snapshot.commitLog.length, control, options?.redact === true),\n    };\n  }\n  return snapshot;\n}\n\n/**\n * The commit log and the fold base as a reader may hold them (9.44.2): a record freezing sealed whole\n * is served as itself; one holding what freezing cannot seal — a Date, a Map, a buffer … — as a copy\n * of its open paths, the reader's own (`capture/freeze.ts · serveRecord`). Here, at the public door:\n * the engine's own snapshot of a log (a subflow mount's) is not served, so the run pays nothing.\n */\nfunction servedLog(snapshot: RuntimeSnapshot): RuntimeSnapshot {\n  const { initialState } = snapshot;\n  return {\n    ...snapshot,\n    commitLog: Object.freeze(snapshot.commitLog.map(serveRecord)) as CommitBundle[],\n    ...(initialState === undefined ? {} : { initialState: serveRecord(initialState) }),\n  };\n}\n\n/**\n * Collect `toSnapshot()` bundles from every attached recorder — ONE entry\n * per recorder id, across all channels and both delivery tiers.\n *\n * The dedupe is load-bearing, not tidiness. A recorder that implements a\n * shared-name hook (`onError` / `onPause` / `onResume` — declared on BOTH\n * the scope and flow interfaces) is legitimately registered on BOTH inline\n * lists by `attachCombinedRecorder`, and that is by design: each channel\n * calls the hook with its own payload variant. `MetricRecorder.onPause` is\n * the everyday case. Walking the lists without a shared `seen` set turned\n * that into a DUPLICATED snapshot entry (same id twice), which breaks every\n * consumer that indexes `snapshot.recorders` by id.\n *\n * Ordering is scope list → flow list → deferred tier, and the FIRST bundle\n * for an id wins. A recorder with no `toSnapshot` never claims an id, so it\n * cannot shadow a same-id recorder that does have one.\n *\n * The row is REBUILT field by field by the one copier (`recorder/snapshot.ts\n * · copyBundle`, shared with `CompositeRecorder`) rather than spread, so a\n * recorder cannot smuggle an `id` of its own choosing into the snapshot (the\n * id is the executor's, and consumers index by it).\n */\nexport function collectRecorderSnapshots(\n  observers: RunObservers,\n  collected?: (recorder: ScopeRecorder | FlowRecorder, row: RecorderSnapshot) => void,\n  includeCapture = false,\n): RecorderSnapshot[] {\n  const out: RecorderSnapshot[] = [];\n  const seen = new Set<string>();\n  const collect = (r: ScopeRecorder | FlowRecorder): void => {\n    if (!r.toSnapshot || seen.has(r.id)) return;\n    seen.add(r.id);\n    const row = copyBundle(r.id, r.toSnapshot(), includeCapture);\n    out.push(row);\n    collected?.(r, row);\n  };\n  for (const r of observers.scopeRecorders) collect(r);\n  for (const r of observers.flowRecorders) collect(r);\n  if (observers.deferredTier) {\n    for (const r of observers.deferredTier.scopeListRecorders()) collect(r);\n    for (const r of observers.deferredTier.flowListRecorders()) collect(r);\n  }\n  return out;\n}\n"]}

package/dist/esm/lib/runner/storedCaptureAdmission.d.ts

@@ -0,0 +1,4 @@
+import type { StoredLog } from 'foottrace';
+import type { StoredCaptureResult } from './readStoredCapture.js';
+/** @internal Engine-metadata admission after Foottrace's generic record validation. */
+export declare function admitStoredCapture(log: StoredLog, runId: string, maxBytes: number): Promise<StoredCaptureResult>;