footprintjs 10.0.1 → 10.2.0

package/dist/esm/lib/recorder/attemptSeries.js

@@ -0,0 +1,103 @@
+/**
+ * recorder/attemptSeries.ts — what a RECORDER keeps of a series: the one evidence predicate, the stop that gave up, and a
+ * per-series tally rebuilt from `onAttempt` records (design §5.1, P1c).
+ *
+ * WHY one module: seven built-in recorders account for attempts, and each must agree on two questions — "is this
+ * series worth a row?" and "did it give up?" — or a Topology node and a boundary count would disagree about the
+ * same run. Asked here, once.
+ *
+ * THE predicate (`isRetryEvidence`): a series is evidence when it RETRIED (some attempt was followed by another),
+ * GAVE UP while a retry was possible (it stopped `exhausted`, `declined` or `no-time-left` with `of > 1`, §3.9), or
+ * TIMED OUT (an attempt ran out of its cap or the deadline — P1b's lone timeout is the incident's own shape). A
+ * policy stage that succeeded first time — or that paused or was aborted on its first attempt — is
+ * indistinguishable from a stage with no policy in every recorder row, so a chart in which nothing retried keeps
+ * those rows byte-identical (law 2). So is a LONE attempt (`of: 1`, recorded for every stage of a run with a
+ * deadline, P1b) that merely failed: a stage error like any other, so a deadline alone never multiplies rows.
+ *
+ * Records arrive in order within a series, so the predicate is decided at the series' FIRST record: attempt 1 is
+ * evidence iff it did not end the series quietly, and every later attempt is evidence by being one.
+ *
+ * L5 (`recorder/**`), beside the stores: it imports the attempt vocabulary's types only (the L0 leaf), so
+ * `recorder/` never takes a runtime edge into `attempt/` — whose runner reaches `decide/` and `scope/`, which
+ * import `recorder/` (a module cycle).
+ */
+import { joinPath, subflowSegmentsOf } from 'foottrace';
+/** The stop reasons that mean "gave up" — apart from `aborted` (the run ended it) and `paused` (§3.9). */
+const GAVE_UP = new Set(['exhausted', 'declined', 'no-time-left']);
+/** The series stopped on this record because retrying was given up (exhausted, declined or no time left). */
+export function gaveUp(record) {
+    return record.next === 'stop' && GAVE_UP.has(record.reason);
+}
+/**
+ * The record belongs to a STAGE's series that retried, gave up or timed out — the one row predicate every recorder
+ * shares. A call's or an observed attempt (`scope.$call`, `observed()`, P2) is never a row here: these recorders keep
+ * one row per stage execution, and a call is counted per TARGET (the `attempts()` recorder, P7) — drawn as a stage's
+ * retry it would say the stage retried when only its call did.
+ */
+export function isRetryEvidence(record) {
+    if (record.kind !== 'stage')
+        return false;
+    return (record.attempt > 1 ||
+        record.next === 'retry' ||
+        record.outcome === 'timeout' ||
+        (gaveUp(record) && (record.of ?? 1) > 1));
+}
+/** Did the attempt itself fail — a failure, a timeout or the run's abort (not a success, not a pause)? */
+export function attemptFailed(record) {
+    return record.outcome === 'failed' || record.outcome === 'timeout' || record.outcome === 'aborted';
+}
+/** The record's name. */
+export function attemptRef(record) {
+    return { series: record.series, attempt: record.attempt };
+}
+/**
+ * The path-prefixed id of the subflow an attempt's stage ran in (`'sf-outer/sf-inner'`), or `undefined` at the top
+ * level — read off the stage execution's `runtimeStageId` (the event's, else the series'), the one id that always
+ * carries it.
+ */
+export function subflowOfAttempt(event) {
+    const segments = subflowSegmentsOf(event.traversalContext?.runtimeStageId ?? event.record.series);
+    return segments.length > 0 ? joinPath(...segments) : undefined;
+}
+/** A zeroed per-outcome count. */
+export function emptyOutcomeCounts() {
+    return { ok: 0, failed: 0, timeout: 0, aborted: 0, paused: 0 };
+}
+/**
+ * Per-series tallies, keyed by `series`, for the series that are evidence. `add` returns the series' state after
+ * the record, or `undefined` for a record that is not evidence (nothing to keep).
+ */
+export class AttemptSeriesBook {
+    bySeries = new Map();
+    add(record) {
+        if (!isRetryEvidence(record))
+            return undefined;
+        let entry = this.bySeries.get(record.series);
+        if (!entry) {
+            entry = { refs: [], counts: emptyOutcomeCounts() };
+            this.bySeries.set(record.series, entry);
+        }
+        entry.refs.push(attemptRef(record));
+        entry.counts[record.outcome] += 1;
+        const attempts = [...entry.refs];
+        if (record.next === 'retry')
+            return { series: record.series, attempts };
+        return { series: record.series, attempts, summary: summaryOf(entry.refs.length, entry.counts, record) };
+    }
+    clear() {
+        this.bySeries.clear();
+    }
+}
+function summaryOf(count, counts, last) {
+    return {
+        count,
+        ...counts,
+        last: {
+            next: last.next,
+            reason: last.reason,
+            ...(last.category !== undefined && { category: last.category }),
+            ...(last.retryOnThrew && { retryOnThrew: true }),
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"attemptSeries.js","sourceRoot":"","sources":["../../../../src/lib/recorder/attemptSeries.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * recorder/attemptSeries.ts — what a RECORDER keeps of a series: the one evidence predicate, the stop that gave up, and a\n * per-series tally rebuilt from `onAttempt` records (design §5.1, P1c).\n *\n * WHY one module: seven built-in recorders account for attempts, and each must agree on two questions — \"is this\n * series worth a row?\" and \"did it give up?\" — or a Topology node and a boundary count would disagree about the\n * same run. Asked here, once.\n *\n * THE predicate (`isRetryEvidence`): a series is evidence when it RETRIED (some attempt was followed by another),\n * GAVE UP while a retry was possible (it stopped `exhausted`, `declined` or `no-time-left` with `of > 1`, §3.9), or\n * TIMED OUT (an attempt ran out of its cap or the deadline — P1b's lone timeout is the incident's own shape). A\n * policy stage that succeeded first time — or that paused or was aborted on its first attempt — is\n * indistinguishable from a stage with no policy in every recorder row, so a chart in which nothing retried keeps\n * those rows byte-identical (law 2). So is a LONE attempt (`of: 1`, recorded for every stage of a run with a\n * deadline, P1b) that merely failed: a stage error like any other, so a deadline alone never multiplies rows.\n *\n * Records arrive in order within a series, so the predicate is decided at the series' FIRST record: attempt 1 is\n * evidence iff it did not end the series quietly, and every later attempt is evidence by being one.\n *\n * L5 (`recorder/**`), beside the stores: it imports the attempt vocabulary's types only (the L0 leaf), so\n * `recorder/` never takes a runtime edge into `attempt/` — whose runner reaches `decide/` and `scope/`, which\n * import `recorder/` (a module cycle).\n */\n\nimport { joinPath, subflowSegmentsOf } from 'foottrace';\n\nimport type { AttemptOutcome, AttemptReason, AttemptRecord, AttemptSummary } from '../attempt/types.js';\n\n/**\n * One attempt, named — `series` (the stage execution's `runtimeStageId`) plus the 1-based `attempt`. The\n * identity `AttemptRecord` carries until the engine stamps foottrace's attempt id (design §3.4).\n */\nexport interface AttemptRef {\n  readonly series: string;\n  readonly attempt: number;\n}\n\n/** Attempt counts per outcome — the shape `AttemptSummary` uses, without the series' end. */\nexport type AttemptOutcomeCounts = Readonly<Record<AttemptOutcome, number>>;\n\n/** The stop reasons that mean \"gave up\" — apart from `aborted` (the run ended it) and `paused` (§3.9). */\nconst GAVE_UP: ReadonlySet<AttemptReason> = new Set<AttemptReason>(['exhausted', 'declined', 'no-time-left']);\n\n/** The series stopped on this record because retrying was given up (exhausted, declined or no time left). */\nexport function gaveUp(record: Pick<AttemptRecord, 'next' | 'reason'>): boolean {\n  return record.next === 'stop' && GAVE_UP.has(record.reason);\n}\n\n/**\n * The record belongs to a STAGE's series that retried, gave up or timed out — the one row predicate every recorder\n * shares. A call's or an observed attempt (`scope.$call`, `observed()`, P2) is never a row here: these recorders keep\n * one row per stage execution, and a call is counted per TARGET (the `attempts()` recorder, P7) — drawn as a stage's\n * retry it would say the stage retried when only its call did.\n */\nexport function isRetryEvidence(record: AttemptRecord): boolean {\n  if (record.kind !== 'stage') return false;\n  return (\n    record.attempt > 1 ||\n    record.next === 'retry' ||\n    record.outcome === 'timeout' ||\n    (gaveUp(record) && (record.of ?? 1) > 1)\n  );\n}\n\n/** Did the attempt itself fail — a failure, a timeout or the run's abort (not a success, not a pause)? */\nexport function attemptFailed(record: AttemptRecord): boolean {\n  return record.outcome === 'failed' || record.outcome === 'timeout' || record.outcome === 'aborted';\n}\n\n/** The record's name. */\nexport function attemptRef(record: AttemptRecord): AttemptRef {\n  return { series: record.series, attempt: record.attempt };\n}\n\n/**\n * The path-prefixed id of the subflow an attempt's stage ran in (`'sf-outer/sf-inner'`), or `undefined` at the top\n * level — read off the stage execution's `runtimeStageId` (the event's, else the series'), the one id that always\n * carries it.\n */\nexport function subflowOfAttempt(event: {\n  readonly record: AttemptRecord;\n  readonly traversalContext?: { readonly runtimeStageId: string };\n}): string | undefined {\n  const segments = subflowSegmentsOf(event.traversalContext?.runtimeStageId ?? event.record.series);\n  return segments.length > 0 ? joinPath(...segments) : undefined;\n}\n\n/** A zeroed per-outcome count. */\nexport function emptyOutcomeCounts(): Record<AttemptOutcome, number> {\n  return { ok: 0, failed: 0, timeout: 0, aborted: 0, paused: 0 };\n}\n\n/** What a recorder knows of one series so far. `summary` is present once the series ended. */\nexport interface AttemptSeriesState {\n  readonly series: string;\n  /** The series' attempts, in order. */\n  readonly attempts: readonly AttemptRef[];\n  /**\n   * The series at a glance — the same value the runner stamps on `StageSnapshot.attemptSummary`, rebuilt from the\n   * records. Absent while the last record says `retry`: the series is in flight, or the run's signal cut its wait\n   * (no record follows; only the execution tree knows how it ended).\n   */\n  readonly summary?: AttemptSummary;\n}\n\n/**\n * Per-series tallies, keyed by `series`, for the series that are evidence. `add` returns the series' state after\n * the record, or `undefined` for a record that is not evidence (nothing to keep).\n */\nexport class AttemptSeriesBook {\n  private readonly bySeries = new Map<string, { refs: AttemptRef[]; counts: Record<AttemptOutcome, number> }>();\n\n  add(record: AttemptRecord): AttemptSeriesState | undefined {\n    if (!isRetryEvidence(record)) return undefined;\n    let entry = this.bySeries.get(record.series);\n    if (!entry) {\n      entry = { refs: [], counts: emptyOutcomeCounts() };\n      this.bySeries.set(record.series, entry);\n    }\n    entry.refs.push(attemptRef(record));\n    entry.counts[record.outcome] += 1;\n    const attempts = [...entry.refs];\n    if (record.next === 'retry') return { series: record.series, attempts };\n    return { series: record.series, attempts, summary: summaryOf(entry.refs.length, entry.counts, record) };\n  }\n\n  clear(): void {\n    this.bySeries.clear();\n  }\n}\n\nfunction summaryOf(count: number, counts: Record<AttemptOutcome, number>, last: AttemptRecord): AttemptSummary {\n  return {\n    count,\n    ...counts,\n    last: {\n      next: last.next as AttemptSummary['last']['next'],\n      reason: last.reason,\n      ...(last.category !== undefined && { category: last.category }),\n      ...(last.retryOnThrew && { retryOnThrew: true as const }),\n    },\n  };\n}\n"]}

package/dist/esm/lib/recorder/hooks.d.ts

@@ -30,6 +30,7 @@
  *
  * Pinned by test/lib/recorder/hooks.test.ts (the `@ts-expect-error` probes).
  */
+import type { RunCorrelation } from '../attempt/types.js';
 import type { FlowRecorder } from '../engine/narrative/types.js';
 import type { ErrorEvent, ScopeRecorder } from '../scope/types.js';
 import type { EmitRecorder } from './EmitRecorder.js';
@@ -174,6 +175,12 @@ export declare const HOOKS: {
         };
         readonly executorMade: false;
     };
+    readonly onAttempt: {
+        readonly on: {
+            readonly flow: "FlowAttemptEvent";
+        };
+        readonly executorMade: false;
+    };
     readonly onStageRetry: {
         readonly on: {
             readonly flow: "FlowStageRetryEvent";
@@ -240,6 +247,8 @@ export interface FailureSite {
     readonly stageId: string;
     readonly runtimeStageId: string;
     readonly pipelineId: string;
+    /** The run's correlation, when the site's events carry one — the failure event carries it too. */
+    readonly correlation?: RunCorrelation;
 }
 /**
  * THE scope-channel `onError` event for a recorder that threw in `hook` — built in ONE place

package/dist/esm/lib/recorder/hooks.js

@@ -54,6 +54,8 @@ export const HOOKS = {
     onError: { on: { scope: 'ErrorEvent', flow: 'FlowErrorEvent' }, executorMade: false },
     onStageStart: { on: { scope: 'StageEvent' }, executorMade: false },
     onStageEnd: { on: { scope: 'StageEvent' }, executorMade: false },
+    // Every attempt of a declared retry policy (10.1): fires DURING a stage, once per attempt, before onStageRetry.
+    onAttempt: { on: { flow: 'FlowAttemptEvent' }, executorMade: false },
     // Declarative per-stage retry (9.15): fires DURING a stage, once per failed attempt that will be retried.
     onStageRetry: { on: { flow: 'FlowStageRetryEvent' }, executorMade: false },
     // Throttling (9.39.0, R9): a fork child's error the run's `throttlingErrorChecker` classified.
@@ -105,6 +107,7 @@ export function recorderFailureEvent(site, thrown, hook) {
         error: extractErrorInfo(thrown),
         operation: operationFor(hook),
         channel: 'scope',
+        ...(site.correlation && { correlation: site.correlation }),
     };
 }
 /**
@@ -153,4 +156,4 @@ export function fire(recorders, hook, event, onFailure = SWALLOW) {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hooks.js","sourceRoot":"","sources":["../../../../src/lib/recorder/hooks.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * recorder/hooks.ts — the hook registry and the one dispatcher (F6).\n *\n * Every recorder hook name is declared ONCE, here, in `HOOKS`. Everything that used to keep\n * its own hand list derives from it:\n *\n *   - channel routing (`CombinedRecorder · has*RecorderMethods`) asks `hooksOn(channel)` — the\n *     three hand lists it replaced (`RECORDER_EVENT_METHODS`, `FLOW_…`, `EMIT_…`) are gone;\n *   - the deferred tier's taps (`DeferredObserverTier · buildScopeTap / buildFlowTap`) iterate\n *     `hooksOn`;\n *   - `CompositeRecorder`'s fan-out is generated from `HOOK_NAMES` (every hook, every channel).\n *\n * `fire` is the one per-recorder loop: call the hook on each recorder, and hand a throw to the\n * caller's failure policy — never to the caller's caller. The engine keeps its two policies\n * (the scope channel routes a throw to every recorder's `onError`; the flow channel warns in\n * dev mode and moves on); `fire` only guarantees that whatever the policy does, the loop goes\n * on and nothing escapes. Borrowed: C# `MulticastDelegate` (one invocation list), OpenTelemetry\n * `MultiSpanProcessor` (one fan-out, a failing processor never stops the others).\n *\n * ## The compile-time law\n *\n * `HOOKS` is checked against the three recorder interfaces in BOTH directions:\n *\n *   - a hook added to `ScopeRecorder` / `FlowRecorder` / `EmitRecorder` and not to `HOOKS` is a\n *     missing property of the `satisfies` clause — it does not compile;\n *   - a hook added to one interface that `HOOKS` lists on another channel only is a missing\n *     key of that entry's `on` — it does not compile;\n *   - an entry naming a channel whose interface does not declare it is an excess property —\n *     it does not compile.\n *\n * Pinned by test/lib/recorder/hooks.test.ts (the `@ts-expect-error` probes).\n */\n\nimport { invokeRecorderHook } from '../capture/invokeHook.js';\nimport { isDevMode } from '../devMode.js';\nimport type { FlowRecorder } from '../engine/narrative/types.js';\nimport { extractErrorInfo } from '../errors/errorInfo.js';\nimport type { ErrorEvent, ScopeRecorder } from '../scope/types.js';\nimport type { EmitRecorder } from './EmitRecorder.js';\n\n/** Members every recorder interface shares that are NOT events. */\ntype Lifecycle = 'id' | 'clear' | 'toSnapshot';\n\n/** Hooks of the emit channel (`EmitRecorder`). */\nexport type EmitHookName = Exclude<keyof EmitRecorder, Lifecycle>;\n/** Hooks of the scope (data-flow) channel. `ScopeRecorder` also declares `onEmit` — the emit\n *  channel rides the scope list — so it is subtracted here and counted on `emit`. */\nexport type ScopeHookName = Exclude<keyof ScopeRecorder, Lifecycle | EmitHookName>;\n/** Hooks of the flow (control-flow) channel. */\nexport type FlowHookName = Exclude<keyof FlowRecorder, Lifecycle>;\n/** Every recorder hook, on any channel. */\nexport type HookName = ScopeHookName | FlowHookName | EmitHookName;\n/** The three runtime channels (the build-time structure channel fires its hooks by name). */\nexport type HookChannel = 'scope' | 'flow' | 'emit';\n\n/** The channels whose interface DECLARES hook `K` — what an entry's `on` must name exactly. */\nexport type ChannelsOf<K extends HookName> =\n  | (K extends ScopeHookName ? 'scope' : never)\n  | (K extends FlowHookName ? 'flow' : never)\n  | (K extends EmitHookName ? 'emit' : never);\n\ntype PayloadOf<I, K> = K extends keyof I ? (NonNullable<I[K]> extends (event: infer E) => unknown ? E : never) : never;\ntype ChannelInterface = { scope: ScopeRecorder; flow: FlowRecorder; emit: EmitRecorder };\n\n/** The payload hook `K` receives on channel `C` — read off the channel's interface, never restated. */\nexport type HookPayload<K extends HookName, C extends ChannelsOf<K> = ChannelsOf<K>> = C extends HookChannel\n  ? PayloadOf<ChannelInterface[C], K>\n  : never;\n\n/**\n * One registry entry.\n *\n * - `on` — every channel the hook is declared on, each mapped to the NAME of its payload type\n *   (prose for readers; the type itself is `HookPayload<K, C>`, read off the interface).\n * - `executorMade` — a LABEL (read by tests and docs, not by routing): `true` when the executor synthesizes the event itself instead of a\n *   dispatch site in the engine (today only `onResume`, fired by `runner/resume.ts · announceResume`).\n *   Such an event goes through `fire` like every other, so a throwing recorder never aborts\n *   the executor call that made it.\n */\nexport type HookSpec<K extends HookName> = {\n  readonly on: { readonly [C in ChannelsOf<K>]: string };\n  readonly executorMade: boolean;\n};\n\n/**\n * THE registry. Key order is the order every derived list keeps: `hooksOn(channel)` is an\n * order-preserving filter of it, identical to the 9.35.0 hand-written lists it replaced.\n */\nexport const HOOKS = {\n  onRead: { on: { scope: 'ReadEvent' }, executorMade: false },\n  onWrite: { on: { scope: 'WriteEvent' }, executorMade: false },\n  onCommit: { on: { scope: 'CommitEvent' }, executorMade: false },\n  onStageExecuted: { on: { flow: 'FlowStageEvent' }, executorMade: false },\n  onNext: { on: { flow: 'FlowNextEvent' }, executorMade: false },\n  onDecision: { on: { flow: 'FlowDecisionEvent' }, executorMade: false },\n  onFork: { on: { flow: 'FlowForkEvent' }, executorMade: false },\n  onSelected: { on: { flow: 'FlowSelectedEvent' }, executorMade: false },\n  onSubflowEntry: { on: { flow: 'FlowSubflowEvent' }, executorMade: false },\n  onSubflowExit: { on: { flow: 'FlowSubflowEvent' }, executorMade: false },\n  onSubflowRegistered: { on: { flow: 'FlowSubflowRegisteredEvent' }, executorMade: false },\n  onLoop: { on: { flow: 'FlowLoopEvent' }, executorMade: false },\n  onBreak: { on: { flow: 'FlowBreakEvent' }, executorMade: false },\n  onError: { on: { scope: 'ErrorEvent', flow: 'FlowErrorEvent' }, executorMade: false },\n  onStageStart: { on: { scope: 'StageEvent' }, executorMade: false },\n  onStageEnd: { on: { scope: 'StageEvent' }, executorMade: false },\n  // Declarative per-stage retry (9.15): fires DURING a stage, once per failed attempt that will be retried.\n  onStageRetry: { on: { flow: 'FlowStageRetryEvent' }, executorMade: false },\n  // Throttling (9.39.0, R9): a fork child's error the run's `throttlingErrorChecker` classified.\n  onThrottled: { on: { flow: 'FlowThrottledEvent' }, executorMade: false },\n  onPause: { on: { scope: 'PauseEvent', flow: 'FlowPauseEvent' }, executorMade: false },\n  onResume: { on: { scope: 'ResumeEvent', flow: 'FlowResumeEvent' }, executorMade: true },\n  // Run boundaries — listed so a recorder whose ONLY hook is one of them still routes to the flow channel.\n  onRunStart: { on: { flow: 'FlowRunEvent' }, executorMade: false },\n  onRunEnd: { on: { flow: 'FlowRunEvent' }, executorMade: false },\n  onRunFailed: { on: { flow: 'FlowRunFailedEvent' }, executorMade: false },\n  onEmit: { on: { emit: 'EmitEvent' }, executorMade: false },\n} as const satisfies { readonly [K in HookName]: HookSpec<K> };\n\n/** Every hook name, in registry order. */\nexport const HOOK_NAMES = Object.freeze(Object.keys(HOOKS)) as readonly HookName[];\n\n/** The hooks declared on `channel`, in registry order. */\nexport function hooksOn(channel: 'scope'): readonly ScopeHookName[];\nexport function hooksOn(channel: 'flow'): readonly FlowHookName[];\nexport function hooksOn(channel: 'emit'): readonly EmitHookName[];\nexport function hooksOn(channel: HookChannel): readonly HookName[];\nexport function hooksOn(channel: HookChannel): readonly HookName[] {\n  return BY_CHANNEL[channel];\n}\n\nconst declaredOn = (channel: HookChannel) =>\n  Object.freeze(HOOK_NAMES.filter((hook) => Object.prototype.hasOwnProperty.call(HOOKS[hook].on, channel)));\n/** Computed once at load — routing asks on every attach, the taps on every traverser. */\nconst BY_CHANNEL: Readonly<Record<HookChannel, readonly HookName[]>> = {\n  scope: declaredOn('scope'),\n  flow: declaredOn('flow'),\n  emit: declaredOn('emit'),\n};\n\n/** The scope-channel error operation a failing hook is reported under (`ErrorEvent.operation`). */\nexport function operationFor(hook: string): 'read' | 'write' | 'commit' {\n  if (hook === 'onRead') return 'read';\n  if (hook === 'onCommit') return 'commit';\n  return 'write';\n}\n\n/** Where a recorder failure is reported FROM — the stage (or synthesized event) whose hook threw. */\nexport interface FailureSite {\n  readonly stageName: string;\n  readonly stageId: string;\n  readonly runtimeStageId: string;\n  readonly pipelineId: string;\n}\n\n/**\n * THE scope-channel `onError` event for a recorder that threw in `hook` — built in ONE place\n * for every path that reports one: the inline facade (`ScopeFacade · _routeFailure`), the\n * executor's own `onResume` (`runner/resume.ts · announceResume`) and deferred delivery\n * (`DeferredObserverTier · routeListenerError`). `error` is the structured form\n * (`extractErrorInfo`: `message`, `name`, `code?`, `raw` = the thrown value itself) whatever\n * was thrown — an `Error`, a string, anything (9.39.0; before, the inline paths passed the raw\n * thrown value and the deferred tier wrapped it in `new Error(...)`).\n */\nexport function recorderFailureEvent(site: FailureSite, thrown: unknown, hook: string): ErrorEvent {\n  return {\n    stageName: site.stageName,\n    stageId: site.stageId,\n    runtimeStageId: site.runtimeStageId,\n    pipelineId: site.pipelineId,\n    timestamp: Date.now(),\n    error: extractErrorInfo(thrown),\n    operation: operationFor(hook),\n    channel: 'scope' as const,\n  };\n}\n\n/**\n * Text for anything a recorder threw. `${err}` throws on a null-prototype object (no\n * `toString`) and on a symbol — and a throw inside the isolation would escape it.\n */\nexport function describeThrown(error: unknown): string {\n  try {\n    return String(error);\n  } catch {\n    return Object.prototype.toString.call(error);\n  }\n}\n\n/** What to do with a recorder's throw. Its own throw is swallowed by `fire`. */\nexport type HookFailure = (error: unknown, recorder: object, hook: HookName) => void;\n\n/**\n * The flow channel's policy, verbatim since 9.0: warn in dev mode, otherwise say nothing.\n * `source` names the dispatcher in the warning (`FlowRecorderDispatcher`, `FlowChartExecutor`).\n */\nexport function warnInDevMode(source: string): HookFailure {\n  return (error, recorder, hook) => {\n    if (!isDevMode()) return;\n    const id = (recorder as { id?: unknown }).id;\n    // eslint-disable-next-line no-console\n    console.warn(`[footprint] ${source}: recorder \"${String(id)}\" threw in ${hook}: ${describeThrown(error)}`);\n  };\n}\n\nconst SWALLOW: HookFailure = () => undefined;\n\n/**\n * Call `hook` on every recorder that implements it (normal property lookup, `this` bound —\n * `invokeRecorderHook`), in order. A throw goes to `onFailure` and the loop continues; a\n * throw FROM `onFailure` is swallowed. Nothing a recorder does can reach the caller.\n */\nexport function fire<K extends HookName>(\n  recorders: Iterable<object>,\n  hook: K,\n  event: HookPayload<K>,\n  onFailure: HookFailure = SWALLOW,\n): void {\n  for (const recorder of recorders) {\n    try {\n      invokeRecorderHook(recorder, hook, event);\n    } catch (error) {\n      try {\n        onFailure(error, recorder, hook);\n      } catch {\n        // An isolation that throws is itself isolated — recorder errors never reach the run.\n      }\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hooks.js","sourceRoot":"","sources":["../../../../src/lib/recorder/hooks.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * recorder/hooks.ts — the hook registry and the one dispatcher (F6).\n *\n * Every recorder hook name is declared ONCE, here, in `HOOKS`. Everything that used to keep\n * its own hand list derives from it:\n *\n *   - channel routing (`CombinedRecorder · has*RecorderMethods`) asks `hooksOn(channel)` — the\n *     three hand lists it replaced (`RECORDER_EVENT_METHODS`, `FLOW_…`, `EMIT_…`) are gone;\n *   - the deferred tier's taps (`DeferredObserverTier · buildScopeTap / buildFlowTap`) iterate\n *     `hooksOn`;\n *   - `CompositeRecorder`'s fan-out is generated from `HOOK_NAMES` (every hook, every channel).\n *\n * `fire` is the one per-recorder loop: call the hook on each recorder, and hand a throw to the\n * caller's failure policy — never to the caller's caller. The engine keeps its two policies\n * (the scope channel routes a throw to every recorder's `onError`; the flow channel warns in\n * dev mode and moves on); `fire` only guarantees that whatever the policy does, the loop goes\n * on and nothing escapes. Borrowed: C# `MulticastDelegate` (one invocation list), OpenTelemetry\n * `MultiSpanProcessor` (one fan-out, a failing processor never stops the others).\n *\n * ## The compile-time law\n *\n * `HOOKS` is checked against the three recorder interfaces in BOTH directions:\n *\n *   - a hook added to `ScopeRecorder` / `FlowRecorder` / `EmitRecorder` and not to `HOOKS` is a\n *     missing property of the `satisfies` clause — it does not compile;\n *   - a hook added to one interface that `HOOKS` lists on another channel only is a missing\n *     key of that entry's `on` — it does not compile;\n *   - an entry naming a channel whose interface does not declare it is an excess property —\n *     it does not compile.\n *\n * Pinned by test/lib/recorder/hooks.test.ts (the `@ts-expect-error` probes).\n */\n\nimport type { RunCorrelation } from '../attempt/types.js';\nimport { invokeRecorderHook } from '../capture/invokeHook.js';\nimport { isDevMode } from '../devMode.js';\nimport type { FlowRecorder } from '../engine/narrative/types.js';\nimport { extractErrorInfo } from '../errors/errorInfo.js';\nimport type { ErrorEvent, ScopeRecorder } from '../scope/types.js';\nimport type { EmitRecorder } from './EmitRecorder.js';\n\n/** Members every recorder interface shares that are NOT events. */\ntype Lifecycle = 'id' | 'clear' | 'toSnapshot';\n\n/** Hooks of the emit channel (`EmitRecorder`). */\nexport type EmitHookName = Exclude<keyof EmitRecorder, Lifecycle>;\n/** Hooks of the scope (data-flow) channel. `ScopeRecorder` also declares `onEmit` — the emit\n *  channel rides the scope list — so it is subtracted here and counted on `emit`. */\nexport type ScopeHookName = Exclude<keyof ScopeRecorder, Lifecycle | EmitHookName>;\n/** Hooks of the flow (control-flow) channel. */\nexport type FlowHookName = Exclude<keyof FlowRecorder, Lifecycle>;\n/** Every recorder hook, on any channel. */\nexport type HookName = ScopeHookName | FlowHookName | EmitHookName;\n/** The three runtime channels (the build-time structure channel fires its hooks by name). */\nexport type HookChannel = 'scope' | 'flow' | 'emit';\n\n/** The channels whose interface DECLARES hook `K` — what an entry's `on` must name exactly. */\nexport type ChannelsOf<K extends HookName> =\n  | (K extends ScopeHookName ? 'scope' : never)\n  | (K extends FlowHookName ? 'flow' : never)\n  | (K extends EmitHookName ? 'emit' : never);\n\ntype PayloadOf<I, K> = K extends keyof I ? (NonNullable<I[K]> extends (event: infer E) => unknown ? E : never) : never;\ntype ChannelInterface = { scope: ScopeRecorder; flow: FlowRecorder; emit: EmitRecorder };\n\n/** The payload hook `K` receives on channel `C` — read off the channel's interface, never restated. */\nexport type HookPayload<K extends HookName, C extends ChannelsOf<K> = ChannelsOf<K>> = C extends HookChannel\n  ? PayloadOf<ChannelInterface[C], K>\n  : never;\n\n/**\n * One registry entry.\n *\n * - `on` — every channel the hook is declared on, each mapped to the NAME of its payload type\n *   (prose for readers; the type itself is `HookPayload<K, C>`, read off the interface).\n * - `executorMade` — a LABEL (read by tests and docs, not by routing): `true` when the executor synthesizes the event itself instead of a\n *   dispatch site in the engine (today only `onResume`, fired by `runner/resume.ts · announceResume`).\n *   Such an event goes through `fire` like every other, so a throwing recorder never aborts\n *   the executor call that made it.\n */\nexport type HookSpec<K extends HookName> = {\n  readonly on: { readonly [C in ChannelsOf<K>]: string };\n  readonly executorMade: boolean;\n};\n\n/**\n * THE registry. Key order is the order every derived list keeps: `hooksOn(channel)` is an\n * order-preserving filter of it, identical to the 9.35.0 hand-written lists it replaced.\n */\nexport const HOOKS = {\n  onRead: { on: { scope: 'ReadEvent' }, executorMade: false },\n  onWrite: { on: { scope: 'WriteEvent' }, executorMade: false },\n  onCommit: { on: { scope: 'CommitEvent' }, executorMade: false },\n  onStageExecuted: { on: { flow: 'FlowStageEvent' }, executorMade: false },\n  onNext: { on: { flow: 'FlowNextEvent' }, executorMade: false },\n  onDecision: { on: { flow: 'FlowDecisionEvent' }, executorMade: false },\n  onFork: { on: { flow: 'FlowForkEvent' }, executorMade: false },\n  onSelected: { on: { flow: 'FlowSelectedEvent' }, executorMade: false },\n  onSubflowEntry: { on: { flow: 'FlowSubflowEvent' }, executorMade: false },\n  onSubflowExit: { on: { flow: 'FlowSubflowEvent' }, executorMade: false },\n  onSubflowRegistered: { on: { flow: 'FlowSubflowRegisteredEvent' }, executorMade: false },\n  onLoop: { on: { flow: 'FlowLoopEvent' }, executorMade: false },\n  onBreak: { on: { flow: 'FlowBreakEvent' }, executorMade: false },\n  onError: { on: { scope: 'ErrorEvent', flow: 'FlowErrorEvent' }, executorMade: false },\n  onStageStart: { on: { scope: 'StageEvent' }, executorMade: false },\n  onStageEnd: { on: { scope: 'StageEvent' }, executorMade: false },\n  // Every attempt of a declared retry policy (10.1): fires DURING a stage, once per attempt, before onStageRetry.\n  onAttempt: { on: { flow: 'FlowAttemptEvent' }, executorMade: false },\n  // Declarative per-stage retry (9.15): fires DURING a stage, once per failed attempt that will be retried.\n  onStageRetry: { on: { flow: 'FlowStageRetryEvent' }, executorMade: false },\n  // Throttling (9.39.0, R9): a fork child's error the run's `throttlingErrorChecker` classified.\n  onThrottled: { on: { flow: 'FlowThrottledEvent' }, executorMade: false },\n  onPause: { on: { scope: 'PauseEvent', flow: 'FlowPauseEvent' }, executorMade: false },\n  onResume: { on: { scope: 'ResumeEvent', flow: 'FlowResumeEvent' }, executorMade: true },\n  // Run boundaries — listed so a recorder whose ONLY hook is one of them still routes to the flow channel.\n  onRunStart: { on: { flow: 'FlowRunEvent' }, executorMade: false },\n  onRunEnd: { on: { flow: 'FlowRunEvent' }, executorMade: false },\n  onRunFailed: { on: { flow: 'FlowRunFailedEvent' }, executorMade: false },\n  onEmit: { on: { emit: 'EmitEvent' }, executorMade: false },\n} as const satisfies { readonly [K in HookName]: HookSpec<K> };\n\n/** Every hook name, in registry order. */\nexport const HOOK_NAMES = Object.freeze(Object.keys(HOOKS)) as readonly HookName[];\n\n/** The hooks declared on `channel`, in registry order. */\nexport function hooksOn(channel: 'scope'): readonly ScopeHookName[];\nexport function hooksOn(channel: 'flow'): readonly FlowHookName[];\nexport function hooksOn(channel: 'emit'): readonly EmitHookName[];\nexport function hooksOn(channel: HookChannel): readonly HookName[];\nexport function hooksOn(channel: HookChannel): readonly HookName[] {\n  return BY_CHANNEL[channel];\n}\n\nconst declaredOn = (channel: HookChannel) =>\n  Object.freeze(HOOK_NAMES.filter((hook) => Object.prototype.hasOwnProperty.call(HOOKS[hook].on, channel)));\n/** Computed once at load — routing asks on every attach, the taps on every traverser. */\nconst BY_CHANNEL: Readonly<Record<HookChannel, readonly HookName[]>> = {\n  scope: declaredOn('scope'),\n  flow: declaredOn('flow'),\n  emit: declaredOn('emit'),\n};\n\n/** The scope-channel error operation a failing hook is reported under (`ErrorEvent.operation`). */\nexport function operationFor(hook: string): 'read' | 'write' | 'commit' {\n  if (hook === 'onRead') return 'read';\n  if (hook === 'onCommit') return 'commit';\n  return 'write';\n}\n\n/** Where a recorder failure is reported FROM — the stage (or synthesized event) whose hook threw. */\nexport interface FailureSite {\n  readonly stageName: string;\n  readonly stageId: string;\n  readonly runtimeStageId: string;\n  readonly pipelineId: string;\n  /** The run's correlation, when the site's events carry one — the failure event carries it too. */\n  readonly correlation?: RunCorrelation;\n}\n\n/**\n * THE scope-channel `onError` event for a recorder that threw in `hook` — built in ONE place\n * for every path that reports one: the inline facade (`ScopeFacade · _routeFailure`), the\n * executor's own `onResume` (`runner/resume.ts · announceResume`) and deferred delivery\n * (`DeferredObserverTier · routeListenerError`). `error` is the structured form\n * (`extractErrorInfo`: `message`, `name`, `code?`, `raw` = the thrown value itself) whatever\n * was thrown — an `Error`, a string, anything (9.39.0; before, the inline paths passed the raw\n * thrown value and the deferred tier wrapped it in `new Error(...)`).\n */\nexport function recorderFailureEvent(site: FailureSite, thrown: unknown, hook: string): ErrorEvent {\n  return {\n    stageName: site.stageName,\n    stageId: site.stageId,\n    runtimeStageId: site.runtimeStageId,\n    pipelineId: site.pipelineId,\n    timestamp: Date.now(),\n    error: extractErrorInfo(thrown),\n    operation: operationFor(hook),\n    channel: 'scope' as const,\n    ...(site.correlation && { correlation: site.correlation }),\n  };\n}\n\n/**\n * Text for anything a recorder threw. `${err}` throws on a null-prototype object (no\n * `toString`) and on a symbol — and a throw inside the isolation would escape it.\n */\nexport function describeThrown(error: unknown): string {\n  try {\n    return String(error);\n  } catch {\n    return Object.prototype.toString.call(error);\n  }\n}\n\n/** What to do with a recorder's throw. Its own throw is swallowed by `fire`. */\nexport type HookFailure = (error: unknown, recorder: object, hook: HookName) => void;\n\n/**\n * The flow channel's policy, verbatim since 9.0: warn in dev mode, otherwise say nothing.\n * `source` names the dispatcher in the warning (`FlowRecorderDispatcher`, `FlowChartExecutor`).\n */\nexport function warnInDevMode(source: string): HookFailure {\n  return (error, recorder, hook) => {\n    if (!isDevMode()) return;\n    const id = (recorder as { id?: unknown }).id;\n    // eslint-disable-next-line no-console\n    console.warn(`[footprint] ${source}: recorder \"${String(id)}\" threw in ${hook}: ${describeThrown(error)}`);\n  };\n}\n\nconst SWALLOW: HookFailure = () => undefined;\n\n/**\n * Call `hook` on every recorder that implements it (normal property lookup, `this` bound —\n * `invokeRecorderHook`), in order. A throw goes to `onFailure` and the loop continues; a\n * throw FROM `onFailure` is swallowed. Nothing a recorder does can reach the caller.\n */\nexport function fire<K extends HookName>(\n  recorders: Iterable<object>,\n  hook: K,\n  event: HookPayload<K>,\n  onFailure: HookFailure = SWALLOW,\n): void {\n  for (const recorder of recorders) {\n    try {\n      invokeRecorderHook(recorder, hook, event);\n    } catch (error) {\n      try {\n        onFailure(error, recorder, hook);\n      } catch {\n        // An isolation that throws is itself isolated — recorder errors never reach the run.\n      }\n    }\n  }\n}\n"]}

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

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

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

@@ -9,9 +9,10 @@
  * The engine (FlowchartTraverser) receives this as its runtime parameter.
  * After execution, consumers query it for the full execution state.
  */
-import type { CommitBundle, CommitValuesMode, LogAddress } from 'foottrace';
-import type { WriteProvenanceMode } from 'foottrace/write';
+import type { CommitBundle, CommitValuesMode, LogAddress, LogOutcome, Meta } from 'foottrace';
+import type { RecordSink, WriteProvenanceMode } from 'foottrace/write';
 import { EventLog, SharedMemory } from 'foottrace/write';
+import type { RunCorrelation } from '../attempt/types.js';
 import type { StageSnapshot } from '../memory/frameTypes.js';
 import type { RunPolicy } from '../memory/runPolicy.js';
 import { StageContext } from '../memory/StageContext.js';
@@ -56,6 +57,13 @@ export type RuntimeSnapshot = {
      * snapshot carries a DIFFERENT runId than the paused run's snapshot.
      */
     readonly runId: string;
+    /**
+     * The run's correlation (10.1) — `env.traceparent`, or `env.traceId` + `env.operationId`, resolved once per
+     * leg; the same frozen object every event of the leg carries (`TraversalContext.correlation`, a scope event's
+     * `correlation`). Like `runId`, per leg: a resume carries ITS env's, never the paused leg's. Absent — no
+     * key — when none was given.
+     */
+    readonly correlation?: RunCorrelation;
     sharedState: Record<string, unknown>;
     executionTree: StageSnapshot;
     /**
@@ -124,7 +132,34 @@ export type RuntimeSnapshot = {
      * with `{ delivery: 'deferred' }` on this executor (zero-cost discipline).
      */
     observerStats?: ObserverStats;
+    /**
+     * The crash-safe record's accounting (10.1, P6) — how many entries the run handed its sink and how many the sink
+     * did not take. ABSENT unless the executor was built with a `sink` and a run started.
+     */
+    sink?: RecordSinkStats;
 };
+/** `getSnapshot().sink` — what the run handed its sink, and what the sink did not take (10.1, P6). */
+export interface RecordSinkStats {
+    /** Entries handed to the adapter (each `opened`, `commit`, `note`, `closed` call). */
+    readonly entries: number;
+    /**
+     * Losses — a method that threw or rejected, an entry the log refused to send, a `meta` the log could not copy
+     * (that entry was still stored, without it), and failed or timed-out flushes. A rejection that settles after the
+     * run finished is counted when it settles.
+     */
+    readonly failed: number;
+    /** The last loss's error, as text. Absent while nothing was lost. */
+    readonly lastError?: string;
+}
+/**
+ * Where a runtime's log writes as it lands (10.1, P6): the run's sink, the log's address and what the writer puts on
+ * its `opened` entry. Absent → the log is the plain one-argument `EventLog`, byte-identical to 10.0.
+ */
+export interface RuntimeRecord {
+    readonly sink: RecordSink;
+    readonly address: LogAddress;
+    readonly meta?: Meta;
+}
 export declare class ExecutionRuntime {
     globalStore: SharedMemory;
     /**
@@ -139,6 +174,8 @@ export declare class ExecutionRuntime {
     redactedStore?: SharedMemory;
     rootStageContext: StageContext;
     executionHistory: EventLog;
+    /** The run's sink, when this runtime's log writes to one — handed on to every mount (`recordFor`). */
+    private recordSink?;
     /** Original root for getSnapshot() — set before resume changes rootStageContext. */
     private _snapshotRoot?;
     private _initialState;
@@ -155,7 +192,7 @@ export declare class ExecutionRuntime {
      *   every frame after inherits the same reference. Default: every dial at
      *   its default, no rule, no mirror.
      */
-    constructor(rootName: string, rootId: string, defaultValues?: unknown, initialState?: unknown, policy?: RunPolicy);
+    constructor(rootName: string, rootId: string, defaultValues?: unknown, initialState?: unknown, policy?: RunPolicy, record?: RuntimeRecord);
     /**
      * A fresh root frame for this runtime — `globalStore`, `executionHistory`,
      * the run's policy and (when kept) the mirror. Also how `SubflowExecutor`
@@ -193,6 +230,16 @@ export declare class ExecutionRuntime {
      * 9.44.2).
      */
     private getFoldBase;
+    /**
+     * Where a mount's log writes (10.1, P6): the same sink, at this log's address plus the mount's `runtimeStageId`
+     * (`drillPath: [...parent, mount]`, the address law `RuntimeSnapshot.logAddress` states). Absent when this log
+     * writes to no sink — a mount of a plain log is plain too.
+     */
+    recordFor(mountRuntimeStageId: string, meta?: Meta): RuntimeRecord | undefined;
+    /** Tell the sink this runtime's log ended. Nothing happens without a sink; never throws. */
+    closeRecord(outcome: LogOutcome, meta?: Meta): void;
+    /** Note something beside this runtime's log, in its sink (a resumed leg). Nothing without a sink; never throws. */
+    noteRecord(kind: string, data: Meta): void;
     getPipelines(): string[];
     setRootObject(path: string[], key: string, value: unknown): void;
     /**
@@ -222,14 +269,15 @@ export declare class ExecutionRuntime {
      * `stateAt`, which is the honest signal that the base did not travel with
      * this log — a partial answer that says it is partial, never a silent one.
      *
-     * Returns `Omit<RuntimeSnapshot, 'runId'>`: the runtime is the memory
+     * Returns `Omit<RuntimeSnapshot, 'runId' | 'correlation'>`: the runtime is the memory
      * container and doesn't know which run it serves — `runId` is per-run
      * executor state, stamped by `FlowchartTraverser.getSnapshot()` (which
      * owns the run's id and already stamps it on every event). Subflows'
      * nested runtimes deliberately have NO runId of their own (a subflow is
-     * part of the parent's logical run).
+     * part of the parent's logical run). `correlation` is the traverser's for
+     * the same reason.
      */
     getSnapshot(options?: {
         redact?: boolean;
-    }): Omit<RuntimeSnapshot, 'runId'>;
+    }): Omit<RuntimeSnapshot, 'runId' | 'correlation'>;
 }