footprintjs 9.0.0 → 9.2.0

package/dist/esm/lib/memory/types.js

@@ -3,5 +3,6 @@
  *
  * Zero dependencies on old code or other libraries in this package.
  */
-export {};
-//# sourceMappingURL=data:application/json;base64,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
+/** Max characters captured in {@link ReadSummaryMarker.preview}. */
+export const READ_PREVIEW_LENGTH = 80;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/lib/memory/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAgGH,oEAAoE;AACpE,MAAM,CAAC,MAAM,mBAAmB,GAAG,EAAE,CAAC","sourcesContent":["/**\n * types.ts — Core type definitions for the memory library\n *\n * Zero dependencies on old code or other libraries in this package.\n */\n\n// ── Patch & Trace ──────────────────────────────────────────────────────────\n\n/** A flat key-value bag representing a state patch (overwrite or merge). */\nexport interface MemoryPatch {\n  [key: string]: any;\n}\n\n/** A single entry in the chronological operation trace. */\nexport interface TraceEntry {\n  /** Canonical path string (segments joined by DELIM). */\n  path: string;\n  /** 'set' = hard overwrite, 'merge' = deep union merge. */\n  verb: 'set' | 'merge';\n}\n\n/** The atomic bundle produced by TransactionBuffer.commit(). */\nexport interface CommitBundle {\n  /** Auto-assigned step index (set by EventLog.record). */\n  idx?: number;\n  /** Human-readable stage name. */\n  stage: string;\n  /** Stable stage identifier (matches spec node id). */\n  stageId: string;\n  /** Unique per-execution-step identifier. Format: [subflowPath/]stageId#executionIndex */\n  runtimeStageId: string;\n  /** Chronological write log for deterministic replay. */\n  trace: TraceEntry[];\n  /** Paths that should be redacted in UI (sensitive data). */\n  redactedPaths: string[];\n  /** Hard overwrite patches. */\n  overwrite: MemoryPatch;\n  /** Deep merge patches. */\n  updates: MemoryPatch;\n}\n\n// ── Flow Control Narrative ─────────────────────────────────────────────────\n\n/** Types of control flow decisions captured by the execution engine. */\nexport type FlowControlType = 'next' | 'branch' | 'children' | 'selected' | 'subflow' | 'loop';\n\n/** A single flow control narrative entry. */\nexport interface FlowMessage {\n  type: FlowControlType;\n  description: string;\n  targetStage?: string | string[];\n  rationale?: string;\n  count?: number;\n  iteration?: number;\n  timestamp?: number;\n}\n\n// ── Read Tracking (#14) ────────────────────────────────────────────────────\n\n/**\n * Policy for how tracked reads are recorded into `StageSnapshot.stageReads`.\n *\n * - `'full'` (default) — every tracked read `structuredClone`s the value into\n *   the stage's read view. Byte-identical to the historical behavior; this is\n *   what snapshot consumers (lens, agentfootprint) see today.\n * - `'summary'` — reads record a cheap {@link ReadSummaryMarker} (type + size\n *   proxy + short preview) instead of the cloned value. O(1)-ish per read —\n *   no value clone, no serialization of large objects.\n * - `'off'` — reads are not recorded at all; `stageReads` is absent from the\n *   snapshot. Zero per-read cost. Values are still readable, and the\n *   `ScopeRecorder.onRead` event still fires (it passes the live reference and\n *   never cloned) — so narrative output is identical in every mode. The policy\n *   scopes ONLY the snapshot's `stageReads` payload.\n *\n * Set via `new FlowChartExecutor(chart, { readTracking })` or\n * `executor.setReadTracking(mode)` (before `run()`).\n */\nexport type ReadTrackingMode = 'full' | 'summary' | 'off';\n\n/**\n * Marker recorded in `StageSnapshot.stageReads` under `readTracking: 'summary'`.\n *\n * Honest cost note: `size` is a cheap proxy (string length / array length /\n * object key count), NOT a serialized byte count — computing real byte size\n * would require an O(value) serialization, which is exactly the cost the\n * summary mode removes. `preview` is only produced for primitives and strings\n * (first {@link READ_PREVIEW_LENGTH} characters); objects and arrays carry no\n * preview for the same reason.\n */\nexport interface ReadSummaryMarker {\n  /** Discriminant — lets snapshot consumers detect marker entries. */\n  __readSummary: true;\n  /** `typeof` result, refined to 'array' / 'null' for objects. */\n  type: 'string' | 'number' | 'boolean' | 'bigint' | 'symbol' | 'function' | 'object' | 'array' | 'null';\n  /** Size proxy: string length, array length, or object key count. */\n  size?: number;\n  /** First {@link READ_PREVIEW_LENGTH} chars — primitives and strings only. */\n  preview?: string;\n}\n\n/** Max characters captured in {@link ReadSummaryMarker.preview}. */\nexport const READ_PREVIEW_LENGTH = 80;\n\n// ── Stage Snapshot ─────────────────────────────────────────────────────────\n\n/** Serialisable representation of a stage's state (for debugging / visualisation). */\nexport type StageSnapshot = {\n  id: string;\n  /** Unique per-execution-step identifier. Format: [subflowPath/]stageId#executionIndex */\n  runtimeStageId?: string;\n  name?: string;\n  /** Human-readable description of what this stage does (from builder). */\n  description?: string;\n  /** Subflow identifier — present when this stage is a subflow entry point. */\n  subflowId?: string;\n  isDecider?: boolean;\n  isFork?: boolean;\n  /** User-level writes made by this stage (pre-namespace keys → values). */\n  stageWrites?: Record<string, unknown>;\n  /** User-level reads made by this stage (pre-namespace keys → values at read\n   *  time). Shape depends on {@link ReadTrackingMode}: cloned values under\n   *  `'full'` (default), {@link ReadSummaryMarker}s under `'summary'`, absent\n   *  under `'off'`. */\n  stageReads?: Record<string, unknown>;\n  logs: Record<string, unknown>;\n  errors: Record<string, unknown>;\n  metrics: Record<string, unknown>;\n  evals: Record<string, unknown>;\n  flowMessages?: FlowMessage[];\n  next?: StageSnapshot;\n  children?: StageSnapshot[];\n};\n\n// ── Scope Factory ──────────────────────────────────────────────────────────\n\n/** Forward-declared so StageContext can accept it without importing scope/. */\nexport type ScopeFactory<TScope> = (core: StageContext, stageName: string, readOnlyContext?: unknown) => TScope;\n\n// ── StageContext (forward reference for ScopeFactory) ──────────────────────\n\n// The actual class lives in StageContext.ts; we just need the type here for\n// the ScopeFactory generic. TypeScript's import-type handles this:\nimport type { StageContext } from './StageContext.js';\n"]}

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

@@ -61,12 +61,17 @@
  *
  * ## How it discriminates
  *
