footprintjs 10.0.1 → 10.2.0

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

@@ -7,6 +7,7 @@
  */
 import { pickDials } from '../memory/runPolicy.js';
 import { ScopeFacade } from '../scope/ScopeFacade.js';
+import { resolveRecordSink } from './recordSink.js';
 /** Default scope factory — creates a plain ScopeFacade for each stage. */
 const defaultScopeFactory = (ctx, stageName, readOnly, env) => new ScopeFacade(ctx, stageName, readOnly, env);
 /**
@@ -26,6 +27,7 @@ export function resolveExecutorArgs(flowChart, factoryOrOptions) {
         streamHandlers: opts.streamHandlers,
         scopeProtectionMode: opts.scopeProtectionMode,
         dials: pickDials(opts),
+        ...(opts.sink !== undefined && { sink: resolveRecordSink(opts.sink) }),
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"options.js","sourceRoot":"","sources":["../../../../src/lib/runner/options.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAEnD,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAEtD,0EAA0E;AAC1E,MAAM,mBAAmB,GAAiB,CAAC,GAAG,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,EAAE,EAAE,CAC1E,IAAI,WAAW,CAAC,GAAG,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,CAAC,CAAC;AAgFjD;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CACjC,SAAkC,EAClC,gBAAqF;IAErF,MAAM,IAAI,GACR,OAAO,gBAAgB,KAAK,UAAU,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,gBAAgB,EAAE,CAAC,CAAC,CAAC,gBAAgB,IAAI,EAAE,CAAC;IACvG,OAAO;QACL,SAAS;QACT,YAAY,EAAE,IAAI,CAAC,YAAY,IAAI,SAAS,CAAC,YAAY,IAAK,mBAA4C;QAC1G,uBAAuB,EAAE,IAAI,CAAC,uBAAuB;QACrD,cAAc,EAAE,IAAI,CAAC,cAAc;QACnC,eAAe,EAAE,IAAI,CAAC,eAAe;QACrC,sBAAsB,EAAE,IAAI,CAAC,sBAAsB;QACnD,cAAc,EAAE,IAAI,CAAC,cAAc;QACnC,mBAAmB,EAAE,IAAI,CAAC,mBAAmB;QAC7C,KAAK,EAAE,SAAS,CAAC,IAAI,CAAC;KACvB,CAAC;AACJ,CAAC","sourcesContent":["/**\n * options — the executor's construction options and how they resolve (F9).\n *\n * `FlowChartExecutorOptions` is the public options object;\n * `resolveExecutorArgs` turns either constructor form (options object, or a\n * bare `ScopeFactory`) into the `ExecutorArgs` the executor keeps for every leg.\n */\n\nimport type { FlowChart } from '../builder/types.js';\nimport type { ScopeFactory, StreamHandlers } from '../engine/types.js';\nimport type { RunDials } from '../memory/runPolicy.js';\nimport { pickDials } from '../memory/runPolicy.js';\nimport type { ScopeProtectionMode } from '../scope/protection/types.js';\nimport { ScopeFacade } from '../scope/ScopeFacade.js';\n\n/** Default scope factory — creates a plain ScopeFacade for each stage. */\nconst defaultScopeFactory: ScopeFactory = (ctx, stageName, readOnly, env) =>\n  new ScopeFacade(ctx, stageName, readOnly, env);\n\n/**\n * Options object for `FlowChartExecutor` — preferred over positional params.\n *\n * ```typescript\n * const ex = new FlowChartExecutor(chart, {\n *   scopeFactory: myFactory,\n *   defaultValuesForContext: { ... },\n * });\n * ```\n *\n * **Sync note for maintainers:** a field added here must also be added to\n * `ExecutorArgs` and `resolveExecutorArgs` below, or it is accepted and never\n * applied. The DIALS are the exception: they come from `RunDials` and travel\n * whole as `dials`.\n *\n * **TScope inference note:** When using the options-object form with a custom scope,\n * TypeScript cannot infer `TScope` through the options object. Pass the type\n * explicitly: `new FlowChartExecutor<TOut, MyScope>(chart, { scopeFactory })`.\n */\nexport interface FlowChartExecutorOptions<TScope = any> extends RunDials {\n  // ── Common options (most callers need only these) ────────────────────────\n\n  /** Custom scope factory. Defaults to TypedScope or ScopeFacade auto-detection. */\n  scopeFactory?: ScopeFactory<TScope>;\n\n  // ── Context options ──────────────────────────────────────────────────────\n\n  /**\n   * Default values pre-populated into the shared context before **each** stage\n   * (re-applied every stage, acting as baseline defaults).\n   */\n  defaultValuesForContext?: unknown;\n  /**\n   * Initial context values merged into the shared context **once** at startup\n   * (applied before the first stage, not repeated on subsequent stages).\n   * Distinct from `defaultValuesForContext`, which is re-applied every stage.\n   */\n  initialContext?: unknown;\n  /** Read-only input accessible via `scope.getArgs()` — never tracked or written. */\n  readOnlyContext?: unknown;\n\n  // ── Observability cost options ────────────────────────────────────────────\n  // The four dials — `readTracking`, `writeTracking`, `commitValues`,\n  // `writeProvenance` — are inherited from `RunDials` (memory/runPolicy.ts,\n  // where each is documented): the executor picks them off this object and\n  // builds the run's ONE policy from them (F5).\n\n  // ── Advanced / escape-hatch options (most callers do not need these) ─────\n\n  /**\n   * Custom error classifier for throttling detection. Return `true` if a fork\n   * child's error represents a rate-limit or backpressure condition; the\n   * executor then fires `FlowRecorder.onThrottled` for that child (9.39.0 —\n   * an EVENT, not a state key: the `monitor.isThrottled` write it replaced\n   * never landed). The child's failure is otherwise handled as before.\n   * Defaults to no throttling classification.\n   */\n  throttlingErrorChecker?: (error: unknown) => boolean;\n  /** Handlers for streaming stage lifecycle events (see `addStreamingFunction`). */\n  streamHandlers?: StreamHandlers;\n  /** Scope protection mode for TypedScope direct-assignment detection. */\n  scopeProtectionMode?: ScopeProtectionMode;\n}\n\n/** What the executor keeps from construction — read by every leg (`run()` / `resume()`). */\nexport interface ExecutorArgs<TOut, TScope> {\n  flowChart: FlowChart<TOut, TScope>;\n  scopeFactory: ScopeFactory<TScope>;\n  defaultValuesForContext?: unknown;\n  initialContext?: unknown;\n  readOnlyContext?: unknown;\n  throttlingErrorChecker?: (error: unknown) => boolean;\n  streamHandlers?: StreamHandlers;\n  scopeProtectionMode?: ScopeProtectionMode;\n  /** The dials as given (absent = default) — the run's policy is built from them per leg. */\n  dials: RunDials;\n}\n\n/**\n * Resolve either constructor form. The 2-param form is the options form with\n * only `scopeFactory`; the scope factory falls back to the chart's, then to a\n * plain `ScopeFacade`.\n */\nexport function resolveExecutorArgs<TOut, TScope>(\n  flowChart: FlowChart<TOut, TScope>,\n  factoryOrOptions: ScopeFactory<TScope> | FlowChartExecutorOptions<TScope> | undefined,\n): ExecutorArgs<TOut, TScope> {\n  const opts: FlowChartExecutorOptions<TScope> =\n    typeof factoryOrOptions === 'function' ? { scopeFactory: factoryOrOptions } : factoryOrOptions ?? {};\n  return {\n    flowChart,\n    scopeFactory: opts.scopeFactory ?? flowChart.scopeFactory ?? (defaultScopeFactory as ScopeFactory<TScope>),\n    defaultValuesForContext: opts.defaultValuesForContext,\n    initialContext: opts.initialContext,\n    readOnlyContext: opts.readOnlyContext,\n    throttlingErrorChecker: opts.throttlingErrorChecker,\n    streamHandlers: opts.streamHandlers,\n    scopeProtectionMode: opts.scopeProtectionMode,\n    dials: pickDials(opts),\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"options.js","sourceRoot":"","sources":["../../../../src/lib/runner/options.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAEnD,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAkD,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEpG,0EAA0E;AAC1E,MAAM,mBAAmB,GAAiB,CAAC,GAAG,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,EAAE,EAAE,CAC1E,IAAI,WAAW,CAAC,GAAG,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,CAAC,CAAC;AAmGjD;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CACjC,SAAkC,EAClC,gBAAqF;IAErF,MAAM,IAAI,GACR,OAAO,gBAAgB,KAAK,UAAU,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,gBAAgB,EAAE,CAAC,CAAC,CAAC,gBAAgB,IAAI,EAAE,CAAC;IACvG,OAAO;QACL,SAAS;QACT,YAAY,EAAE,IAAI,CAAC,YAAY,IAAI,SAAS,CAAC,YAAY,IAAK,mBAA4C;QAC1G,uBAAuB,EAAE,IAAI,CAAC,uBAAuB;QACrD,cAAc,EAAE,IAAI,CAAC,cAAc;QACnC,eAAe,EAAE,IAAI,CAAC,eAAe;QACrC,sBAAsB,EAAE,IAAI,CAAC,sBAAsB;QACnD,cAAc,EAAE,IAAI,CAAC,cAAc;QACnC,mBAAmB,EAAE,IAAI,CAAC,mBAAmB;QAC7C,KAAK,EAAE,SAAS,CAAC,IAAI,CAAC;QACtB,GAAG,CAAC,IAAI,CAAC,IAAI,KAAK,SAAS,IAAI,EAAE,IAAI,EAAE,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;KACvE,CAAC;AACJ,CAAC","sourcesContent":["/**\n * options — the executor's construction options and how they resolve (F9).\n *\n * `FlowChartExecutorOptions` is the public options object;\n * `resolveExecutorArgs` turns either constructor form (options object, or a\n * bare `ScopeFactory`) into the `ExecutorArgs` the executor keeps for every leg.\n */\n\nimport type { FlowChart } from '../builder/types.js';\nimport type { ScopeFactory, StreamHandlers } from '../engine/types.js';\nimport type { RunDials } from '../memory/runPolicy.js';\nimport { pickDials } from '../memory/runPolicy.js';\nimport type { ScopeProtectionMode } from '../scope/protection/types.js';\nimport { ScopeFacade } from '../scope/ScopeFacade.js';\nimport { type RecordSinkOption, type ResolvedRecordSink, resolveRecordSink } from './recordSink.js';\n\n/** Default scope factory — creates a plain ScopeFacade for each stage. */\nconst defaultScopeFactory: ScopeFactory = (ctx, stageName, readOnly, env) =>\n  new ScopeFacade(ctx, stageName, readOnly, env);\n\n/**\n * Options object for `FlowChartExecutor` — preferred over positional params.\n *\n * ```typescript\n * const ex = new FlowChartExecutor(chart, {\n *   scopeFactory: myFactory,\n *   defaultValuesForContext: { ... },\n * });\n * ```\n *\n * **Sync note for maintainers:** a field added here must also be added to\n * `ExecutorArgs` and `resolveExecutorArgs` below, or it is accepted and never\n * applied. The DIALS are the exception: they come from `RunDials` and travel\n * whole as `dials`.\n *\n * **TScope inference note:** When using the options-object form with a custom scope,\n * TypeScript cannot infer `TScope` through the options object. Pass the type\n * explicitly: `new FlowChartExecutor<TOut, MyScope>(chart, { scopeFactory })`.\n */\nexport interface FlowChartExecutorOptions<TScope = any> extends RunDials {\n  // ── Common options (most callers need only these) ────────────────────────\n\n  /** Custom scope factory. Defaults to TypedScope or ScopeFacade auto-detection. */\n  scopeFactory?: ScopeFactory<TScope>;\n\n  // ── Context options ──────────────────────────────────────────────────────\n\n  /**\n   * Default values pre-populated into the shared context before **each** stage\n   * (re-applied every stage, acting as baseline defaults).\n   */\n  defaultValuesForContext?: unknown;\n  /**\n   * Initial context values merged into the shared context **once** at startup\n   * (applied before the first stage, not repeated on subsequent stages).\n   * Distinct from `defaultValuesForContext`, which is re-applied every stage.\n   */\n  initialContext?: unknown;\n  /** Read-only input accessible via `scope.getArgs()` — never tracked or written. */\n  readOnlyContext?: unknown;\n\n  // ── Observability cost options ────────────────────────────────────────────\n  // The four dials — `readTracking`, `writeTracking`, `commitValues`,\n  // `writeProvenance` — are inherited from `RunDials` (memory/runPolicy.ts,\n  // where each is documented): the executor picks them off this object and\n  // builds the run's ONE policy from them (F5).\n\n  // ── The crash-safe record (10.1, P6) ─────────────────────────────────────\n\n  /**\n   * Where the run's record goes AS IT LANDS, so a run that never finishes still leaves it: every log of the run\n   * (the root and each subflow mount) hands the sink its `opened` base, each commit, a note per attempt that ended,\n   * and its `closed` outcome. `fileSink(path)` (`footprintjs/sinks`, Node) or `memorySink()` (`foottrace/write`);\n   * read it back with `readStoredRecord` (`foottrace`). The redaction policy applies before any entry is written.\n   * A failing sink never stops the run (`onFailure: 'report'`, the default) — `getSnapshot().sink` counts what was\n   * lost. See the guide's \"A crash-safe record\".\n   *\n   * @example\n   * ```typescript\n   * const executor = new FlowChartExecutor(chart, { sink: fileSink('/var/footprint/run.jsonl') });\n   * ```\n   */\n  sink?: RecordSinkOption;\n\n  // ── Advanced / escape-hatch options (most callers do not need these) ─────\n\n  /**\n   * Custom error classifier for throttling detection. Return `true` if a fork\n   * child's error represents a rate-limit or backpressure condition; the\n   * executor then fires `FlowRecorder.onThrottled` for that child (9.39.0 —\n   * an EVENT, not a state key: the `monitor.isThrottled` write it replaced\n   * never landed). The child's failure is otherwise handled as before.\n   * Defaults to no throttling classification.\n   */\n  throttlingErrorChecker?: (error: unknown) => boolean;\n  /** Handlers for streaming stage lifecycle events (see `addStreamingFunction`). */\n  streamHandlers?: StreamHandlers;\n  /** Scope protection mode for TypedScope direct-assignment detection. */\n  scopeProtectionMode?: ScopeProtectionMode;\n}\n\n/** What the executor keeps from construction — read by every leg (`run()` / `resume()`). */\nexport interface ExecutorArgs<TOut, TScope> {\n  flowChart: FlowChart<TOut, TScope>;\n  scopeFactory: ScopeFactory<TScope>;\n  defaultValuesForContext?: unknown;\n  initialContext?: unknown;\n  readOnlyContext?: unknown;\n  throttlingErrorChecker?: (error: unknown) => boolean;\n  streamHandlers?: StreamHandlers;\n  scopeProtectionMode?: ScopeProtectionMode;\n  /** The dials as given (absent = default) — the run's policy is built from them per leg. */\n  dials: RunDials;\n  /** The record sink, resolved and checked at construction (10.1, P6). */\n  sink?: ResolvedRecordSink;\n}\n\n/**\n * Resolve either constructor form. The 2-param form is the options form with\n * only `scopeFactory`; the scope factory falls back to the chart's, then to a\n * plain `ScopeFacade`.\n */\nexport function resolveExecutorArgs<TOut, TScope>(\n  flowChart: FlowChart<TOut, TScope>,\n  factoryOrOptions: ScopeFactory<TScope> | FlowChartExecutorOptions<TScope> | undefined,\n): ExecutorArgs<TOut, TScope> {\n  const opts: FlowChartExecutorOptions<TScope> =\n    typeof factoryOrOptions === 'function' ? { scopeFactory: factoryOrOptions } : factoryOrOptions ?? {};\n  return {\n    flowChart,\n    scopeFactory: opts.scopeFactory ?? flowChart.scopeFactory ?? (defaultScopeFactory as ScopeFactory<TScope>),\n    defaultValuesForContext: opts.defaultValuesForContext,\n    initialContext: opts.initialContext,\n    readOnlyContext: opts.readOnlyContext,\n    throttlingErrorChecker: opts.throttlingErrorChecker,\n    streamHandlers: opts.streamHandlers,\n    scopeProtectionMode: opts.scopeProtectionMode,\n    dials: pickDials(opts),\n    ...(opts.sink !== undefined && { sink: resolveRecordSink(opts.sink) }),\n  };\n}\n"]}

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

@@ -0,0 +1,128 @@
+/**
+ * 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.
+ */
+import type { Meta } from 'foottrace';
+import type { RecordSink } from 'foottrace/write';
+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. */
+export type RecordSinkFailureMode = 'report' | 'fail';
+/** When the adapter's `flush()` runs: after each run's closing entry (`'auto'`), or when the app asks. */
+export type RecordSinkFlushMode = 'auto' | 'manual';
+/**
+ * The executor's `sink` option in its long form. The short form is the adapter itself.
+ *
+ * @example
+ * ```typescript
+ * new FlowChartExecutor(chart, { sink: { adapter: fileSink('/var/footprint/run.jsonl'), onFailure: 'fail' } });
+ * ```
+ */
+export interface RecordSinkOptions {
+    /** Where the entries go — `fileSink(path)` (`footprintjs/sinks`), `memorySink()` (`foottrace/write`), or yours. */
+    readonly adapter: RecordSink;
+    /** `'report'` (default): a lost entry is counted and the run goes on. `'fail'`: the first one fails the run. */
+    readonly onFailure?: RecordSinkFailureMode;
+    /** `'auto'` (default): `run()` awaits the adapter's `flush()` after the closing entry. `'manual'`: `flushRecord()`. */
+    readonly flush?: RecordSinkFlushMode;
+}
+/** The executor's `sink` option: an adapter, or {@link RecordSinkOptions}. */
+export type RecordSinkOption = RecordSink | RecordSinkOptions;
+/** What `executor.flushRecord()` resolves with — the `drainObservers` shape. */
+export interface RecordFlushResult {
+    /** The adapter's flush finished (or there was nothing to flush). */
+    readonly done: boolean;
+    /** The adapter's flush threw or rejected — counted on `getSnapshot().sink`. */
+    readonly failed: boolean;
+    /** The flush had not settled when `timeoutMs` ran out. */
+    readonly pending: boolean;
+}
+/**
+ * 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.
+ */
+export declare class RecordSinkError extends Error {
+    readonly cause: unknown;
+    readonly name = "RecordSinkError";
+    constructor(message: string, cause: unknown);
+}
+/** The option resolved once, at construction. */
+export interface ResolvedRecordSink {
+    readonly adapter: RecordSink;
+    readonly onFailure: RecordSinkFailureMode;
+    readonly flush: RecordSinkFlushMode;
+}
+/**
+ * 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.
+ */
+export declare function resolveRecordSink(option: unknown): ResolvedRecordSink | undefined;
+/**
+ * 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.
+ */
+export declare class RunRecord {
+    private readonly resolved;
+    /** Hand this to every `EventLog` of the run. */
+    readonly sink: RecordSink;
+    private entries;
+    private failed;
+    private lastError?;
+    private warned;
+    private rule?;
+    /** Aborted at the first loss under `'fail'` — composed into the leg's signal; fresh per leg ({@link beginLeg}). */
+    private stopper?;
+    private failure?;
+    /** Opaque error identities only: no raw entry or adapter error is enumerable on the transport error. */
+    private readonly invocationFailures;
+    constructor(resolved: ResolvedRecordSink);
+    /** Capture the served entry now; an asynchronous failure keeps this leg's rule, not a later resume's rule. */
+    private invoke;
+    /** A sink error is the diagnostic errors.recordSinkError; raw causes belong only to the caller's exception. */
+    private errorView;
+    /**
+     * 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(): void;
+    /** The leg's redaction rule — a resume builds a new one; the next `opened` / `closed` is served under it. */
+    useRule(rule: RedactionRule | undefined): void;
+    /** Aborts at the first loss under `onFailure: 'fail'`; absent otherwise. */
+    get stopSignal(): AbortSignal | undefined;
+    get flushMode(): RecordSinkFlushMode;
+    /** The loss that fails the run under `'fail'`; absent while nothing was lost (and always under `'report'`). */
+    get fatal(): RecordSinkError | undefined;
+    stats(): RecordSinkStats;
+    /**
+     * 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.
+     */
+    flush(timeoutMs?: number, pendingIsLoss?: boolean): Promise<RecordFlushResult>;
+    /** The meta as served: a boundary record, scrubbed by key name at every depth (an inert rule copies nothing). */
+    serve(meta: Meta): Meta;
+    /** One loss: counted, warned once per run, told with a safe dispatched entry when available, fatal under 'fail'. */
+    private lost;
+}

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

@@ -0,0 +1,296 @@
+/**
+ * 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.
+ */
+import { LOG_PLACEHOLDER } from 'foottrace/write';
+import { isDevMode } from '../devMode.js';
+import { extractErrorInfo, thrownText } from '../errors/errorInfo.js';
+import { SCOPE_PLACEHOLDER } from '../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.
+ */
+export class RecordSinkError extends Error {
+    cause;
+    name = 'RecordSinkError';
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+    }
+}
+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.
+ */
+export 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? }');
+}
+/**
+ * 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.
+ */
+export 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, 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 = thrownText(error);
+        const retained = rule
+            ? rule.retainStageError(error, text, rule.retainDiagnostic(['errors', 'recordSinkError'], text))
+            : { message: text, structuredError: 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, 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 (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, SCOPE_PLACEHOLDER);
+                if (this.rule !== view.rule)
+                    this.rule?.retainStageError(this.failure, this.failure.message, SCOPE_PLACEHOLDER);
+            }
+            this.stopper.abort(this.failure);
+        }
+        if (entry !== undefined)
+            tellAdapter(this.resolved.adapter, { entry, error: view.error });
+    }
+}
+/** 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/esm/lib/runner/resume.d.ts

@@ -17,6 +17,7 @@
  * The executor owns the per-run state between the steps (the runId, the
  * runtime, the traverser); this module never holds any.
  */
+import type { RunCorrelation } from '../attempt/types.js';
 import type { FlowChart } from '../builder/types.js';
 import { ResumeEntry } from '../engine/handlers/ResumeEntry.js';
 import type { StageNode } from '../engine/types.js';
@@ -70,4 +71,6 @@ export declare function announceResume<TOut, TScope>(plan: ResumePlan<TOut, TSco
     readonly runId: string;
     readonly executionCount: number;
     readonly observers: RunObservers;
+    /** The RESUMED leg's correlation (from `resume()`'s env) — on both events, like every event of the leg. */
+    readonly correlation?: RunCorrelation;
 }): void;