- * Scope-channel events extend `RecorderContext`, which carries `pipelineId`.
- * Flow-channel events do not carry `pipelineId` (they carry an optional
- * `traversalContext` instead, but that field is optional and cannot be
- * relied on as a positive signal). We detect the flow variant by the
- * ABSENCE of `pipelineId` — this is schema-stable as long as scope events
- * continue to extend `RecorderContext`.
+ * 1. **Explicit `channel` field first** (backlog B3): every engine-dispatched
+ *    shared-method event is stamped `channel: 'flow'` (control-flow) or
+ *    `channel: 'scope'` (data-flow) at construction. This is the positive,
+ *    schema-robust signal — it survives wrappers that add/strip fields.
+ * 2. **Legacy fallback** for unstamped events (consumer-fabricated tests,
+ *    persisted traces from <9.2): scope-channel events extend
+ *    `RecorderContext`, which carries `pipelineId`; flow-channel events do
+ *    not. The flow variant is detected by the ABSENCE of `pipelineId` —
+ *    schema-stable as long as scope events continue to extend
+ *    `RecorderContext`, but fragile against field-stripping wrappers, which
+ *    is why the explicit discriminant now exists.
  *
  * @example
  * ```ts
@@ -82,7 +87,12 @@
 export function isFlowEvent(event) {
     if (typeof event !== 'object' || event === null)
         return false;
-    return event.pipelineId === undefined;
+    const e = event;
+    if (e.channel === 'flow')
+        return true;
+    if (e.channel === 'scope')
+        return false;
+    return e.pipelineId === undefined;
 }
 /**
  * Method names belonging to the `ScopeRecorder` (data-flow) interface.
@@ -107,8 +117,8 @@ const RECORDER_EVENT_METHODS = [
  * NOTE: the `onError`, `onPause`, `onResume` methods exist on BOTH interfaces
  * with DIFFERENT event payload shapes. A `CombinedRecorder` that implements
  * any of these receives both variants (one from each channel). Consumers who
- * care about the distinction can discriminate on the presence of
- * `traversalContext` (which only control-flow events carry).
+ * care about the distinction discriminate with `isFlowEvent()` (explicit
+ * `channel` discriminant, legacy pipelineId-absence fallback).
  */
 const FLOW_RECORDER_EVENT_METHODS = [
     'onStageExecuted',
@@ -215,4 +225,4 @@ export function hasFlowRecorderMethods(r) {
 export function hasEmitRecorderMethods(r) {
     return EMIT_RECORDER_EVENT_METHODS.some((m) => hasOwnOrClassMethod(r, m));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CombinedRecorder.js","sourceRoot":"","sources":["../../../../src/lib/recorder/CombinedRecorder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AAmFH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,WAAW,CAAI,KAAQ;IACrC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAC9D,OAAQ,KAAiC,CAAC,UAAU,KAAK,SAAS,CAAC;AACrE,CAAC;AAED;;;;;GAKG;AACH,MAAM,sBAAsB,GAAG;IAC7B,QAAQ;IACR,SAAS;IACT,UAAU;IACV,SAAS;IACT,cAAc;IACd,YAAY;IACZ,SAAS;IACT,UAAU;CACF,CAAC;AAEX;;;;;;;;;GASG;AACH,MAAM,2BAA2B,GAAG;IAClC,iBAAiB;IACjB,QAAQ;IACR,YAAY;IACZ,QAAQ;IACR,YAAY;IACZ,gBAAgB;IAChB,eAAe;IACf,qBAAqB;IACrB,QAAQ;IACR,SAAS;IACT,SAAS;IACT,SAAS;IACT,UAAU;IACV,sEAAsE;IACtE,4DAA4D;IAC5D,uEAAuE;IACvE,qEAAqE;IACrE,YAAY;IACZ,UAAU;IACV,aAAa;CACL,CAAC;AAEX;;;;GAIG;AACH,MAAM,2BAA2B,GAAG,CAAC,QAAQ,CAAU,CAAC;AAExD;;;;;;;;;;;;;;;;GAgBG;AACH,SAAS,mBAAmB,CAAC,CAAU,EAAE,CAAS;IAChD,IAAI,CAAC,KAAK,IAAI,IAAI,OAAO,CAAC,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IACtD,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;QAC/C,OAAO,OAAQ,CAA6B,CAAC,CAAC,CAAC,KAAK,UAAU,CAAC;IACjE,CAAC;IACD,IAAI,KAAK,GAAY,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IAC9C,OAAO,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,MAAM,CAAC,SAAS,EAAE,CAAC;QACpD,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC;YACnD,OAAO,OAAQ,KAAiC,CAAC,CAAC,CAAC,KAAK,UAAU,CAAC;QACrE,CAAC;QACD,KAAK,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;IACvC,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,kBAAkB,CAAC,CAAmB;IACpD,OAAO,sBAAsB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AACvE,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,sBAAsB,CAAC,CAAmB;IACxD,OAAO,2BAA2B,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAC5E,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,sBAAsB,CAAC,CAAmB;IACxD,OAAO,2BAA2B,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAC5E,CAAC","sourcesContent":["/**\n * CombinedRecorder — a single observer that can hook into MULTIPLE event\n * streams (currently: scope data-flow + control-flow). One object, one `id`,\n * one consistent view of the execution.\n *\n * ## Why this exists\n *\n * Before `CombinedRecorder`, a consumer who wanted to observe both streams\n * had to:\n *   1. Implement both `ScopeRecorder` (8 methods) and `FlowRecorder` (12 methods)\n *      fully — stubbing every event they didn't care about.\n *   2. Remember to call BOTH `attachScopeRecorder(r)` AND `attachFlowRecorder(r)`.\n *      Forgetting the second call silently dropped half their events — no\n *      warning, no runtime error.\n *   3. Re-implement coordination logic (buffering, ordering) themselves.\n *\n * `CombinedRecorder` collapses that into a single type and a single attach\n * call (`executor.attachCombinedRecorder(r)`), with the library handling the\n * routing internally. Consumers implement only the events they care about\n * (`Partial<...>`) and the attach method duck-types at runtime to dispatch\n * to the relevant channels.\n *\n * ## Forward compatibility\n *\n * When a third observer type is added (e.g. an `OperationRecorder`), the\n * `CombinedRecorder` type gains an `& Partial<OperationRecorder>` clause and\n * `attachCombinedRecorder` gains one more runtime branch in its dispatch.\n * Consumers writing a `CombinedRecorder` today are NOT affected — their\n * code keeps compiling and attaching correctly, because every new layer is\n * optional.\n *\n * ## Example\n *\n * ```typescript\n * import type { CombinedRecorder } from 'footprintjs';\n *\n * const audit: CombinedRecorder = {\n *   id: 'audit',\n *   onWrite: (e) => logWrite(e.key, e.value),        // ScopeRecorder method\n *   onDecision: (e) => logDecision(e.chosen),        // FlowRecorder method\n * };\n *\n * executor.attachCombinedRecorder(audit);\n * // ^ internally: detects both sets of methods, routes to both channels.\n * ```\n *\n * ## Contract with existing APIs\n *\n * - `attachScopeRecorder(r)` and `attachFlowRecorder(r)` remain unchanged.\n *   Consumers who want only ONE channel keep using them — explicit is good.\n * - `attachCombinedRecorder(r)` is the ONLY way to guarantee an object is\n *   hooked into every stream it has methods for, without maintaining two\n *   attach calls at the call site.\n * - Idempotency by `id` is preserved across channels: re-attaching with the\n *   same `id` replaces the previous instance on BOTH channels, not just one.\n */\n\nimport type { FlowErrorEvent, FlowPauseEvent, FlowRecorder, FlowResumeEvent } from '../engine/narrative/types.js';\nimport type { ErrorEvent, PauseEvent, ResumeEvent, ScopeRecorder } from '../scope/types.js';\nimport type { EmitRecorder } from './EmitRecorder.js';\n\n/**\n * Method names that appear on BOTH `ScopeRecorder` and `FlowRecorder` but with\n * different event payload types. For these, a `CombinedRecorder` declares\n * ONE handler that receives the union of both payloads — consumers\n * discriminate on `traversalContext`, which only control-flow events carry.\n */\ntype SharedLifecycleOverlap = 'onError' | 'onPause' | 'onResume';\n\n/** Lifecycle hooks (not event-specific) that both interfaces share identically. */\ntype SharedLifecycle = 'id' | 'clear' | 'toSnapshot';\n\n/**\n * A recorder that MAY observe any combination of supported event streams.\n *\n * Today's streams:\n *   - Scope data-flow (`ScopeRecorder`: onRead/onWrite/onCommit/onStageStart/…)\n *   - Control-flow (`FlowRecorder`: onDecision/onSubflowEntry/onLoop/…)\n *\n * All event handlers are optional — implement only what you care about.\n * `id` is required so the library can deduplicate re-attaches.\n *\n * ## Shared method names (onError / onPause / onResume)\n *\n * Both `ScopeRecorder` and `FlowRecorder` declare these with DIFFERENT payload\n * shapes. In a combined recorder, each such handler is called by BOTH\n * channels with its own variant. The parameter type is a union — consumers\n * can either handle both variants uniformly, or discriminate (control-flow\n * variants carry a `traversalContext` field that data-flow variants lack).\n *\n * ## Forward compatibility\n *\n * When a third observer type ships (e.g. `OperationRecorder`), the type\n * gains another `& Partial<…>` clause. Because every clause is `Partial`,\n * existing `CombinedRecorder` implementations remain type-valid.\n */\nexport type CombinedRecorder = Partial<Omit<ScopeRecorder, SharedLifecycleOverlap | SharedLifecycle>> &\n  Partial<Omit<FlowRecorder, SharedLifecycleOverlap | SharedLifecycle>> &\n  // Emit channel — new third stream (Phase 3). No method-name overlap with\n  // the other two interfaces, so a plain intersection is sound — no\n  // union-payload discriminator needed.\n  Partial<Omit<EmitRecorder, SharedLifecycle>> & {\n    readonly id: string;\n\n    // Shared lifecycle hooks — same on both interfaces, shape compatible.\n    clear?(): void;\n    toSnapshot?(): {\n      name: string;\n      description?: string;\n      preferredOperation?: 'translate' | 'accumulate' | 'aggregate';\n      data: unknown;\n    };\n\n    // Shared event method names with DIVERGENT payloads — declared as unions.\n    // Consumers either handle both variants, or discriminate using the\n    // exported helper `isFlowEvent()` (which checks for the\n    // `traversalContext` field — present only on control-flow variants).\n    //\n    // @example\n    // ```ts\n    // const audit: CombinedRecorder = {\n    //   id: 'audit',\n    //   onError: (e) => {\n    //     if (isFlowEvent(e)) {\n    //       // e is FlowErrorEvent — has stageName, message, structuredError\n    //       log('flow error in stage', e.stageName);\n    //     } else {\n    //       // e is ErrorEvent — has error, operation, key?\n    //       log('scope error during', e.operation, e.error.message);\n    //     }\n    //   },\n    // };\n    // ```\n    onError?(event: ErrorEvent | FlowErrorEvent): void;\n    onPause?(event: PauseEvent | FlowPauseEvent): void;\n    onResume?(event: ResumeEvent | FlowResumeEvent): void;\n  };\n\n/**\n * Discriminator for the union payload types on `CombinedRecorder`'s shared\n * methods (`onError`, `onPause`, `onResume`). Returns `true` if the event\n * was emitted from the control-flow channel (FlowRecorder).\n *\n * ## How it discriminates\n *\n * Scope-channel events extend `RecorderContext`, which carries `pipelineId`.\n * Flow-channel events do not carry `pipelineId` (they carry an optional\n * `traversalContext` instead, but that field is optional and cannot be\n * relied on as a positive signal). We detect the flow variant by the\n * ABSENCE of `pipelineId` — this is schema-stable as long as scope events\n * continue to extend `RecorderContext`.\n *\n * @example\n * ```ts\n * onError: (e) => {\n *   if (isFlowEvent(e)) {\n *     // Narrowed to FlowErrorEvent: has stageName, message, structuredError\n *   } else {\n *     // Narrowed to ErrorEvent: has error, operation, key?\n *   }\n * }\n * ```\n */\nexport function isFlowEvent<T>(event: T): event is Exclude<T, { pipelineId: string }> {\n  if (typeof event !== 'object' || event === null) return false;\n  return (event as Record<string, unknown>).pipelineId === undefined;\n}\n\n/**\n * Method names belonging to the `ScopeRecorder` (data-flow) interface.\n * Kept as a single source of truth so the runtime duck-type detector stays\n * in sync with the interface. If a method is added to `ScopeRecorder`, adding it\n * here is the ONLY change required to route combined-recorders correctly.\n */\nconst RECORDER_EVENT_METHODS = [\n  'onRead',\n  'onWrite',\n  'onCommit',\n  'onError',\n  'onStageStart',\n  'onStageEnd',\n  'onPause',\n  'onResume',\n] as const;\n\n/**\n * Method names belonging to the `FlowRecorder` (control-flow) interface.\n * See the note on `RECORDER_EVENT_METHODS`.\n *\n * NOTE: the `onError`, `onPause`, `onResume` methods exist on BOTH interfaces\n * with DIFFERENT event payload shapes. A `CombinedRecorder` that implements\n * any of these receives both variants (one from each channel). Consumers who\n * care about the distinction can discriminate on the presence of\n * `traversalContext` (which only control-flow events carry).\n */\nconst FLOW_RECORDER_EVENT_METHODS = [\n  'onStageExecuted',\n  'onNext',\n  'onDecision',\n  'onFork',\n  'onSelected',\n  'onSubflowEntry',\n  'onSubflowExit',\n  'onSubflowRegistered',\n  'onLoop',\n  'onBreak',\n  'onError',\n  'onPause',\n  'onResume',\n  // Run-boundary methods — included so a recorder whose ONLY event hook\n  // is a run boundary (e.g. an error bridge implementing just\n  // `onRunFailed`) is still detected as a FlowRecorder and routed to the\n  // flow channel. Previously a run-only recorder was silently dropped.\n  'onRunStart',\n  'onRunEnd',\n  'onRunFailed',\n] as const;\n\n/**\n * Method names belonging to the `EmitRecorder` (user-emitted events)\n * interface. Same convention as the other two arrays above — kept as\n * the single source of truth for duck-type detection.\n */\nconst EMIT_RECORDER_EVENT_METHODS = ['onEmit'] as const;\n\n/**\n * True iff the recorder declares a method named `m` either as an own\n * property OR on its class-prototype chain — but NOT inherited from\n * `Object.prototype`.\n *\n * ## Why this layered check\n *\n * A `CombinedRecorder` can be either a plain object literal (handlers as\n * own properties) OR a class instance (handlers as class-prototype\n * methods). Both are legitimate consumer patterns and both MUST attach.\n *\n * But handlers inherited from `Object.prototype` are ALWAYS accidental or\n * malicious (nobody legitimately attaches recorder methods there). So we\n * walk the prototype chain, STOPPING before `Object.prototype`. This\n * accepts class methods while still blocking `Object.prototype`\n * pollution attacks.\n */\nfunction hasOwnOrClassMethod(r: unknown, m: string): boolean {\n  if (r === null || typeof r !== 'object') return false;\n  if (Object.prototype.hasOwnProperty.call(r, m)) {\n    return typeof (r as Record<string, unknown>)[m] === 'function';\n  }\n  let proto: unknown = Object.getPrototypeOf(r);\n  while (proto !== null && proto !== Object.prototype) {\n    if (Object.prototype.hasOwnProperty.call(proto, m)) {\n      return typeof (proto as Record<string, unknown>)[m] === 'function';\n    }\n    proto = Object.getPrototypeOf(proto);\n  }\n  return false;\n}\n\n/**\n * True iff the recorder implements at least one data-flow event method.\n * Used by `executor.attachCombinedRecorder` to decide whether to hook into\n * the scope data-flow channel.\n *\n * ## Detection rule\n *\n * Accepts both object-literal recorders (own-property handlers) AND class\n * instances (handlers declared on the class prototype). Rejects handlers\n * inherited from `Object.prototype` — that's always accidental or\n * malicious pollution, never a legitimate recorder.\n *\n * ## Lifecycle exclusions\n *\n * `clear` and `toSnapshot` are NOT counted as event methods — a recorder\n * that only implements those has nothing to observe and would be a no-op\n * on either channel.\n *\n * ## Return type\n *\n * Returns plain `boolean` (not a type predicate). The full `ScopeRecorder`\n * interface has payload types that diverge from `CombinedRecorder`'s union\n * variants for shared methods, so a narrowing predicate would be unsound.\n * Callers that need to treat the recorder as a `ScopeRecorder` do so explicitly\n * at the attach site — the cast is the contract that each channel passes\n * its own payload variant.\n */\nexport function hasRecorderMethods(r: CombinedRecorder): boolean {\n  return RECORDER_EVENT_METHODS.some((m) => hasOwnOrClassMethod(r, m));\n}\n\n/**\n * True iff the recorder implements at least one control-flow event method.\n * See `hasRecorderMethods`.\n */\nexport function hasFlowRecorderMethods(r: CombinedRecorder): boolean {\n  return FLOW_RECORDER_EVENT_METHODS.some((m) => hasOwnOrClassMethod(r, m));\n}\n\n/**\n * True iff the recorder implements at least one emit-channel event method.\n * See `hasRecorderMethods` for the ownership-detection rules (own or\n * class-prototype methods count; `Object.prototype` pollution does not).\n */\nexport function hasEmitRecorderMethods(r: CombinedRecorder): boolean {\n  return EMIT_RECORDER_EVENT_METHODS.some((m) => hasOwnOrClassMethod(r, m));\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CombinedRecorder.js","sourceRoot":"","sources":["../../../../src/lib/recorder/CombinedRecorder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AAqFH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,UAAU,WAAW,CAAI,KAAQ;IACrC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAC9D,MAAM,CAAC,GAAG,KAAgC,CAAC;IAC3C,IAAI,CAAC,CAAC,OAAO,KAAK,MAAM;QAAE,OAAO,IAAI,CAAC;IACtC,IAAI,CAAC,CAAC,OAAO,KAAK,OAAO;QAAE,OAAO,KAAK,CAAC;IACxC,OAAO,CAAC,CAAC,UAAU,KAAK,SAAS,CAAC;AACpC,CAAC;AAED;;;;;GAKG;AACH,MAAM,sBAAsB,GAAG;IAC7B,QAAQ;IACR,SAAS;IACT,UAAU;IACV,SAAS;IACT,cAAc;IACd,YAAY;IACZ,SAAS;IACT,UAAU;CACF,CAAC;AAEX;;;;;;;;;GASG;AACH,MAAM,2BAA2B,GAAG;IAClC,iBAAiB;IACjB,QAAQ;IACR,YAAY;IACZ,QAAQ;IACR,YAAY;IACZ,gBAAgB;IAChB,eAAe;IACf,qBAAqB;IACrB,QAAQ;IACR,SAAS;IACT,SAAS;IACT,SAAS;IACT,UAAU;IACV,sEAAsE;IACtE,4DAA4D;IAC5D,uEAAuE;IACvE,qEAAqE;IACrE,YAAY;IACZ,UAAU;IACV,aAAa;CACL,CAAC;AAEX;;;;GAIG;AACH,MAAM,2BAA2B,GAAG,CAAC,QAAQ,CAAU,CAAC;AAExD;;;;;;;;;;;;;;;;GAgBG;AACH,SAAS,mBAAmB,CAAC,CAAU,EAAE,CAAS;IAChD,IAAI,CAAC,KAAK,IAAI,IAAI,OAAO,CAAC,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IACtD,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;QAC/C,OAAO,OAAQ,CAA6B,CAAC,CAAC,CAAC,KAAK,UAAU,CAAC;IACjE,CAAC;IACD,IAAI,KAAK,GAAY,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IAC9C,OAAO,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,MAAM,CAAC,SAAS,EAAE,CAAC;QACpD,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC;YACnD,OAAO,OAAQ,KAAiC,CAAC,CAAC,CAAC,KAAK,UAAU,CAAC;QACrE,CAAC;QACD,KAAK,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;IACvC,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,kBAAkB,CAAC,CAAmB;IACpD,OAAO,sBAAsB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AACvE,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,sBAAsB,CAAC,CAAmB;IACxD,OAAO,2BAA2B,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAC5E,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,sBAAsB,CAAC,CAAmB;IACxD,OAAO,2BAA2B,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAC5E,CAAC","sourcesContent":["/**\n * CombinedRecorder — a single observer that can hook into MULTIPLE event\n * streams (currently: scope data-flow + control-flow). One object, one `id`,\n * one consistent view of the execution.\n *\n * ## Why this exists\n *\n * Before `CombinedRecorder`, a consumer who wanted to observe both streams\n * had to:\n *   1. Implement both `ScopeRecorder` (8 methods) and `FlowRecorder` (12 methods)\n *      fully — stubbing every event they didn't care about.\n *   2. Remember to call BOTH `attachScopeRecorder(r)` AND `attachFlowRecorder(r)`.\n *      Forgetting the second call silently dropped half their events — no\n *      warning, no runtime error.\n *   3. Re-implement coordination logic (buffering, ordering) themselves.\n *\n * `CombinedRecorder` collapses that into a single type and a single attach\n * call (`executor.attachCombinedRecorder(r)`), with the library handling the\n * routing internally. Consumers implement only the events they care about\n * (`Partial<...>`) and the attach method duck-types at runtime to dispatch\n * to the relevant channels.\n *\n * ## Forward compatibility\n *\n * When a third observer type is added (e.g. an `OperationRecorder`), the\n * `CombinedRecorder` type gains an `& Partial<OperationRecorder>` clause and\n * `attachCombinedRecorder` gains one more runtime branch in its dispatch.\n * Consumers writing a `CombinedRecorder` today are NOT affected — their\n * code keeps compiling and attaching correctly, because every new layer is\n * optional.\n *\n * ## Example\n *\n * ```typescript\n * import type { CombinedRecorder } from 'footprintjs';\n *\n * const audit: CombinedRecorder = {\n *   id: 'audit',\n *   onWrite: (e) => logWrite(e.key, e.value),        // ScopeRecorder method\n *   onDecision: (e) => logDecision(e.chosen),        // FlowRecorder method\n * };\n *\n * executor.attachCombinedRecorder(audit);\n * // ^ internally: detects both sets of methods, routes to both channels.\n * ```\n *\n * ## Contract with existing APIs\n *\n * - `attachScopeRecorder(r)` and `attachFlowRecorder(r)` remain unchanged.\n *   Consumers who want only ONE channel keep using them — explicit is good.\n * - `attachCombinedRecorder(r)` is the ONLY way to guarantee an object is\n *   hooked into every stream it has methods for, without maintaining two\n *   attach calls at the call site.\n * - Idempotency by `id` is preserved across channels: re-attaching with the\n *   same `id` replaces the previous instance on BOTH channels, not just one.\n */\n\nimport type { FlowErrorEvent, FlowPauseEvent, FlowRecorder, FlowResumeEvent } from '../engine/narrative/types.js';\nimport type { ErrorEvent, PauseEvent, ResumeEvent, ScopeRecorder } from '../scope/types.js';\nimport type { EmitRecorder } from './EmitRecorder.js';\n\n/**\n * Method names that appear on BOTH `ScopeRecorder` and `FlowRecorder` but with\n * different event payload types. For these, a `CombinedRecorder` declares\n * ONE handler that receives the union of both payloads — consumers\n * discriminate with the exported `isFlowEvent()` helper (explicit `channel`\n * discriminant, with a legacy pipelineId-absence fallback).\n */\ntype SharedLifecycleOverlap = 'onError' | 'onPause' | 'onResume';\n\n/** Lifecycle hooks (not event-specific) that both interfaces share identically. */\ntype SharedLifecycle = 'id' | 'clear' | 'toSnapshot';\n\n/**\n * A recorder that MAY observe any combination of supported event streams.\n *\n * Today's streams:\n *   - Scope data-flow (`ScopeRecorder`: onRead/onWrite/onCommit/onStageStart/…)\n *   - Control-flow (`FlowRecorder`: onDecision/onSubflowEntry/onLoop/…)\n *\n * All event handlers are optional — implement only what you care about.\n * `id` is required so the library can deduplicate re-attaches.\n *\n * ## Shared method names (onError / onPause / onResume)\n *\n * Both `ScopeRecorder` and `FlowRecorder` declare these with DIFFERENT payload\n * shapes. In a combined recorder, each such handler is called by BOTH\n * channels with its own variant. The parameter type is a union — consumers\n * can either handle both variants uniformly, or discriminate with\n * `isFlowEvent()` (explicit `channel` discriminant stamped by the engine).\n *\n * ## Forward compatibility\n *\n * When a third observer type ships (e.g. `OperationRecorder`), the type\n * gains another `& Partial<…>` clause. Because every clause is `Partial`,\n * existing `CombinedRecorder` implementations remain type-valid.\n */\nexport type CombinedRecorder = Partial<Omit<ScopeRecorder, SharedLifecycleOverlap | SharedLifecycle>> &\n  Partial<Omit<FlowRecorder, SharedLifecycleOverlap | SharedLifecycle>> &\n  // Emit channel — new third stream (Phase 3). No method-name overlap with\n  // the other two interfaces, so a plain intersection is sound — no\n  // union-payload discriminator needed.\n  Partial<Omit<EmitRecorder, SharedLifecycle>> & {\n    readonly id: string;\n\n    // Shared lifecycle hooks — same on both interfaces, shape compatible.\n    clear?(): void;\n    toSnapshot?(): {\n      name: string;\n      description?: string;\n      preferredOperation?: 'translate' | 'accumulate' | 'aggregate';\n      data: unknown;\n    };\n\n    // Shared event method names with DIVERGENT payloads — declared as unions.\n    // Consumers either handle both variants, or discriminate using the\n    // exported helper `isFlowEvent()` (which checks the explicit `channel`\n    // discriminant stamped by the engine, falling back to pipelineId\n    // absence for unstamped events).\n    //\n    // @example\n    // ```ts\n    // const audit: CombinedRecorder = {\n    //   id: 'audit',\n    //   onError: (e) => {\n    //     if (isFlowEvent(e)) {\n    //       // e is FlowErrorEvent — has stageName, message, structuredError\n    //       log('flow error in stage', e.stageName);\n    //     } else {\n    //       // e is ErrorEvent — has error, operation, key?\n    //       log('scope error during', e.operation, e.error.message);\n    //     }\n    //   },\n    // };\n    // ```\n    onError?(event: ErrorEvent | FlowErrorEvent): void;\n    onPause?(event: PauseEvent | FlowPauseEvent): void;\n    onResume?(event: ResumeEvent | FlowResumeEvent): void;\n  };\n\n/**\n * Discriminator for the union payload types on `CombinedRecorder`'s shared\n * methods (`onError`, `onPause`, `onResume`). Returns `true` if the event\n * was emitted from the control-flow channel (FlowRecorder).\n *\n * ## How it discriminates\n *\n * 1. **Explicit `channel` field first** (backlog B3): every engine-dispatched\n *    shared-method event is stamped `channel: 'flow'` (control-flow) or\n *    `channel: 'scope'` (data-flow) at construction. This is the positive,\n *    schema-robust signal — it survives wrappers that add/strip fields.\n * 2. **Legacy fallback** for unstamped events (consumer-fabricated tests,\n *    persisted traces from <9.2): scope-channel events extend\n *    `RecorderContext`, which carries `pipelineId`; flow-channel events do\n *    not. The flow variant is detected by the ABSENCE of `pipelineId` —\n *    schema-stable as long as scope events continue to extend\n *    `RecorderContext`, but fragile against field-stripping wrappers, which\n *    is why the explicit discriminant now exists.\n *\n * @example\n * ```ts\n * onError: (e) => {\n *   if (isFlowEvent(e)) {\n *     // Narrowed to FlowErrorEvent: has stageName, message, structuredError\n *   } else {\n *     // Narrowed to ErrorEvent: has error, operation, key?\n *   }\n * }\n * ```\n */\nexport function isFlowEvent<T>(event: T): event is Exclude<T, { pipelineId: string }> {\n  if (typeof event !== 'object' || event === null) return false;\n  const e = event as Record<string, unknown>;\n  if (e.channel === 'flow') return true;\n  if (e.channel === 'scope') return false;\n  return e.pipelineId === undefined;\n}\n\n/**\n * Method names belonging to the `ScopeRecorder` (data-flow) interface.\n * Kept as a single source of truth so the runtime duck-type detector stays\n * in sync with the interface. If a method is added to `ScopeRecorder`, adding it\n * here is the ONLY change required to route combined-recorders correctly.\n */\nconst RECORDER_EVENT_METHODS = [\n  'onRead',\n  'onWrite',\n  'onCommit',\n  'onError',\n  'onStageStart',\n  'onStageEnd',\n  'onPause',\n  'onResume',\n] as const;\n\n/**\n * Method names belonging to the `FlowRecorder` (control-flow) interface.\n * See the note on `RECORDER_EVENT_METHODS`.\n *\n * NOTE: the `onError`, `onPause`, `onResume` methods exist on BOTH interfaces\n * with DIFFERENT event payload shapes. A `CombinedRecorder` that implements\n * any of these receives both variants (one from each channel). Consumers who\n * care about the distinction discriminate with `isFlowEvent()` (explicit\n * `channel` discriminant, legacy pipelineId-absence fallback).\n */\nconst FLOW_RECORDER_EVENT_METHODS = [\n  'onStageExecuted',\n  'onNext',\n  'onDecision',\n  'onFork',\n  'onSelected',\n  'onSubflowEntry',\n  'onSubflowExit',\n  'onSubflowRegistered',\n  'onLoop',\n  'onBreak',\n  'onError',\n  'onPause',\n  'onResume',\n  // Run-boundary methods — included so a recorder whose ONLY event hook\n  // is a run boundary (e.g. an error bridge implementing just\n  // `onRunFailed`) is still detected as a FlowRecorder and routed to the\n  // flow channel. Previously a run-only recorder was silently dropped.\n  'onRunStart',\n  'onRunEnd',\n  'onRunFailed',\n] as const;\n\n/**\n * Method names belonging to the `EmitRecorder` (user-emitted events)\n * interface. Same convention as the other two arrays above — kept as\n * the single source of truth for duck-type detection.\n */\nconst EMIT_RECORDER_EVENT_METHODS = ['onEmit'] as const;\n\n/**\n * True iff the recorder declares a method named `m` either as an own\n * property OR on its class-prototype chain — but NOT inherited from\n * `Object.prototype`.\n *\n * ## Why this layered check\n *\n * A `CombinedRecorder` can be either a plain object literal (handlers as\n * own properties) OR a class instance (handlers as class-prototype\n * methods). Both are legitimate consumer patterns and both MUST attach.\n *\n * But handlers inherited from `Object.prototype` are ALWAYS accidental or\n * malicious (nobody legitimately attaches recorder methods there). So we\n * walk the prototype chain, STOPPING before `Object.prototype`. This\n * accepts class methods while still blocking `Object.prototype`\n * pollution attacks.\n */\nfunction hasOwnOrClassMethod(r: unknown, m: string): boolean {\n  if (r === null || typeof r !== 'object') return false;\n  if (Object.prototype.hasOwnProperty.call(r, m)) {\n    return typeof (r as Record<string, unknown>)[m] === 'function';\n  }\n  let proto: unknown = Object.getPrototypeOf(r);\n  while (proto !== null && proto !== Object.prototype) {\n    if (Object.prototype.hasOwnProperty.call(proto, m)) {\n      return typeof (proto as Record<string, unknown>)[m] === 'function';\n    }\n    proto = Object.getPrototypeOf(proto);\n  }\n  return false;\n}\n\n/**\n * True iff the recorder implements at least one data-flow event method.\n * Used by `executor.attachCombinedRecorder` to decide whether to hook into\n * the scope data-flow channel.\n *\n * ## Detection rule\n *\n * Accepts both object-literal recorders (own-property handlers) AND class\n * instances (handlers declared on the class prototype). Rejects handlers\n * inherited from `Object.prototype` — that's always accidental or\n * malicious pollution, never a legitimate recorder.\n *\n * ## Lifecycle exclusions\n *\n * `clear` and `toSnapshot` are NOT counted as event methods — a recorder\n * that only implements those has nothing to observe and would be a no-op\n * on either channel.\n *\n * ## Return type\n *\n * Returns plain `boolean` (not a type predicate). The full `ScopeRecorder`\n * interface has payload types that diverge from `CombinedRecorder`'s union\n * variants for shared methods, so a narrowing predicate would be unsound.\n * Callers that need to treat the recorder as a `ScopeRecorder` do so explicitly\n * at the attach site — the cast is the contract that each channel passes\n * its own payload variant.\n */\nexport function hasRecorderMethods(r: CombinedRecorder): boolean {\n  return RECORDER_EVENT_METHODS.some((m) => hasOwnOrClassMethod(r, m));\n}\n\n/**\n * True iff the recorder implements at least one control-flow event method.\n * See `hasRecorderMethods`.\n */\nexport function hasFlowRecorderMethods(r: CombinedRecorder): boolean {\n  return FLOW_RECORDER_EVENT_METHODS.some((m) => hasOwnOrClassMethod(r, m));\n}\n\n/**\n * True iff the recorder implements at least one emit-channel event method.\n * See `hasRecorderMethods` for the ownership-detection rules (own or\n * class-prototype methods count; `Object.prototype` pollution does not).\n */\nexport function hasEmitRecorderMethods(r: CombinedRecorder): boolean {\n  return EMIT_RECORDER_EVENT_METHODS.some((m) => hasOwnOrClassMethod(r, m));\n}\n"]}

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

@@ -58,6 +58,17 @@ export class ExecutionRuntime {
         this._initialState);
         this.rootStageContext.useRedactedMirror(this.redactedStore);
     }
+    /**
+     * Set the read-tracking policy (#14) on the root stage context. Descendant
+     * contexts inherit via `createNext`/`createChild`; subflow root contexts
+     * inherit from their parent-mount context via `SubflowExecutor`. Called by
+     * `FlowChartExecutor.createTraverser()` when the executor's policy is not
+     * the default `'full'` — including the resume path, where it is applied to
+     * the freshly-created continuation root.
+     */
+    useReadTracking(mode) {
+        this.rootStageContext.useReadTracking(mode);
+    }
     /** Preserve the current rootStageContext for snapshots before changing it for resume. */
     preserveSnapshotRoot() {
         if (!this._snapshotRoot) {
@@ -98,4 +109,4 @@ export class ExecutionRuntime {
         };
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ExecutionRuntime.js","sourceRoot":"","sources":["../../../../src/lib/runner/ExecutionRuntime.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAwBzD,MAAM,OAAO,gBAAgB;IACpB,WAAW,CAAe;IACjC;;;;;;;;OAQG;IACI,aAAa,CAAgB;IAC7B,gBAAgB,CAAe;IAC/B,gBAAgB,CAAW;IAClC,oFAAoF;IAC5E,aAAa,CAAgB;IAC7B,aAAa,CAAU;IACvB,cAAc,CAAU;IAEhC,YAAY,QAAgB,EAAE,MAAc,EAAE,aAAuB,EAAE,YAAsB;QAC3F,IAAI,CAAC,aAAa,GAAG,YAAY,CAAC;QAClC,IAAI,CAAC,cAAc,GAAG,aAAa,CAAC;QACpC,IAAI,CAAC,gBAAgB,GAAG,IAAI,QAAQ,CAAC,YAAY,CAAC,CAAC;QACnD,IAAI,CAAC,WAAW,GAAG,IAAI,YAAY,CAAC,aAAa,EAAE,YAAY,CAAC,CAAC;QACjE,IAAI,CAAC,gBAAgB,GAAG,IAAI,YAAY,CAAC,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,WAAW,EAAE,EAAE,EAAE,IAAI,CAAC,gBAAgB,CAAC,CAAC;IAC9G,CAAC;IAED;;;;;;;;;;OAUG;IACH,oBAAoB;QAClB,IAAI,IAAI,CAAC,aAAa;YAAE,OAAO,CAAC,aAAa;QAC7C,IAAI,CAAC,aAAa,GAAG,IAAI,YAAY,CACnC,IAAI,CAAC,cAAc;QACnB,kEAAkE;QAClE,oEAAoE;QACpE,+BAA+B;QAC/B,IAAI,CAAC,aAAa,CACnB,CAAC;QACF,IAAI,CAAC,gBAAgB,CAAC,iBAAiB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IAC9D,CAAC;IAED,yFAAyF;IACzF,oBAAoB;QAClB,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;YACxB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,gBAAgB,CAAC;QAC7C,CAAC;IACH,CAAC;IAED,YAAY;QACV,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC;QAC1C,OAAO,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,SAAoC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IACxF,CAAC;IAED,aAAa,CAAC,IAAc,EAAE,GAAW,EAAE,KAAc;QACvD,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;IACpD,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,WAAW,CAAC,OAA8B;QACxC,MAAM,YAAY,GAAG,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,gBAAgB,CAAC;QACjE,MAAM,WAAW,GAAG,OAAO,EAAE,MAAM,KAAK,IAAI,IAAI,IAAI,CAAC,aAAa,KAAK,SAAS,CAAC;QACjF,OAAO;YACL,WAAW,EAAE,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,aAAc,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE;YACvF,aAAa,EAAE,YAAY,CAAC,WAAW,EAAE;YACzC,SAAS,EAAE,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE;SACxC,CAAC;IACJ,CAAC;CACF","sourcesContent":["/**\n * ExecutionRuntime — The runtime environment for one flowchart execution.\n *\n * Wires up the three memory primitives into a single container:\n *   - SharedMemory (the heap — shared state across all stages)\n *   - StageContext  (the call stack — per-stage execution tree)\n *   - EventLog      (the transaction log — commit history for replay)\n *\n * The engine (FlowchartTraverser) receives this as its runtime parameter.\n * After execution, consumers query it for the full execution state.\n */\n\nimport { EventLog } from '../memory/EventLog.js';\nimport { SharedMemory } from '../memory/SharedMemory.js';\nimport { StageContext } from '../memory/StageContext.js';\nimport type { CommitBundle, StageSnapshot } from '../memory/types.js';\n\n/** Snapshot of a single recorder's collected data. */\nexport interface RecorderSnapshot {\n  id: string;\n  name: string;\n  /** ScopeRecorder type and pattern description (e.g., \"Translator (KeyedStore) — per-step token usage\"). */\n  description?: string;\n  /** Preferred read-time operation — hints the UI about which view to show prominently. */\n  preferredOperation?: 'translate' | 'accumulate' | 'aggregate';\n  data: unknown;\n}\n\nexport type RuntimeSnapshot = {\n  sharedState: Record<string, unknown>;\n  executionTree: StageSnapshot;\n  commitLog: CommitBundle[];\n  /** Per-subflow execution results (keyed by subflowId). */\n  subflowResults?: Record<string, unknown>;\n  /** Snapshot data from recorders that implement toSnapshot(). */\n  recorders?: RecorderSnapshot[];\n};\n\nexport class ExecutionRuntime {\n  public globalStore: SharedMemory;\n  /**\n   * Parallel redacted mirror of `globalStore`. Populated during traversal via\n   * `StageContext.commit()` using the already-computed redacted patches.\n   * Only exists when `enableRedactedMirror()` has been called — typically by\n   * `FlowChartExecutor` when a `RedactionPolicy` is configured. Otherwise\n   * undefined and zero cost.\n   *\n   * Read via `getSnapshot({ redact: true })`.\n   */\n  public redactedStore?: SharedMemory;\n  public rootStageContext: StageContext;\n  public executionHistory: EventLog;\n  /** Original root for getSnapshot() — set before resume changes rootStageContext. */\n  private _snapshotRoot?: StageContext;\n  private _initialState: unknown;\n  private _defaultValues: unknown;\n\n  constructor(rootName: string, rootId: string, defaultValues?: unknown, initialState?: unknown) {\n    this._initialState = initialState;\n    this._defaultValues = defaultValues;\n    this.executionHistory = new EventLog(initialState);\n    this.globalStore = new SharedMemory(defaultValues, initialState);\n    this.rootStageContext = new StageContext('', rootName, rootId, this.globalStore, '', this.executionHistory);\n  }\n\n  /**\n   * Opt in to maintaining a parallel redacted mirror of `globalStore`. After\n   * this call, every `StageContext.commit()` in the run writes the redacted\n   * patches (the same ones fed to the event log) into `redactedStore` in\n   * addition to the raw ones written to `globalStore`.\n   *\n   * The mirror is created lazily and propagated into all child / next\n   * contexts, so it correctly reflects subflow-scope writes. When no\n   * `RedactionPolicy` is configured, callers should skip this — unused\n   * allocation, no functional difference in the snapshot.\n   */\n  enableRedactedMirror(): void {\n    if (this.redactedStore) return; // idempotent\n    this.redactedStore = new SharedMemory(\n      this._defaultValues,\n      // Seed with the same initial state as the raw store so the mirror\n      // starts from a scrubbed-nothing baseline; subsequent commits apply\n      // the redacted patches on top.\n      this._initialState,\n    );\n    this.rootStageContext.useRedactedMirror(this.redactedStore);\n  }\n\n  /** Preserve the current rootStageContext for snapshots before changing it for resume. */\n  preserveSnapshotRoot(): void {\n    if (!this._snapshotRoot) {\n      this._snapshotRoot = this.rootStageContext;\n    }\n  }\n\n  getPipelines(): string[] {\n    const state = this.globalStore.getState();\n    return state.pipelines ? Object.keys(state.pipelines as Record<string, unknown>) : [];\n  }\n\n  setRootObject(path: string[], key: string, value: unknown) {\n    this.rootStageContext.setObject(path, key, value);\n  }\n\n  /**\n   * Return the runtime snapshot.\n   *\n   * @param options.redact  When `true`, returns `sharedState` from the\n   *   parallel redacted mirror (if one was enabled). This is the safe view\n   *   for sharing traces externally — paste into a viewer, ship to support,\n   *   etc. When the mirror was never enabled, falls back to raw `globalStore`\n   *   and a dev-mode warning is emitted (silent in production).\n   *\n   *   Default `false` preserves the runtime view — necessary for pause /\n   *   resume (resumption must replay against the real values, not\n   *   '[REDACTED]').\n   *\n   * Other fields (`executionTree`, `commitLog`) are the same either way —\n   * the commit log is already redacted at write-time, and the execution\n   * tree only carries structural metadata.\n   */\n  getSnapshot(options?: { redact?: boolean }): RuntimeSnapshot {\n    const snapshotRoot = this._snapshotRoot ?? this.rootStageContext;\n    const useRedacted = options?.redact === true && this.redactedStore !== undefined;\n    return {\n      sharedState: useRedacted ? this.redactedStore!.getState() : this.globalStore.getState(),\n      executionTree: snapshotRoot.getSnapshot(),\n      commitLog: this.executionHistory.list(),\n    };\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ExecutionRuntime.js","sourceRoot":"","sources":["../../../../src/lib/runner/ExecutionRuntime.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAwBzD,MAAM,OAAO,gBAAgB;IACpB,WAAW,CAAe;IACjC;;;;;;;;OAQG;IACI,aAAa,CAAgB;IAC7B,gBAAgB,CAAe;IAC/B,gBAAgB,CAAW;IAClC,oFAAoF;IAC5E,aAAa,CAAgB;IAC7B,aAAa,CAAU;IACvB,cAAc,CAAU;IAEhC,YAAY,QAAgB,EAAE,MAAc,EAAE,aAAuB,EAAE,YAAsB;QAC3F,IAAI,CAAC,aAAa,GAAG,YAAY,CAAC;QAClC,IAAI,CAAC,cAAc,GAAG,aAAa,CAAC;QACpC,IAAI,CAAC,gBAAgB,GAAG,IAAI,QAAQ,CAAC,YAAY,CAAC,CAAC;QACnD,IAAI,CAAC,WAAW,GAAG,IAAI,YAAY,CAAC,aAAa,EAAE,YAAY,CAAC,CAAC;QACjE,IAAI,CAAC,gBAAgB,GAAG,IAAI,YAAY,CAAC,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,WAAW,EAAE,EAAE,EAAE,IAAI,CAAC,gBAAgB,CAAC,CAAC;IAC9G,CAAC;IAED;;;;;;;;;;OAUG;IACH,oBAAoB;QAClB,IAAI,IAAI,CAAC,aAAa;YAAE,OAAO,CAAC,aAAa;QAC7C,IAAI,CAAC,aAAa,GAAG,IAAI,YAAY,CACnC,IAAI,CAAC,cAAc;QACnB,kEAAkE;QAClE,oEAAoE;QACpE,+BAA+B;QAC/B,IAAI,CAAC,aAAa,CACnB,CAAC;QACF,IAAI,CAAC,gBAAgB,CAAC,iBAAiB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IAC9D,CAAC;IAED;;;;;;;OAOG;IACH,eAAe,CAAC,IAAsB;QACpC,IAAI,CAAC,gBAAgB,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;IAC9C,CAAC;IAED,yFAAyF;IACzF,oBAAoB;QAClB,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;YACxB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,gBAAgB,CAAC;QAC7C,CAAC;IACH,CAAC;IAED,YAAY;QACV,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC;QAC1C,OAAO,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,SAAoC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IACxF,CAAC;IAED,aAAa,CAAC,IAAc,EAAE,GAAW,EAAE,KAAc;QACvD,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;IACpD,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,WAAW,CAAC,OAA8B;QACxC,MAAM,YAAY,GAAG,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,gBAAgB,CAAC;QACjE,MAAM,WAAW,GAAG,OAAO,EAAE,MAAM,KAAK,IAAI,IAAI,IAAI,CAAC,aAAa,KAAK,SAAS,CAAC;QACjF,OAAO;YACL,WAAW,EAAE,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,aAAc,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE;YACvF,aAAa,EAAE,YAAY,CAAC,WAAW,EAAE;YACzC,SAAS,EAAE,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE;SACxC,CAAC;IACJ,CAAC;CACF","sourcesContent":["/**\n * ExecutionRuntime — The runtime environment for one flowchart execution.\n *\n * Wires up the three memory primitives into a single container:\n *   - SharedMemory (the heap — shared state across all stages)\n *   - StageContext  (the call stack — per-stage execution tree)\n *   - EventLog      (the transaction log — commit history for replay)\n *\n * The engine (FlowchartTraverser) receives this as its runtime parameter.\n * After execution, consumers query it for the full execution state.\n */\n\nimport { EventLog } from '../memory/EventLog.js';\nimport { SharedMemory } from '../memory/SharedMemory.js';\nimport { StageContext } from '../memory/StageContext.js';\nimport type { CommitBundle, ReadTrackingMode, StageSnapshot } from '../memory/types.js';\n\n/** Snapshot of a single recorder's collected data. */\nexport interface RecorderSnapshot {\n  id: string;\n  name: string;\n  /** ScopeRecorder type and pattern description (e.g., \"Translator (KeyedStore) — per-step token usage\"). */\n  description?: string;\n  /** Preferred read-time operation — hints the UI about which view to show prominently. */\n  preferredOperation?: 'translate' | 'accumulate' | 'aggregate';\n  data: unknown;\n}\n\nexport type RuntimeSnapshot = {\n  sharedState: Record<string, unknown>;\n  executionTree: StageSnapshot;\n  commitLog: CommitBundle[];\n  /** Per-subflow execution results (keyed by subflowId). */\n  subflowResults?: Record<string, unknown>;\n  /** Snapshot data from recorders that implement toSnapshot(). */\n  recorders?: RecorderSnapshot[];\n};\n\nexport class ExecutionRuntime {\n  public globalStore: SharedMemory;\n  /**\n   * Parallel redacted mirror of `globalStore`. Populated during traversal via\n   * `StageContext.commit()` using the already-computed redacted patches.\n   * Only exists when `enableRedactedMirror()` has been called — typically by\n   * `FlowChartExecutor` when a `RedactionPolicy` is configured. Otherwise\n   * undefined and zero cost.\n   *\n   * Read via `getSnapshot({ redact: true })`.\n   */\n  public redactedStore?: SharedMemory;\n  public rootStageContext: StageContext;\n  public executionHistory: EventLog;\n  /** Original root for getSnapshot() — set before resume changes rootStageContext. */\n  private _snapshotRoot?: StageContext;\n  private _initialState: unknown;\n  private _defaultValues: unknown;\n\n  constructor(rootName: string, rootId: string, defaultValues?: unknown, initialState?: unknown) {\n    this._initialState = initialState;\n    this._defaultValues = defaultValues;\n    this.executionHistory = new EventLog(initialState);\n    this.globalStore = new SharedMemory(defaultValues, initialState);\n    this.rootStageContext = new StageContext('', rootName, rootId, this.globalStore, '', this.executionHistory);\n  }\n\n  /**\n   * Opt in to maintaining a parallel redacted mirror of `globalStore`. After\n   * this call, every `StageContext.commit()` in the run writes the redacted\n   * patches (the same ones fed to the event log) into `redactedStore` in\n   * addition to the raw ones written to `globalStore`.\n   *\n   * The mirror is created lazily and propagated into all child / next\n   * contexts, so it correctly reflects subflow-scope writes. When no\n   * `RedactionPolicy` is configured, callers should skip this — unused\n   * allocation, no functional difference in the snapshot.\n   */\n  enableRedactedMirror(): void {\n    if (this.redactedStore) return; // idempotent\n    this.redactedStore = new SharedMemory(\n      this._defaultValues,\n      // Seed with the same initial state as the raw store so the mirror\n      // starts from a scrubbed-nothing baseline; subsequent commits apply\n      // the redacted patches on top.\n      this._initialState,\n    );\n    this.rootStageContext.useRedactedMirror(this.redactedStore);\n  }\n\n  /**\n   * Set the read-tracking policy (#14) on the root stage context. Descendant\n   * contexts inherit via `createNext`/`createChild`; subflow root contexts\n   * inherit from their parent-mount context via `SubflowExecutor`. Called by\n   * `FlowChartExecutor.createTraverser()` when the executor's policy is not\n   * the default `'full'` — including the resume path, where it is applied to\n   * the freshly-created continuation root.\n   */\n  useReadTracking(mode: ReadTrackingMode): void {\n    this.rootStageContext.useReadTracking(mode);\n  }\n\n  /** Preserve the current rootStageContext for snapshots before changing it for resume. */\n  preserveSnapshotRoot(): void {\n    if (!this._snapshotRoot) {\n      this._snapshotRoot = this.rootStageContext;\n    }\n  }\n\n  getPipelines(): string[] {\n    const state = this.globalStore.getState();\n    return state.pipelines ? Object.keys(state.pipelines as Record<string, unknown>) : [];\n  }\n\n  setRootObject(path: string[], key: string, value: unknown) {\n    this.rootStageContext.setObject(path, key, value);\n  }\n\n  /**\n   * Return the runtime snapshot.\n   *\n   * @param options.redact  When `true`, returns `sharedState` from the\n   *   parallel redacted mirror (if one was enabled). This is the safe view\n   *   for sharing traces externally — paste into a viewer, ship to support,\n   *   etc. When the mirror was never enabled, falls back to raw `globalStore`\n   *   and a dev-mode warning is emitted (silent in production).\n   *\n   *   Default `false` preserves the runtime view — necessary for pause /\n   *   resume (resumption must replay against the real values, not\n   *   '[REDACTED]').\n   *\n   * Other fields (`executionTree`, `commitLog`) are the same either way —\n   * the commit log is already redacted at write-time, and the execution\n   * tree only carries structural metadata.\n   */\n  getSnapshot(options?: { redact?: boolean }): RuntimeSnapshot {\n    const snapshotRoot = this._snapshotRoot ?? this.rootStageContext;\n    const useRedacted = options?.redact === true && this.redactedStore !== undefined;\n    return {\n      sharedState: useRedacted ? this.redactedStore!.getState() : this.globalStore.getState(),\n      executionTree: snapshotRoot.getSnapshot(),\n      commitLog: this.executionHistory.list(),\n    };\n  }\n}\n"]}