footprintjs 4.17.2 → 5.0.0

package/dist/lib/reactive/types.js

@@ -25,9 +25,9 @@ exports.SCOPE_METHOD_NAMES = new Set([
     '$error',
     '$metric',
     '$eval',
-    '$attachRecorder',
-    '$detachRecorder',
-    '$getRecorders',
+    '$attachScopeRecorder',
+    '$detachScopeRecorder',
+    '$getScopeRecorders',
     '$batchArray',
     '$break',
     '$emit',
@@ -51,10 +51,10 @@ exports.EXECUTOR_INTERNAL_METHODS = new Set([
     'notifyStageStart', // StageRunner.run() line 59
     'notifyStageEnd', // StageRunner.run() line 79
     'notifyPause', // StageRunner.run() — pause detection
-    'attachRecorder', // FlowChartExecutor.createTraverser() — narrative + user recorders
-    'detachRecorder', // FlowChartExecutor.detachRecorder()
-    'getRecorders', // FlowChartExecutor.getRecorders()
+    'attachScopeRecorder', // FlowChartExecutor.createTraverser() — narrative + user recorders
+    'detachScopeRecorder', // FlowChartExecutor.detachScopeRecorder()
+    'getScopeRecorders', // FlowChartExecutor.getScopeRecorders()
     'useSharedRedactedKeys', // FlowChartExecutor.createTraverser() — redaction wrapping
     'useRedactionPolicy', // FlowChartExecutor.createTraverser() — redaction wrapping
 ]);
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/lib/reactive/types.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;AA0PH,+EAA+E;AAC/E,uEAAuE;AAE1D,QAAA,kBAAkB,GAAG,IAAI,GAAG,CAAS;IAChD,WAAW;IACX,WAAW;IACX,SAAS;IACT,SAAS;IACT,OAAO;IACP,UAAU;IACV,SAAS;IACT,QAAQ;IACR,MAAM;IACN,QAAQ;IACR,SAAS;IACT,OAAO;IACP,iBAAiB;IACjB,iBAAiB;IACjB,eAAe;IACf,aAAa;IACb,QAAQ;IACR,OAAO;IACP,qBAAqB;IACrB,kBAAkB;IAClB,QAAQ;CACT,CAAC,CAAC;AAEH,+EAA+E;AAC/E,gEAAgE;AAChE,qEAAqE;AAExD,QAAA,YAAY,GAAG,MAAM,CAAC,6BAA6B,CAAC,CAAC;AAElE,+EAA+E;AAC/E,6EAA6E;AAC7E,+CAA+C;AAElC,QAAA,cAAc,GAAG,MAAM,CAAC,iCAAiC,CAAC,CAAC;AAExE,+EAA+E;AAC/E,gFAAgF;AAChF,0EAA0E;AAC1E,0EAA0E;AAE7D,QAAA,yBAAyB,GAAG,IAAI,GAAG,CAAC;IAC/C,kBAAkB,EAAE,4BAA4B;IAChD,gBAAgB,EAAE,4BAA4B;IAC9C,aAAa,EAAE,sCAAsC;IACrD,gBAAgB,EAAE,mEAAmE;IACrF,gBAAgB,EAAE,qCAAqC;IACvD,cAAc,EAAE,mCAAmC;IACnD,uBAAuB,EAAE,2DAA2D;IACpF,oBAAoB,EAAE,2DAA2D;CAClF,CAAC,CAAC","sourcesContent":["/**\n * reactive/types -- Type definitions for the TypedScope<T> reactive proxy system.\n *\n * TypedScope<T> wraps a ReactiveTarget (ScopeFacade) in a Proxy that provides\n * typed property access. All scope infrastructure methods are $-prefixed to\n * avoid collisions with user state keys.\n *\n * Dependency: type-only imports from engine/ and scope/ (zero runtime cost).\n */\n\nimport type { ExecutionEnv } from '../engine/types.js';\nimport type { Recorder } from '../scope/types.js';\n\n// -- ReactiveTarget ----------------------------------------------------------\n// Minimum protocol required by TypedScope -- a curated subset of ScopeFacade's\n// public API. Not a full mirror: excludes internal/redaction methods that are\n// handled at the executor level (useRedactionPolicy, useSharedRedactedKeys, etc.)\n// and infrastructure methods (getPipelineId, setGlobal, getGlobal, etc.).\n\nexport interface ReactiveTarget {\n  // State access (tracked by recorders)\n  getValue(key?: string): unknown;\n  setValue(key: string, value: unknown, shouldRedact?: boolean, description?: string): void;\n  updateValue(key: string, value: unknown, description?: string): void;\n  deleteValue(key: string, description?: string): void;\n\n  // Non-tracking state inspection (for proxy internals — no recorder dispatch)\n  /** Returns all state keys without firing onRead. Used by ownKeys/has traps. */\n  getStateKeys?(): string[];\n  /** Check key existence without firing onRead. Used by has trap. */\n  hasKey?(key: string): boolean;\n  /** Read state without firing onRead. Used by array proxy getCurrent(). */\n  getValueSilent?(key?: string): unknown;\n\n  // Input & environment (readonly, NOT tracked)\n  getArgs<T = Record<string, unknown>>(): T;\n  getEnv(): Readonly<ExecutionEnv>;\n\n  // Recorder management\n  attachRecorder(recorder: Recorder): void;\n  detachRecorder(recorderId: string): void;\n  getRecorders(): Recorder[];\n\n  // Diagnostics\n  addDebugInfo(key: string, value: unknown): void;\n  addDebugMessage(value: unknown): void;\n  addErrorInfo(key: string, value: unknown): void;\n  addMetric(name: string, value: unknown): void;\n  addEval(name: string, value: unknown): void;\n\n  // Emit channel (Phase 3) — structured user-authored events to EmitRecorders.\n  emitEvent(name: string, payload?: unknown): void;\n\n  // Detach (T4) — fire-and-forget child flowcharts. ScopeFacade\n  // delegates to `detach/spawn`, minting refIds from this stage's\n  // runtimeStageId for diagnostic correlation.\n  detachAndJoinLater(\n    driver: import('../detach/types.js').DetachDriver,\n    child: import('../builder/types.js').FlowChart,\n    input?: unknown,\n  ): import('../detach/types.js').DetachHandle;\n\n  detachAndForget(\n    driver: import('../detach/types.js').DetachDriver,\n    child: import('../builder/types.js').FlowChart,\n    input?: unknown,\n  ): void;\n}\n\n// -- ScopeMethods ------------------------------------------------------------\n// $-prefixed escape hatches. Non-enumerable on the proxy -- don't appear in\n// Object.keys(), destructuring, or for...in. Only state keys are visible.\n\nexport interface ScopeMethods {\n  // State (untyped escape hatch -- for dynamic keys, redaction, description)\n  $getValue(key: string): unknown;\n  $setValue(key: string, value: unknown, shouldRedact?: boolean, description?: string): void;\n  $update(key: string, value: unknown, description?: string): void;\n  $delete(key: string, description?: string): void;\n  /** Proxy-synthesized: calls getValue(rootKey) then lodash.get for nested path. Not a direct delegation. */\n  $read(dotPath: string): unknown;\n\n  // Input & environment (readonly)\n  $getArgs<T = Record<string, unknown>>(): T;\n  $getEnv(): Readonly<ExecutionEnv>;\n\n  // Observability — legacy diagnostic primitives.\n  //\n  // As of Phase 3 these ALSO dispatch on the emit channel (in addition to\n  // their existing `DiagnosticCollector` side-bag writes for snapshot\n  // inclusion). Any attached `EmitRecorder` will see these events with\n  // the corresponding namespaced names:\n  //\n  //   $debug(key, value)    -> emits `log.debug.${key}`\n  //   $error(key, value)    -> emits `log.error.${key}`\n  //   $metric(name, value)  -> emits `metric.${name}`\n  //   $eval (name, value)   -> emits `eval.${name}`\n  //   $log(value)           -> emits `log.debug.messages`\n  //\n  // This makes the calls observable in real time — no loss of backward\n  // compat; the side bag continues to populate for consumers that inspect\n  // the snapshot directly.\n  $debug(key: string, value: unknown): void;\n  $log(value: unknown): void;\n  $error(key: string, value: unknown): void;\n  $metric(name: string, value: unknown): void;\n  $eval(name: string, value: unknown): void;\n\n  // Recorder management\n  $attachRecorder(recorder: Recorder): void;\n  $detachRecorder(recorderId: string): void;\n  $getRecorders(): Recorder[];\n\n  /**\n   * Batch-mutate an array key in a single clone+write cycle.\n   *\n   * Every `scope.items.push(x)` clones the entire array and commits it — O(N) per call.\n   * For N mutations on an M-length array that is O(N×M). Use `$batchArray` to clone once,\n   * apply all mutations inside `fn`, then commit once — O(M) total.\n   *\n   * ```typescript\n   * // Before: 1000 clones × growing array = O(N²)\n   * for (let i = 0; i < 1000; i++) scope.items.push(i);\n   *\n   * // After: 1 clone + 1 commit = O(N)\n   * scope.$batchArray('items', (arr) => {\n   *   for (let i = 0; i < 1000; i++) arr.push(i);\n   * });\n   * ```\n   *\n   * `fn` receives a plain (non-proxy) mutable **shallow copy** of the current array.\n   * The array itself is a new instance, but object references inside it are shared with\n   * the original state — mutations to nested objects inside `fn` affect those originals.\n   * Only push/pop/sort/splice and other operations that change the array's own slots are\n   * safely isolated.\n   *\n   * Mutations inside `fn` are NOT tracked individually — only the final committed array\n   * appears in the narrative as a single write. If the key does not exist or is not an\n   * array, `fn` receives an empty array and the result is committed as the new value.\n   *\n   * If `fn` throws, `setValue` is never called and state remains unchanged (atomic on\n   * error). The exception propagates to the caller.\n   *\n   * `key` is untyped (`string`) — TypeScript will not catch typos. `arr` is typed as\n   * `unknown[]` because `ScopeMethods` is not parameterized by `T`; cast inside `fn`\n   * when element types are known: `(arr as string[]).push(x)`.\n   */\n  $batchArray(key: string, fn: (arr: unknown[]) => void): void;\n\n  // Observability — Emit channel (Phase 3)\n  /**\n   * Fire a structured event to every attached recorder implementing\n   * `onEmit`. The primary primitive for consumer-authored observability\n   * events (LLM tokens, billing metrics, domain milestones, etc.) that\n   * shouldn't live in scope state.\n   *\n   * Synchronous, pass-through — delivered to recorders immediately, in\n   * call order. Zero-allocation when no recorders are attached.\n   *\n   * ## Naming convention\n   *\n   * Use hierarchical dotted names: `'<namespace>.<category>.<event>'`.\n   * Examples:\n   *   - `'agentfootprint.llm.tokens'`\n   *   - `'myapp.billing.spend'`\n   *   - `'auth.check.denied'`\n   *\n   * The library stays vocabulary-agnostic — no central registry, no\n   * reserved prefixes. Namespace prefixes prevent collisions across\n   * libraries and apps naturally.\n   *\n   * ## Redaction\n   *\n   * If `RedactionPolicy.emitPatterns` matches the name, the payload is\n   * replaced with `'[REDACTED]'` before dispatch. No recorder ever sees\n   * the raw value for redacted event names.\n   *\n   * @param name - Consumer-chosen event identifier (see naming convention).\n   * @param payload - Structured data to attach. Shape is up to the\n   *   consumer; library treats it as opaque.\n   *\n   * @example\n   * ```typescript\n   * scope.$emit('agentfootprint.llm.tokens', { input: 100, output: 50 });\n   * scope.$emit('myapp.decision', { branch: 'approved', confidence: 0.92 });\n   * ```\n   */\n  $emit(name: string, payload?: unknown): void;\n\n  // Detach — fire-and-forget child flowchart execution.\n  //\n  // `$detachAndJoinLater(driver, child, input?)` schedules the child via\n  // the given driver and returns a `DetachHandle` the consumer can read\n  // synchronously (`.status`) or await (`.wait()`). The parent stage\n  // does NOT block on the child — it returns to the agent loop the\n  // moment the driver's `schedule()` returns (passive recorder rule).\n  //\n  // `$detachAndForget(driver, child, input?)` discards the handle —\n  // useful for fire-and-forget telemetry where the caller never needs\n  // to know how the child finished. Errors still land on the (now-\n  // dropped) handle and go silent unless an observer surfaces them.\n  //\n  // Driver is REQUIRED — there's no library-default. Pass e.g.\n  // `microtaskBatchDriver` (from 'footprintjs/detach') or your own\n  // custom driver. Explicit passing avoids global state and keeps the\n  // engine free of driver imports.\n  $detachAndJoinLater(\n    driver: import('../detach/types.js').DetachDriver,\n    child: import('../builder/types.js').FlowChart,\n    input?: unknown,\n  ): import('../detach/types.js').DetachHandle;\n\n  $detachAndForget(\n    driver: import('../detach/types.js').DetachDriver,\n    child: import('../builder/types.js').FlowChart,\n    input?: unknown,\n  ): void;\n\n  // Pipeline control\n  /**\n   * Stop the current execution context.\n   *\n   * - **In a top-level chart:** the traverser exits cleanly after this stage\n   *   completes.\n   * - **Inside a subflow:** by default, only the subflow's own execution\n   *   stops; control returns to the parent as normal. If the subflow is\n   *   mounted with `propagateBreak: true`, the break signal (and its\n   *   optional reason) propagates up to the parent scope, terminating the\n   *   outer loop too. See `SubflowMountOptions.propagateBreak`.\n   *\n   * @param reason - Optional free-form string describing why the break\n   *   happened. Propagates to `FlowBreakEvent.reason` so recorders and\n   *   custom narratives can surface it. Defaults to undefined.\n   */\n  $break(reason?: string): void;\n\n  // Escape hatch -- unwrap to underlying ReactiveTarget\n  $toRaw(): ReactiveTarget;\n}\n\n// -- TypedScope<T> -----------------------------------------------------------\n// The consumer-facing type. T is the user's state interface.\n// Property access is typed; $-methods provide escape hatches.\n\nexport type TypedScope<T extends object = Record<string, unknown>> = T & ScopeMethods;\n\n// -- ReactiveOptions ---------------------------------------------------------\n// Configuration passed to createTypedScope.\n\nexport interface ReactiveOptions {\n  /**\n   * Pipeline break function — injected by StageRunner after scope creation.\n   * Accepts an optional reason string that propagates to `FlowBreakEvent`\n   * and (when `propagateBreak` is set on a mount) up to the parent scope.\n   */\n  breakPipeline?: (reason?: string) => void;\n}\n\n// -- Internal: $-method name set ---------------------------------------------\n// Used by the Proxy get trap to distinguish $-methods from state keys.\n\nexport const SCOPE_METHOD_NAMES = new Set<string>([\n  '$getValue',\n  '$setValue',\n  '$update',\n  '$delete',\n  '$read',\n  '$getArgs',\n  '$getEnv',\n  '$debug',\n  '$log',\n  '$error',\n  '$metric',\n  '$eval',\n  '$attachRecorder',\n  '$detachRecorder',\n  '$getRecorders',\n  '$batchArray',\n  '$break',\n  '$emit',\n  '$detachAndJoinLater',\n  '$detachAndForget',\n  '$toRaw',\n]);\n\n// -- Internal: Symbol for deferred break injection ---------------------------\n// StageRunner sets this after scope creation so $break() works.\n// Private Symbol (not Symbol.for) to prevent cross-module tampering.\n\nexport const BREAK_SETTER = Symbol('footprint:reactive:setBreak');\n\n// -- Internal: Symbol for TypedScope detection -------------------------------\n// Used by StageRunner to skip createProtectedScope for TypedScope instances.\n// Private Symbol prevents string-tag spoofing.\n\nexport const IS_TYPED_SCOPE = Symbol('footprint:reactive:isTypedScope');\n\n// -- Internal: executor method allowlist -------------------------------------\n// ScopeFacade methods called by FlowChartExecutor wrapping code and StageRunner\n// THROUGH a TypedScope proxy. Only add methods with confirmed call sites.\n// Shared between createTypedScope.ts and StageRunner.ts to prevent drift.\n\nexport const EXECUTOR_INTERNAL_METHODS = new Set([\n  'notifyStageStart', // StageRunner.run() line 59\n  'notifyStageEnd', // StageRunner.run() line 79\n  'notifyPause', // StageRunner.run() — pause detection\n  'attachRecorder', // FlowChartExecutor.createTraverser() — narrative + user recorders\n  'detachRecorder', // FlowChartExecutor.detachRecorder()\n  'getRecorders', // FlowChartExecutor.getRecorders()\n  'useSharedRedactedKeys', // FlowChartExecutor.createTraverser() — redaction wrapping\n  'useRedactionPolicy', // FlowChartExecutor.createTraverser() — redaction wrapping\n]);\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/lib/reactive/types.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;AA0PH,+EAA+E;AAC/E,uEAAuE;AAE1D,QAAA,kBAAkB,GAAG,IAAI,GAAG,CAAS;IAChD,WAAW;IACX,WAAW;IACX,SAAS;IACT,SAAS;IACT,OAAO;IACP,UAAU;IACV,SAAS;IACT,QAAQ;IACR,MAAM;IACN,QAAQ;IACR,SAAS;IACT,OAAO;IACP,sBAAsB;IACtB,sBAAsB;IACtB,oBAAoB;IACpB,aAAa;IACb,QAAQ;IACR,OAAO;IACP,qBAAqB;IACrB,kBAAkB;IAClB,QAAQ;CACT,CAAC,CAAC;AAEH,+EAA+E;AAC/E,gEAAgE;AAChE,qEAAqE;AAExD,QAAA,YAAY,GAAG,MAAM,CAAC,6BAA6B,CAAC,CAAC;AAElE,+EAA+E;AAC/E,6EAA6E;AAC7E,+CAA+C;AAElC,QAAA,cAAc,GAAG,MAAM,CAAC,iCAAiC,CAAC,CAAC;AAExE,+EAA+E;AAC/E,gFAAgF;AAChF,0EAA0E;AAC1E,0EAA0E;AAE7D,QAAA,yBAAyB,GAAG,IAAI,GAAG,CAAC;IAC/C,kBAAkB,EAAE,4BAA4B;IAChD,gBAAgB,EAAE,4BAA4B;IAC9C,aAAa,EAAE,sCAAsC;IACrD,qBAAqB,EAAE,mEAAmE;IAC1F,qBAAqB,EAAE,0CAA0C;IACjE,mBAAmB,EAAE,wCAAwC;IAC7D,uBAAuB,EAAE,2DAA2D;IACpF,oBAAoB,EAAE,2DAA2D;CAClF,CAAC,CAAC","sourcesContent":["/**\n * reactive/types -- Type definitions for the TypedScope<T> reactive proxy system.\n *\n * TypedScope<T> wraps a ReactiveTarget (ScopeFacade) in a Proxy that provides\n * typed property access. All scope infrastructure methods are $-prefixed to\n * avoid collisions with user state keys.\n *\n * Dependency: type-only imports from engine/ and scope/ (zero runtime cost).\n */\n\nimport type { ExecutionEnv } from '../engine/types.js';\nimport type { ScopeRecorder } from '../scope/types.js';\n\n// -- ReactiveTarget ----------------------------------------------------------\n// Minimum protocol required by TypedScope -- a curated subset of ScopeFacade's\n// public API. Not a full mirror: excludes internal/redaction methods that are\n// handled at the executor level (useRedactionPolicy, useSharedRedactedKeys, etc.)\n// and infrastructure methods (getPipelineId, setGlobal, getGlobal, etc.).\n\nexport interface ReactiveTarget {\n  // State access (tracked by recorders)\n  getValue(key?: string): unknown;\n  setValue(key: string, value: unknown, shouldRedact?: boolean, description?: string): void;\n  updateValue(key: string, value: unknown, description?: string): void;\n  deleteValue(key: string, description?: string): void;\n\n  // Non-tracking state inspection (for proxy internals — no recorder dispatch)\n  /** Returns all state keys without firing onRead. Used by ownKeys/has traps. */\n  getStateKeys?(): string[];\n  /** Check key existence without firing onRead. Used by has trap. */\n  hasKey?(key: string): boolean;\n  /** Read state without firing onRead. Used by array proxy getCurrent(). */\n  getValueSilent?(key?: string): unknown;\n\n  // Input & environment (readonly, NOT tracked)\n  getArgs<T = Record<string, unknown>>(): T;\n  getEnv(): Readonly<ExecutionEnv>;\n\n  // ScopeRecorder management\n  attachScopeRecorder(recorder: ScopeRecorder): void;\n  detachScopeRecorder(recorderId: string): void;\n  getScopeRecorders(): ScopeRecorder[];\n\n  // Diagnostics\n  addDebugInfo(key: string, value: unknown): void;\n  addDebugMessage(value: unknown): void;\n  addErrorInfo(key: string, value: unknown): void;\n  addMetric(name: string, value: unknown): void;\n  addEval(name: string, value: unknown): void;\n\n  // Emit channel (Phase 3) — structured user-authored events to EmitRecorders.\n  emitEvent(name: string, payload?: unknown): void;\n\n  // Detach (T4) — fire-and-forget child flowcharts. ScopeFacade\n  // delegates to `detach/spawn`, minting refIds from this stage's\n  // runtimeStageId for diagnostic correlation.\n  detachAndJoinLater(\n    driver: import('../detach/types.js').DetachDriver,\n    child: import('../builder/types.js').FlowChart,\n    input?: unknown,\n  ): import('../detach/types.js').DetachHandle;\n\n  detachAndForget(\n    driver: import('../detach/types.js').DetachDriver,\n    child: import('../builder/types.js').FlowChart,\n    input?: unknown,\n  ): void;\n}\n\n// -- ScopeMethods ------------------------------------------------------------\n// $-prefixed escape hatches. Non-enumerable on the proxy -- don't appear in\n// Object.keys(), destructuring, or for...in. Only state keys are visible.\n\nexport interface ScopeMethods {\n  // State (untyped escape hatch -- for dynamic keys, redaction, description)\n  $getValue(key: string): unknown;\n  $setValue(key: string, value: unknown, shouldRedact?: boolean, description?: string): void;\n  $update(key: string, value: unknown, description?: string): void;\n  $delete(key: string, description?: string): void;\n  /** Proxy-synthesized: calls getValue(rootKey) then lodash.get for nested path. Not a direct delegation. */\n  $read(dotPath: string): unknown;\n\n  // Input & environment (readonly)\n  $getArgs<T = Record<string, unknown>>(): T;\n  $getEnv(): Readonly<ExecutionEnv>;\n\n  // Observability — legacy diagnostic primitives.\n  //\n  // As of Phase 3 these ALSO dispatch on the emit channel (in addition to\n  // their existing `DiagnosticCollector` side-bag writes for snapshot\n  // inclusion). Any attached `EmitRecorder` will see these events with\n  // the corresponding namespaced names:\n  //\n  //   $debug(key, value)    -> emits `log.debug.${key}`\n  //   $error(key, value)    -> emits `log.error.${key}`\n  //   $metric(name, value)  -> emits `metric.${name}`\n  //   $eval (name, value)   -> emits `eval.${name}`\n  //   $log(value)           -> emits `log.debug.messages`\n  //\n  // This makes the calls observable in real time — no loss of backward\n  // compat; the side bag continues to populate for consumers that inspect\n  // the snapshot directly.\n  $debug(key: string, value: unknown): void;\n  $log(value: unknown): void;\n  $error(key: string, value: unknown): void;\n  $metric(name: string, value: unknown): void;\n  $eval(name: string, value: unknown): void;\n\n  // ScopeRecorder management\n  $attachScopeRecorder(recorder: ScopeRecorder): void;\n  $detachScopeRecorder(recorderId: string): void;\n  $getScopeRecorders(): ScopeRecorder[];\n\n  /**\n   * Batch-mutate an array key in a single clone+write cycle.\n   *\n   * Every `scope.items.push(x)` clones the entire array and commits it — O(N) per call.\n   * For N mutations on an M-length array that is O(N×M). Use `$batchArray` to clone once,\n   * apply all mutations inside `fn`, then commit once — O(M) total.\n   *\n   * ```typescript\n   * // Before: 1000 clones × growing array = O(N²)\n   * for (let i = 0; i < 1000; i++) scope.items.push(i);\n   *\n   * // After: 1 clone + 1 commit = O(N)\n   * scope.$batchArray('items', (arr) => {\n   *   for (let i = 0; i < 1000; i++) arr.push(i);\n   * });\n   * ```\n   *\n   * `fn` receives a plain (non-proxy) mutable **shallow copy** of the current array.\n   * The array itself is a new instance, but object references inside it are shared with\n   * the original state — mutations to nested objects inside `fn` affect those originals.\n   * Only push/pop/sort/splice and other operations that change the array's own slots are\n   * safely isolated.\n   *\n   * Mutations inside `fn` are NOT tracked individually — only the final committed array\n   * appears in the narrative as a single write. If the key does not exist or is not an\n   * array, `fn` receives an empty array and the result is committed as the new value.\n   *\n   * If `fn` throws, `setValue` is never called and state remains unchanged (atomic on\n   * error). The exception propagates to the caller.\n   *\n   * `key` is untyped (`string`) — TypeScript will not catch typos. `arr` is typed as\n   * `unknown[]` because `ScopeMethods` is not parameterized by `T`; cast inside `fn`\n   * when element types are known: `(arr as string[]).push(x)`.\n   */\n  $batchArray(key: string, fn: (arr: unknown[]) => void): void;\n\n  // Observability — Emit channel (Phase 3)\n  /**\n   * Fire a structured event to every attached recorder implementing\n   * `onEmit`. The primary primitive for consumer-authored observability\n   * events (LLM tokens, billing metrics, domain milestones, etc.) that\n   * shouldn't live in scope state.\n   *\n   * Synchronous, pass-through — delivered to recorders immediately, in\n   * call order. Zero-allocation when no recorders are attached.\n   *\n   * ## Naming convention\n   *\n   * Use hierarchical dotted names: `'<namespace>.<category>.<event>'`.\n   * Examples:\n   *   - `'agentfootprint.llm.tokens'`\n   *   - `'myapp.billing.spend'`\n   *   - `'auth.check.denied'`\n   *\n   * The library stays vocabulary-agnostic — no central registry, no\n   * reserved prefixes. Namespace prefixes prevent collisions across\n   * libraries and apps naturally.\n   *\n   * ## Redaction\n   *\n   * If `RedactionPolicy.emitPatterns` matches the name, the payload is\n   * replaced with `'[REDACTED]'` before dispatch. No recorder ever sees\n   * the raw value for redacted event names.\n   *\n   * @param name - Consumer-chosen event identifier (see naming convention).\n   * @param payload - Structured data to attach. Shape is up to the\n   *   consumer; library treats it as opaque.\n   *\n   * @example\n   * ```typescript\n   * scope.$emit('agentfootprint.llm.tokens', { input: 100, output: 50 });\n   * scope.$emit('myapp.decision', { branch: 'approved', confidence: 0.92 });\n   * ```\n   */\n  $emit(name: string, payload?: unknown): void;\n\n  // Detach — fire-and-forget child flowchart execution.\n  //\n  // `$detachAndJoinLater(driver, child, input?)` schedules the child via\n  // the given driver and returns a `DetachHandle` the consumer can read\n  // synchronously (`.status`) or await (`.wait()`). The parent stage\n  // does NOT block on the child — it returns to the agent loop the\n  // moment the driver's `schedule()` returns (passive recorder rule).\n  //\n  // `$detachAndForget(driver, child, input?)` discards the handle —\n  // useful for fire-and-forget telemetry where the caller never needs\n  // to know how the child finished. Errors still land on the (now-\n  // dropped) handle and go silent unless an observer surfaces them.\n  //\n  // Driver is REQUIRED — there's no library-default. Pass e.g.\n  // `microtaskBatchDriver` (from 'footprintjs/detach') or your own\n  // custom driver. Explicit passing avoids global state and keeps the\n  // engine free of driver imports.\n  $detachAndJoinLater(\n    driver: import('../detach/types.js').DetachDriver,\n    child: import('../builder/types.js').FlowChart,\n    input?: unknown,\n  ): import('../detach/types.js').DetachHandle;\n\n  $detachAndForget(\n    driver: import('../detach/types.js').DetachDriver,\n    child: import('../builder/types.js').FlowChart,\n    input?: unknown,\n  ): void;\n\n  // Pipeline control\n  /**\n   * Stop the current execution context.\n   *\n   * - **In a top-level chart:** the traverser exits cleanly after this stage\n   *   completes.\n   * - **Inside a subflow:** by default, only the subflow's own execution\n   *   stops; control returns to the parent as normal. If the subflow is\n   *   mounted with `propagateBreak: true`, the break signal (and its\n   *   optional reason) propagates up to the parent scope, terminating the\n   *   outer loop too. See `SubflowMountOptions.propagateBreak`.\n   *\n   * @param reason - Optional free-form string describing why the break\n   *   happened. Propagates to `FlowBreakEvent.reason` so recorders and\n   *   custom narratives can surface it. Defaults to undefined.\n   */\n  $break(reason?: string): void;\n\n  // Escape hatch -- unwrap to underlying ReactiveTarget\n  $toRaw(): ReactiveTarget;\n}\n\n// -- TypedScope<T> -----------------------------------------------------------\n// The consumer-facing type. T is the user's state interface.\n// Property access is typed; $-methods provide escape hatches.\n\nexport type TypedScope<T extends object = Record<string, unknown>> = T & ScopeMethods;\n\n// -- ReactiveOptions ---------------------------------------------------------\n// Configuration passed to createTypedScope.\n\nexport interface ReactiveOptions {\n  /**\n   * Pipeline break function — injected by StageRunner after scope creation.\n   * Accepts an optional reason string that propagates to `FlowBreakEvent`\n   * and (when `propagateBreak` is set on a mount) up to the parent scope.\n   */\n  breakPipeline?: (reason?: string) => void;\n}\n\n// -- Internal: $-method name set ---------------------------------------------\n// Used by the Proxy get trap to distinguish $-methods from state keys.\n\nexport const SCOPE_METHOD_NAMES = new Set<string>([\n  '$getValue',\n  '$setValue',\n  '$update',\n  '$delete',\n  '$read',\n  '$getArgs',\n  '$getEnv',\n  '$debug',\n  '$log',\n  '$error',\n  '$metric',\n  '$eval',\n  '$attachScopeRecorder',\n  '$detachScopeRecorder',\n  '$getScopeRecorders',\n  '$batchArray',\n  '$break',\n  '$emit',\n  '$detachAndJoinLater',\n  '$detachAndForget',\n  '$toRaw',\n]);\n\n// -- Internal: Symbol for deferred break injection ---------------------------\n// StageRunner sets this after scope creation so $break() works.\n// Private Symbol (not Symbol.for) to prevent cross-module tampering.\n\nexport const BREAK_SETTER = Symbol('footprint:reactive:setBreak');\n\n// -- Internal: Symbol for TypedScope detection -------------------------------\n// Used by StageRunner to skip createProtectedScope for TypedScope instances.\n// Private Symbol prevents string-tag spoofing.\n\nexport const IS_TYPED_SCOPE = Symbol('footprint:reactive:isTypedScope');\n\n// -- Internal: executor method allowlist -------------------------------------\n// ScopeFacade methods called by FlowChartExecutor wrapping code and StageRunner\n// THROUGH a TypedScope proxy. Only add methods with confirmed call sites.\n// Shared between createTypedScope.ts and StageRunner.ts to prevent drift.\n\nexport const EXECUTOR_INTERNAL_METHODS = new Set([\n  'notifyStageStart', // StageRunner.run() line 59\n  'notifyStageEnd', // StageRunner.run() line 79\n  'notifyPause', // StageRunner.run() — pause detection\n  'attachScopeRecorder', // FlowChartExecutor.createTraverser() — narrative + user recorders\n  'detachScopeRecorder', // FlowChartExecutor.detachScopeRecorder()\n  'getScopeRecorders', // FlowChartExecutor.getScopeRecorders()\n  'useSharedRedactedKeys', // FlowChartExecutor.createTraverser() — redaction wrapping\n  'useRedactionPolicy', // FlowChartExecutor.createTraverser() — redaction wrapping\n]);\n"]}

package/dist/lib/recorder/BoundaryStateStore.js

@@ -0,0 +1,171 @@
+"use strict";
+/**
+ * BoundaryStateStore<TState> — concrete, composable per-boundary
+ * transient state storage.
+ *
+ * Pattern: COMPOSITION primitive. Concrete class — instantiate with
+ *          `new BoundaryStateStore<TState>()` and own it as a field
+ *          on your recorder. Replaces the abstract
+ *          `BoundaryStateTracker<TState>` base class for the v5
+ *          "one purpose per recorder" rule.
+ * Role:    "What's the LIVE transient state of every currently-active
+ *          boundary?" A boundary is a matched event pair `[start, stop]`
+ *          bracketing an interval (e.g., `(llm_start, llm_end)`).
+ *          Between the brackets, intermediate events evolve the
+ *          boundary's state. On `stop`, the state clears.
+ *
+ * Algorithmically this is the **DFS bracket-sequence pattern** — the
+ * `active` map is the open-brackets stack at any moment.
+ *
+ * **Lifecycle contract — STRICT:** every `start(key, ...)` call MUST
+ * be paired with a `stop(key)` call. Failure to wire stop produces a
+ * memory leak: the active map grows without bound.
+ *
+ * **Concurrency / nesting:** concurrent boundaries (parallel branches
+ * with two LLM calls active at once) work correctly — each is keyed
+ * independently. Nested boundaries of DIFFERENT KINDS require
+ * SEPARATE store instances — one per kind.
+ *
+ * @example
+ * ```typescript
+ * import { BoundaryStateStore } from 'footprintjs/trace';
+ * import type { CombinedRecorder, EmitEvent } from 'footprintjs';
+ *
+ * interface LLMLiveState { partial: string; tokens: number; }
+ *
+ * class LiveLLMTracker implements CombinedRecorder {
+ *   readonly id = 'live-llm';
+ *   private readonly store = new BoundaryStateStore<LLMLiveState>();
+ *
+ *   onEmit(event: EmitEvent): void {
+ *     if (event.name === 'agentfootprint.stream.llm_start') {
+ *       this.store.start(event.runtimeStageId, { partial: '', tokens: 0 });
+ *     } else if (event.name === 'agentfootprint.stream.llm_end') {
+ *       this.store.stop(event.runtimeStageId);
+ *     } else if (event.name === 'agentfootprint.stream.token') {
+ *       this.store.update(event.runtimeStageId, (s) => ({
+ *         partial: s.partial + (event.payload as { content: string }).content,
+ *         tokens: s.tokens + 1,
+ *       }));
+ *     }
+ *   }
+ *
+ *   isInFlight(): boolean { return this.store.hasActive; }
+ *   getPartial(rid: string): string {
+ *     return this.store.get(rid)?.partial ?? '';
+ *   }
+ *
+ *   clear() { this.store.clear(); }
+ * }
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoundaryStateStore = void 0;
+const detectCircular_js_1 = require("../scope/detectCircular.js");
+class BoundaryStateStore {
+    /** Open-brackets stack: key → current transient state. */
+    active = new Map();
+    /** Per-key count of `update` calls that landed without a matching
+     *  active boundary. Drives rate-limited dev-mode warnings so a
+     *  stuck loop doesn't spam the console. */
+    missedUpdates = new Map();
+    /** Optional id for diagnostics — passed to dev-mode warnings so the
+     *  source of the leak is easy to find when multiple stores coexist. */
+    diagnosticId;
+    constructor(diagnosticId = 'boundary-state-store') {
+        this.diagnosticId = diagnosticId;
+    }
+    // ── Mutators ─────────────────────────────────────────────────────────
+    /**
+     * Open a new boundary with initial transient state. If a boundary
+     * with the same `key` is already active, the prior state is
+     * overwritten (last-writer-wins). Dev mode warns — usually
+     * indicates a missed `stop` upstream.
+     */
+    start(key, initial) {
+        if (this.active.has(key) && (0, detectCircular_js_1.isDevMode)()) {
+            console.warn(`[${this.diagnosticId}] start('${key}') called while an active boundary ` +
+                'already exists. Overwriting prior state — likely a missed stop upstream.');
+        }
+        this.active.set(key, initial);
+    }
+    /**
+     * Evolve the transient state of an active boundary using a pure
+     * updater function. Silent no-op if no boundary is active for `key`
+     * (defensive against out-of-order events). Dev mode logs a rate-
+     * limited warning.
+     */
+    update(key, updater) {
+        const cur = this.active.get(key);
+        if (cur === undefined) {
+            if ((0, detectCircular_js_1.isDevMode)()) {
+                const n = (this.missedUpdates.get(key) ?? 0) + 1;
+                this.missedUpdates.set(key, n);
+                if (n === 1) {
+                    console.warn(`[${this.diagnosticId}] update('${key}') — no active boundary. Update dropped.`);
+                }
+                else if (n === 10 || n === 100) {
+                    console.warn(`[${this.diagnosticId}] update('${key}') — ${n} dropped updates. Wiring bug?`);
+                }
+            }
+            return;
+        }
+        this.active.set(key, updater(cur));
+    }
+    /**
+     * Close the boundary identified by `key` and return its FINAL
+     * transient state (so the consumer can do any cleanup — e.g., emit
+     * a snapshot to a SequenceStore for durable storage).
+     */
+    stop(key) {
+        const final = this.active.get(key);
+        this.active.delete(key);
+        return final;
+    }
+    // ── Read (O(1)) ──────────────────────────────────────────────────────
+    /** Current transient state of ONE active boundary. `undefined` if no
+     *  boundary is active for `key`. */
+    get(key) {
+        return this.active.get(key);
+    }
+    /** All currently-active boundaries.
+     *
+     *  **Type-only readonly:** TypeScript prevents mutation through
+     *  `ReadonlyMap`, but a runtime cast or non-TS consumer can mutate
+     *  the underlying Map and corrupt state. Don't. */
+    getAll() {
+        return this.active;
+    }
+    /** True if any boundary is currently active. O(1). */
+    get hasActive() {
+        return this.active.size > 0;
+    }
+    /** Number of currently-active boundaries. O(1). */
+    get activeCount() {
+        return this.active.size;
+    }
+    // ── Lifecycle ────────────────────────────────────────────────────────
+    /**
+     * Reset all transient state. Called by recorder composers from
+     * their own `clear()` method, which the executor invokes before
+     * each run.
+     *
+     * Dev mode warns if any boundaries are still active when called —
+     * likely indicates a missed `stop` upstream. Leaked keys are listed
+     * (truncated to 10) so the wiring bug is findable.
+     */
+    clear() {
+        if (this.active.size > 0 && (0, detectCircular_js_1.isDevMode)()) {
+            const keys = [...this.active.keys()];
+            const head = keys.slice(0, 10).join(', ');
+            const more = keys.length > 10 ? ` ...(+${keys.length - 10} more)` : '';
+            console.warn(`[${this.diagnosticId}] clear() called with ${this.active.size} ` +
+                'still-active boundaries. Missed stop? ' +
+                `Leaked keys: ${head}${more}`);
+        }
+        this.active.clear();
+        this.missedUpdates.clear();
+    }
+}
+exports.BoundaryStateStore = BoundaryStateStore;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BoundaryStateStore.js","sourceRoot":"","sources":["../../../src/lib/recorder/BoundaryStateStore.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * BoundaryStateStore<TState> — concrete, composable per-boundary\n * transient state storage.\n *\n * Pattern: COMPOSITION primitive. Concrete class — instantiate with\n *          `new BoundaryStateStore<TState>()` and own it as a field\n *          on your recorder. Replaces the abstract\n *          `BoundaryStateTracker<TState>` base class for the v5\n *          \"one purpose per recorder\" rule.\n * Role:    \"What's the LIVE transient state of every currently-active\n *          boundary?\" A boundary is a matched event pair `[start, stop]`\n *          bracketing an interval (e.g., `(llm_start, llm_end)`).\n *          Between the brackets, intermediate events evolve the\n *          boundary's state. On `stop`, the state clears.\n *\n * Algorithmically this is the **DFS bracket-sequence pattern** — the\n * `active` map is the open-brackets stack at any moment.\n *\n * **Lifecycle contract — STRICT:** every `start(key, ...)` call MUST\n * be paired with a `stop(key)` call. Failure to wire stop produces a\n * memory leak: the active map grows without bound.\n *\n * **Concurrency / nesting:** concurrent boundaries (parallel branches\n * with two LLM calls active at once) work correctly — each is keyed\n * independently. Nested boundaries of DIFFERENT KINDS require\n * SEPARATE store instances — one per kind.\n *\n * @example\n * ```typescript\n * import { BoundaryStateStore } from 'footprintjs/trace';\n * import type { CombinedRecorder, EmitEvent } from 'footprintjs';\n *\n * interface LLMLiveState { partial: string; tokens: number; }\n *\n * class LiveLLMTracker implements CombinedRecorder {\n *   readonly id = 'live-llm';\n *   private readonly store = new BoundaryStateStore<LLMLiveState>();\n *\n *   onEmit(event: EmitEvent): void {\n *     if (event.name === 'agentfootprint.stream.llm_start') {\n *       this.store.start(event.runtimeStageId, { partial: '', tokens: 0 });\n *     } else if (event.name === 'agentfootprint.stream.llm_end') {\n *       this.store.stop(event.runtimeStageId);\n *     } else if (event.name === 'agentfootprint.stream.token') {\n *       this.store.update(event.runtimeStageId, (s) => ({\n *         partial: s.partial + (event.payload as { content: string }).content,\n *         tokens: s.tokens + 1,\n *       }));\n *     }\n *   }\n *\n *   isInFlight(): boolean { return this.store.hasActive; }\n *   getPartial(rid: string): string {\n *     return this.store.get(rid)?.partial ?? '';\n *   }\n *\n *   clear() { this.store.clear(); }\n * }\n * ```\n */\n\nimport { isDevMode } from '../scope/detectCircular.js';\n\nexport class BoundaryStateStore<TState> {\n  /** Open-brackets stack: key → current transient state. */\n  private readonly active = new Map<string, TState>();\n\n  /** Per-key count of `update` calls that landed without a matching\n   *  active boundary. Drives rate-limited dev-mode warnings so a\n   *  stuck loop doesn't spam the console. */\n  private readonly missedUpdates = new Map<string, number>();\n\n  /** Optional id for diagnostics — passed to dev-mode warnings so the\n   *  source of the leak is easy to find when multiple stores coexist. */\n  private readonly diagnosticId: string;\n\n  constructor(diagnosticId = 'boundary-state-store') {\n    this.diagnosticId = diagnosticId;\n  }\n\n  // ── Mutators ─────────────────────────────────────────────────────────\n\n  /**\n   * Open a new boundary with initial transient state. If a boundary\n   * with the same `key` is already active, the prior state is\n   * overwritten (last-writer-wins). Dev mode warns — usually\n   * indicates a missed `stop` upstream.\n   */\n  start(key: string, initial: TState): void {\n    if (this.active.has(key) && isDevMode()) {\n      console.warn(\n        `[${this.diagnosticId}] start('${key}') called while an active boundary ` +\n          'already exists. Overwriting prior state — likely a missed stop upstream.',\n      );\n    }\n    this.active.set(key, initial);\n  }\n\n  /**\n   * Evolve the transient state of an active boundary using a pure\n   * updater function. Silent no-op if no boundary is active for `key`\n   * (defensive against out-of-order events). Dev mode logs a rate-\n   * limited warning.\n   */\n  update(key: string, updater: (prev: TState) => TState): void {\n    const cur = this.active.get(key);\n    if (cur === undefined) {\n      if (isDevMode()) {\n        const n = (this.missedUpdates.get(key) ?? 0) + 1;\n        this.missedUpdates.set(key, n);\n        if (n === 1) {\n          console.warn(`[${this.diagnosticId}] update('${key}') — no active boundary. Update dropped.`);\n        } else if (n === 10 || n === 100) {\n          console.warn(`[${this.diagnosticId}] update('${key}') — ${n} dropped updates. Wiring bug?`);\n        }\n      }\n      return;\n    }\n    this.active.set(key, updater(cur));\n  }\n\n  /**\n   * Close the boundary identified by `key` and return its FINAL\n   * transient state (so the consumer can do any cleanup — e.g., emit\n   * a snapshot to a SequenceStore for durable storage).\n   */\n  stop(key: string): TState | undefined {\n    const final = this.active.get(key);\n    this.active.delete(key);\n    return final;\n  }\n\n  // ── Read (O(1)) ──────────────────────────────────────────────────────\n\n  /** Current transient state of ONE active boundary. `undefined` if no\n   *  boundary is active for `key`. */\n  get(key: string): TState | undefined {\n    return this.active.get(key);\n  }\n\n  /** All currently-active boundaries.\n   *\n   *  **Type-only readonly:** TypeScript prevents mutation through\n   *  `ReadonlyMap`, but a runtime cast or non-TS consumer can mutate\n   *  the underlying Map and corrupt state. Don't. */\n  getAll(): ReadonlyMap<string, TState> {\n    return this.active;\n  }\n\n  /** True if any boundary is currently active. O(1). */\n  get hasActive(): boolean {\n    return this.active.size > 0;\n  }\n\n  /** Number of currently-active boundaries. O(1). */\n  get activeCount(): number {\n    return this.active.size;\n  }\n\n  // ── Lifecycle ────────────────────────────────────────────────────────\n\n  /**\n   * Reset all transient state. Called by recorder composers from\n   * their own `clear()` method, which the executor invokes before\n   * each run.\n   *\n   * Dev mode warns if any boundaries are still active when called —\n   * likely indicates a missed `stop` upstream. Leaked keys are listed\n   * (truncated to 10) so the wiring bug is findable.\n   */\n  clear(): void {\n    if (this.active.size > 0 && isDevMode()) {\n      const keys = [...this.active.keys()];\n      const head = keys.slice(0, 10).join(', ');\n      const more = keys.length > 10 ? ` ...(+${keys.length - 10} more)` : '';\n      console.warn(\n        `[${this.diagnosticId}] clear() called with ${this.active.size} ` +\n          'still-active boundaries. Missed stop? ' +\n          `Leaked keys: ${head}${more}`,\n      );\n    }\n    this.active.clear();\n    this.missedUpdates.clear();\n  }\n}\n"]}

package/dist/lib/recorder/BoundaryStateTracker.js

@@ -5,7 +5,7 @@
  *
  * **Mental model — observers vs. bookkeepers:**
  *
- *   `Recorder` / `FlowRecorder` / `EmitRecorder` / `CombinedRecorder`
+ *   `ScopeRecorder` / `FlowRecorder` / `EmitRecorder` / `CombinedRecorder`
  *     are OBSERVER interfaces — they describe how a recorder hears
  *     events from the executor.
  *
@@ -58,8 +58,8 @@
  *   - Aggregations across the whole run (totals, counts) — those are
  *     `SequenceRecorder.aggregate()` / `KeyedRecorder.aggregate()`.
  *
- *   - Stage-level concerns — those use `Recorder.onStageStart` /
- *     `Recorder.onStageEnd`. This primitive operates at finer
+ *   - Stage-level concerns — those use `ScopeRecorder.onStageStart` /
+ *     `ScopeRecorder.onStageEnd`. This primitive operates at finer
  *     granularity (events emitted DURING a stage execution).
  *
  * **Lifecycle contract — STRICT:**
@@ -264,4 +264,4 @@ class BoundaryStateTracker {
     }
 }
 exports.BoundaryStateTracker = BoundaryStateTracker;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BoundaryStateTracker.js","sourceRoot":"","sources":["../../../src/lib/recorder/BoundaryStateTracker.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * BoundaryStateTracker<TState> — third storage primitive on the recorder\n * shelf, alongside `SequenceRecorder<T>` and `KeyedRecorder<T>`.\n *\n * **Mental model — observers vs. bookkeepers:**\n *\n *   `Recorder` / `FlowRecorder` / `EmitRecorder` / `CombinedRecorder`\n *     are OBSERVER interfaces — they describe how a recorder hears\n *     events from the executor.\n *\n *   `SequenceRecorder<T>` / `KeyedRecorder<T>` / `BoundaryStateTracker<TState>`\n *     are STORAGE primitives — three different bookkeeping shelves with\n *     different durability and indexing properties. A real recorder\n *     class typically picks ONE observer interface AND ONE storage\n *     shelf, combining them via `extends + implements`.\n *\n * **What this primitive answers:** \"At any moment during the run, what\n * is the LIVE transient state of every currently-active boundary?\"\n *\n * A \"boundary\" is a matched event pair `[start, stop]` bracketing an\n * interval — for example, `(llm_start, llm_end)` for an LLM call,\n * `(tool_start, tool_end)` for tool execution, `(turn_start, turn_end)`\n * for an agent turn. Between the brackets, intermediate events evolve\n * the boundary's state (token chunks accumulating into a partial\n * answer, args streaming in, etc.). On `stop`, the state clears.\n *\n * Algorithmically this is the **DFS bracket-sequence pattern** —\n * stack-frame state during a graph-traversal interval. Same shape used\n * by Tarjan's SCC algorithm, tree decomposition, and push-down\n * automata. The `active` map is the open-brackets stack at any moment.\n *\n * **Comparison with the other storage primitives:**\n *\n * | Primitive                       | Stores                               | Time scope          | Memory      |\n * |---------------------------------|--------------------------------------|---------------------|-------------|\n * | `SequenceRecorder<T>`           | append-only ordered + keyed entries  | durable across run  | O(N events) |\n * | `KeyedRecorder<T>`              | 1:1 entry per `runtimeStageId`       | durable across run  | O(N steps)  |\n * | `BoundaryStateTracker<TState>`  | transient bracket-scoped state       | live; clears on stop | O(K active) |\n *\n * **When to pick which:**\n *\n *   - \"I need to keep a permanent log of every event for time-travel\"\n *      → `SequenceRecorder<T>`\n *   - \"I want one durable record per stage execution (e.g., metrics)\"\n *      → `KeyedRecorder<T>`\n *   - \"I need to know what's happening RIGHT NOW inside an in-flight\n *     boundary (e.g., partial LLM stream, partial tool args)\"\n *      → `BoundaryStateTracker<TState>` (this class)\n *\n * **What this is NOT for:**\n *\n *   - Time-travel queries (\"what was the state at past slider step N?\")\n *     — transient state clears on stop. For time-travel, snapshot the\n *     state at each emit into a separate `SequenceRecorder<TState>`,\n *     or wait for a future `BoundarySnapshotRecorder<TState>` primitive.\n *\n *   - Aggregations across the whole run (totals, counts) — those are\n *     `SequenceRecorder.aggregate()` / `KeyedRecorder.aggregate()`.\n *\n *   - Stage-level concerns — those use `Recorder.onStageStart` /\n *     `Recorder.onStageEnd`. This primitive operates at finer\n *     granularity (events emitted DURING a stage execution).\n *\n * **Lifecycle contract — STRICT:**\n *\n *   Every `startBoundary(key, ...)` call MUST be paired with a\n *   `stopBoundary(key)` call. Failure to wire the stop side produces a\n *   memory leak: the active map grows without bound, and `getAllActive()`\n *   returns stale entries that look in-flight but aren't. Common cause:\n *   subclass wires `start` to one event handler and forgets to wire\n *   `stop`. **Always wire both at the same time.**\n *\n *   Dev mode (`enableDevMode()`) detects leaks at `clear()` time —\n *   warning includes the leaked keys so you can find the missing wiring.\n *\n * **Concurrency / nesting:**\n *\n *   - Concurrent boundaries (parallel branches with two LLM calls\n *     active at once) work correctly: each is keyed independently in\n *     the active map.\n *   - Nested boundaries of DIFFERENT KINDS (Agent boundary contains\n *     LLM boundary) require SEPARATE tracker instances — one per kind.\n *     The base class tracks one boundary kind per instance.\n *\n * **Key convention:**\n *\n *   The `key: string` is whatever your subclass picks. Convention:\n *   use `runtimeStageId` when the boundary maps 1:1 to a stage\n *   execution — this gives free interop with `SequenceRecorder\n *   .getEntriesForStep`, `KeyedRecorder.getByKey`, `findCommit` /\n *   `findLastWriter`, and the rest of the trace ecosystem. Use a more\n *   granular key (e.g., `toolCallId`) only when there are multiple\n *   concurrent boundaries WITHIN one stage execution.\n *\n * @example Build a live LLM tracker (combining storage + observer):\n *\n * ```typescript\n * import {\n *   BoundaryStateTracker,\n *   type CombinedRecorder,\n *   type EmitEvent,\n * } from 'footprintjs';\n *\n * interface LLMLiveState {\n *   readonly partial: string;\n *   readonly tokens: number;\n * }\n *\n * class LiveLLMTracker\n *   extends BoundaryStateTracker<LLMLiveState>   // STORAGE shelf\n *   implements CombinedRecorder                   // OBSERVER interface\n * {\n *   readonly id = 'live-llm';\n *\n *   // Observer half — translate events into bracket mutations.\n *   onEmit(event: EmitEvent): void {\n *     if (event.name === 'agentfootprint.stream.llm_start') {\n *       this.startBoundary(event.runtimeStageId, { partial: '', tokens: 0 });\n *     } else if (event.name === 'agentfootprint.stream.llm_end') {\n *       this.stopBoundary(event.runtimeStageId);\n *     } else if (event.name === 'agentfootprint.stream.token') {\n *       this.updateBoundary(event.runtimeStageId, (s) => ({\n *         partial: s.partial + (event.payload as { content: string }).content,\n *         tokens: s.tokens + 1,\n *       }));\n *     }\n *   }\n *\n *   // Public read API — O(1) at any moment.\n *   isInFlight(): boolean { return this.hasActive; }\n *   getPartial(stageId: string): string {\n *     return this.getActive(stageId)?.partial ?? '';\n *   }\n * }\n *\n * // Attached the same way as any other CombinedRecorder.\n * const tracker = new LiveLLMTracker();\n * executor.attachCombinedRecorder(tracker);\n * await executor.run({ input });\n *\n * // Read live state at any time during or after the run.\n * tracker.isInFlight();\n * tracker.getPartial(rid);\n * ```\n */\n\nimport { isDevMode } from '../scope/detectCircular.js';\n\nexport abstract class BoundaryStateTracker<TState> {\n  /** Stable id — same idempotency contract as other recorders. */\n  abstract readonly id: string;\n\n  /** Open-brackets stack: key → current transient state. */\n  private readonly active = new Map<string, TState>();\n\n  /** Per-key count of `updateBoundary` calls that landed without a\n   *  matching active boundary. Drives rate-limited dev-mode warnings\n   *  so a stuck loop doesn't spam the console. */\n  private readonly missedUpdates = new Map<string, number>();\n\n  // ── Mutator API (subclass calls these from observer hooks) ──────────\n\n  /**\n   * Open a new boundary with initial transient state.\n   *\n   * If a boundary with the same `key` is already active, the prior\n   * state is overwritten (last-writer-wins). In dev mode, a warning\n   * is logged because re-starting an active key usually indicates a\n   * missed `stopBoundary` call upstream.\n   *\n   * @param key Boundary identifier — by convention, `runtimeStageId`\n   *            for 1:1-with-stage boundaries, or a more granular id\n   *            (e.g., `toolCallId`) when multiple concurrent boundaries\n   *            run within one stage execution.\n   * @param initial Initial state — typed by `TState`.\n   */\n  protected startBoundary(key: string, initial: TState): void {\n    if (this.active.has(key) && isDevMode()) {\n      console.warn(\n        `[${this.id}] startBoundary('${key}') called while an active boundary already exists. ` +\n          'Overwriting prior state — likely a missed stopBoundary upstream.',\n      );\n    }\n    this.active.set(key, initial);\n  }\n\n  /**\n   * Evolve the transient state of an active boundary using an updater\n   * function. Silent no-op if no boundary is active for `key`\n   * (defensive against out-of-order events). In dev mode, a rate-limited\n   * warning is logged on the 1st, 10th, and 100th missed update per key.\n   *\n   * @param key      Boundary identifier (must match a prior `startBoundary`).\n   * @param updater  Pure function: previous state → next state.\n   */\n  protected updateBoundary(key: string, updater: (prev: TState) => TState): void {\n    const cur = this.active.get(key);\n    if (cur === undefined) {\n      if (isDevMode()) {\n        const n = (this.missedUpdates.get(key) ?? 0) + 1;\n        this.missedUpdates.set(key, n);\n        if (n === 1) {\n          console.warn(`[${this.id}] updateBoundary('${key}') — no active boundary. Update dropped.`);\n        } else if (n === 10 || n === 100) {\n          console.warn(`[${this.id}] updateBoundary('${key}') — ${n} dropped updates. Wiring bug?`);\n        }\n      }\n      return;\n    }\n    this.active.set(key, updater(cur));\n  }\n\n  /**\n   * Close the boundary identified by `key` and return its FINAL\n   * transient state (for any cleanup the subclass wants — e.g., emit a\n   * snapshot to a SequenceRecorder for durable storage).\n   *\n   * @param key Boundary identifier.\n   * @returns The final state, or `undefined` if no boundary was active.\n   */\n  protected stopBoundary(key: string): TState | undefined {\n    const final = this.active.get(key);\n    this.active.delete(key);\n    return final;\n  }\n\n  // ── Read API (consumers call these — O(1)) ─────────────────────────\n\n  /** Current transient state of ONE active boundary. `undefined` if no\n   *  boundary is active for `key`. */\n  getActive(key: string): TState | undefined {\n    return this.active.get(key);\n  }\n\n  /**\n   * All currently-active boundaries.\n   *\n   * **Type-only readonly:** the returned reference IS the internal Map.\n   * TypeScript prevents mutation through the `ReadonlyMap` type, but a\n   * runtime cast or non-TS consumer can mutate it and corrupt internal\n   * state. **Do not mutate.**\n   */\n  getAllActive(): ReadonlyMap<string, TState> {\n    return this.active;\n  }\n\n  /** True if any boundary is currently active. O(1). */\n  get hasActive(): boolean {\n    return this.active.size > 0;\n  }\n\n  /** Number of currently-active boundaries. O(1). */\n  get activeCount(): number {\n    return this.active.size;\n  }\n\n  // ── Lifecycle ───────────────────────────────────────────────────────\n\n  /**\n   * Reset all transient state. Called by executors before each `run()`\n   * so consumers get a clean slate per run — same lifecycle contract\n   * as `SequenceRecorder.clear()`.\n   *\n   * In dev mode, warns if any boundaries are still active when called\n   * — likely indicates a missed `stopBoundary` upstream. The leaked\n   * keys are listed (truncated to 10) so the wiring bug is findable.\n   */\n  clear(): void {\n    if (this.active.size > 0 && isDevMode()) {\n      const keys = [...this.active.keys()];\n      const head = keys.slice(0, 10).join(', ');\n      const more = keys.length > 10 ? ` ...(+${keys.length - 10} more)` : '';\n      console.warn(\n        `[${this.id}] clear() called with ${this.active.size} ` +\n          'still-active boundaries. Missed stopBoundary? ' +\n          `Leaked keys: ${head}${more}`,\n      );\n    }\n    this.active.clear();\n    this.missedUpdates.clear();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BoundaryStateTracker.js","sourceRoot":"","sources":["../../../src/lib/recorder/BoundaryStateTracker.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgJG;;;AAEH,kEAAuD;AAEvD,MAAsB,oBAAoB;IAIxC,0DAA0D;IACzC,MAAM,GAAG,IAAI,GAAG,EAAkB,CAAC;IAEpD;;oDAEgD;IAC/B,aAAa,GAAG,IAAI,GAAG,EAAkB,CAAC;IAE3D,uEAAuE;IAEvE;;;;;;;;;;;;;OAaG;IACO,aAAa,CAAC,GAAW,EAAE,OAAe;QAClD,IAAI,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,IAAA,6BAAS,GAAE,EAAE,CAAC;YACxC,OAAO,CAAC,IAAI,CACV,IAAI,IAAI,CAAC,EAAE,oBAAoB,GAAG,qDAAqD;gBACrF,kEAAkE,CACrE,CAAC;QACJ,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;IAChC,CAAC;IAED;;;;;;;;OAQG;IACO,cAAc,CAAC,GAAW,EAAE,OAAiC;QACrE,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACjC,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;YACtB,IAAI,IAAA,6BAAS,GAAE,EAAE,CAAC;gBAChB,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;gBACjD,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;gBAC/B,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;oBACZ,OAAO,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,EAAE,qBAAqB,GAAG,0CAA0C,CAAC,CAAC;gBAC9F,CAAC;qBAAM,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;oBACjC,OAAO,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,EAAE,qBAAqB,GAAG,QAAQ,CAAC,+BAA+B,CAAC,CAAC;gBAC5F,CAAC;YACH,CAAC;YACD,OAAO;QACT,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;IACrC,CAAC;IAED;;;;;;;OAOG;IACO,YAAY,CAAC,GAAW;QAChC,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACnC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACxB,OAAO,KAAK,CAAC;IACf,CAAC;IAED,sEAAsE;IAEtE;wCACoC;IACpC,SAAS,CAAC,GAAW;QACnB,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC9B,CAAC;IAED;;;;;;;OAOG;IACH,YAAY;QACV,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED,sDAAsD;IACtD,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,GAAG,CAAC,CAAC;IAC9B,CAAC;IAED,mDAAmD;IACnD,IAAI,WAAW;QACb,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;IAC1B,CAAC;IAED,uEAAuE;IAEvE;;;;;;;;OAQG;IACH,KAAK;QACH,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,GAAG,CAAC,IAAI,IAAA,6BAAS,GAAE,EAAE,CAAC;YACxC,MAAM,IAAI,GAAG,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;YACrC,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC1C,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC,CAAC,SAAS,IAAI,CAAC,MAAM,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;YACvE,OAAO,CAAC,IAAI,CACV,IAAI,IAAI,CAAC,EAAE,yBAAyB,IAAI,CAAC,MAAM,CAAC,IAAI,GAAG;gBACrD,gDAAgD;gBAChD,gBAAgB,IAAI,GAAG,IAAI,EAAE,CAChC,CAAC;QACJ,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;QACpB,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;IAC7B,CAAC;CACF;AArID,oDAqIC","sourcesContent":["/**\n * BoundaryStateTracker<TState> — third storage primitive on the recorder\n * shelf, alongside `SequenceRecorder<T>` and `KeyedRecorder<T>`.\n *\n * **Mental model — observers vs. bookkeepers:**\n *\n *   `ScopeRecorder` / `FlowRecorder` / `EmitRecorder` / `CombinedRecorder`\n *     are OBSERVER interfaces — they describe how a recorder hears\n *     events from the executor.\n *\n *   `SequenceRecorder<T>` / `KeyedRecorder<T>` / `BoundaryStateTracker<TState>`\n *     are STORAGE primitives — three different bookkeeping shelves with\n *     different durability and indexing properties. A real recorder\n *     class typically picks ONE observer interface AND ONE storage\n *     shelf, combining them via `extends + implements`.\n *\n * **What this primitive answers:** \"At any moment during the run, what\n * is the LIVE transient state of every currently-active boundary?\"\n *\n * A \"boundary\" is a matched event pair `[start, stop]` bracketing an\n * interval — for example, `(llm_start, llm_end)` for an LLM call,\n * `(tool_start, tool_end)` for tool execution, `(turn_start, turn_end)`\n * for an agent turn. Between the brackets, intermediate events evolve\n * the boundary's state (token chunks accumulating into a partial\n * answer, args streaming in, etc.). On `stop`, the state clears.\n *\n * Algorithmically this is the **DFS bracket-sequence pattern** —\n * stack-frame state during a graph-traversal interval. Same shape used\n * by Tarjan's SCC algorithm, tree decomposition, and push-down\n * automata. The `active` map is the open-brackets stack at any moment.\n *\n * **Comparison with the other storage primitives:**\n *\n * | Primitive                       | Stores                               | Time scope          | Memory      |\n * |---------------------------------|--------------------------------------|---------------------|-------------|\n * | `SequenceRecorder<T>`           | append-only ordered + keyed entries  | durable across run  | O(N events) |\n * | `KeyedRecorder<T>`              | 1:1 entry per `runtimeStageId`       | durable across run  | O(N steps)  |\n * | `BoundaryStateTracker<TState>`  | transient bracket-scoped state       | live; clears on stop | O(K active) |\n *\n * **When to pick which:**\n *\n *   - \"I need to keep a permanent log of every event for time-travel\"\n *      → `SequenceRecorder<T>`\n *   - \"I want one durable record per stage execution (e.g., metrics)\"\n *      → `KeyedRecorder<T>`\n *   - \"I need to know what's happening RIGHT NOW inside an in-flight\n *     boundary (e.g., partial LLM stream, partial tool args)\"\n *      → `BoundaryStateTracker<TState>` (this class)\n *\n * **What this is NOT for:**\n *\n *   - Time-travel queries (\"what was the state at past slider step N?\")\n *     — transient state clears on stop. For time-travel, snapshot the\n *     state at each emit into a separate `SequenceRecorder<TState>`,\n *     or wait for a future `BoundarySnapshotRecorder<TState>` primitive.\n *\n *   - Aggregations across the whole run (totals, counts) — those are\n *     `SequenceRecorder.aggregate()` / `KeyedRecorder.aggregate()`.\n *\n *   - Stage-level concerns — those use `ScopeRecorder.onStageStart` /\n *     `ScopeRecorder.onStageEnd`. This primitive operates at finer\n *     granularity (events emitted DURING a stage execution).\n *\n * **Lifecycle contract — STRICT:**\n *\n *   Every `startBoundary(key, ...)` call MUST be paired with a\n *   `stopBoundary(key)` call. Failure to wire the stop side produces a\n *   memory leak: the active map grows without bound, and `getAllActive()`\n *   returns stale entries that look in-flight but aren't. Common cause:\n *   subclass wires `start` to one event handler and forgets to wire\n *   `stop`. **Always wire both at the same time.**\n *\n *   Dev mode (`enableDevMode()`) detects leaks at `clear()` time —\n *   warning includes the leaked keys so you can find the missing wiring.\n *\n * **Concurrency / nesting:**\n *\n *   - Concurrent boundaries (parallel branches with two LLM calls\n *     active at once) work correctly: each is keyed independently in\n *     the active map.\n *   - Nested boundaries of DIFFERENT KINDS (Agent boundary contains\n *     LLM boundary) require SEPARATE tracker instances — one per kind.\n *     The base class tracks one boundary kind per instance.\n *\n * **Key convention:**\n *\n *   The `key: string` is whatever your subclass picks. Convention:\n *   use `runtimeStageId` when the boundary maps 1:1 to a stage\n *   execution — this gives free interop with `SequenceRecorder\n *   .getEntriesForStep`, `KeyedRecorder.getByKey`, `findCommit` /\n *   `findLastWriter`, and the rest of the trace ecosystem. Use a more\n *   granular key (e.g., `toolCallId`) only when there are multiple\n *   concurrent boundaries WITHIN one stage execution.\n *\n * @example Build a live LLM tracker (combining storage + observer):\n *\n * ```typescript\n * import {\n *   BoundaryStateTracker,\n *   type CombinedRecorder,\n *   type EmitEvent,\n * } from 'footprintjs';\n *\n * interface LLMLiveState {\n *   readonly partial: string;\n *   readonly tokens: number;\n * }\n *\n * class LiveLLMTracker\n *   extends BoundaryStateTracker<LLMLiveState>   // STORAGE shelf\n *   implements CombinedRecorder                   // OBSERVER interface\n * {\n *   readonly id = 'live-llm';\n *\n *   // Observer half — translate events into bracket mutations.\n *   onEmit(event: EmitEvent): void {\n *     if (event.name === 'agentfootprint.stream.llm_start') {\n *       this.startBoundary(event.runtimeStageId, { partial: '', tokens: 0 });\n *     } else if (event.name === 'agentfootprint.stream.llm_end') {\n *       this.stopBoundary(event.runtimeStageId);\n *     } else if (event.name === 'agentfootprint.stream.token') {\n *       this.updateBoundary(event.runtimeStageId, (s) => ({\n *         partial: s.partial + (event.payload as { content: string }).content,\n *         tokens: s.tokens + 1,\n *       }));\n *     }\n *   }\n *\n *   // Public read API — O(1) at any moment.\n *   isInFlight(): boolean { return this.hasActive; }\n *   getPartial(stageId: string): string {\n *     return this.getActive(stageId)?.partial ?? '';\n *   }\n * }\n *\n * // Attached the same way as any other CombinedRecorder.\n * const tracker = new LiveLLMTracker();\n * executor.attachCombinedRecorder(tracker);\n * await executor.run({ input });\n *\n * // Read live state at any time during or after the run.\n * tracker.isInFlight();\n * tracker.getPartial(rid);\n * ```\n */\n\nimport { isDevMode } from '../scope/detectCircular.js';\n\nexport abstract class BoundaryStateTracker<TState> {\n  /** Stable id — same idempotency contract as other recorders. */\n  abstract readonly id: string;\n\n  /** Open-brackets stack: key → current transient state. */\n  private readonly active = new Map<string, TState>();\n\n  /** Per-key count of `updateBoundary` calls that landed without a\n   *  matching active boundary. Drives rate-limited dev-mode warnings\n   *  so a stuck loop doesn't spam the console. */\n  private readonly missedUpdates = new Map<string, number>();\n\n  // ── Mutator API (subclass calls these from observer hooks) ──────────\n\n  /**\n   * Open a new boundary with initial transient state.\n   *\n   * If a boundary with the same `key` is already active, the prior\n   * state is overwritten (last-writer-wins). In dev mode, a warning\n   * is logged because re-starting an active key usually indicates a\n   * missed `stopBoundary` call upstream.\n   *\n   * @param key Boundary identifier — by convention, `runtimeStageId`\n   *            for 1:1-with-stage boundaries, or a more granular id\n   *            (e.g., `toolCallId`) when multiple concurrent boundaries\n   *            run within one stage execution.\n   * @param initial Initial state — typed by `TState`.\n   */\n  protected startBoundary(key: string, initial: TState): void {\n    if (this.active.has(key) && isDevMode()) {\n      console.warn(\n        `[${this.id}] startBoundary('${key}') called while an active boundary already exists. ` +\n          'Overwriting prior state — likely a missed stopBoundary upstream.',\n      );\n    }\n    this.active.set(key, initial);\n  }\n\n  /**\n   * Evolve the transient state of an active boundary using an updater\n   * function. Silent no-op if no boundary is active for `key`\n   * (defensive against out-of-order events). In dev mode, a rate-limited\n   * warning is logged on the 1st, 10th, and 100th missed update per key.\n   *\n   * @param key      Boundary identifier (must match a prior `startBoundary`).\n   * @param updater  Pure function: previous state → next state.\n   */\n  protected updateBoundary(key: string, updater: (prev: TState) => TState): void {\n    const cur = this.active.get(key);\n    if (cur === undefined) {\n      if (isDevMode()) {\n        const n = (this.missedUpdates.get(key) ?? 0) + 1;\n        this.missedUpdates.set(key, n);\n        if (n === 1) {\n          console.warn(`[${this.id}] updateBoundary('${key}') — no active boundary. Update dropped.`);\n        } else if (n === 10 || n === 100) {\n          console.warn(`[${this.id}] updateBoundary('${key}') — ${n} dropped updates. Wiring bug?`);\n        }\n      }\n      return;\n    }\n    this.active.set(key, updater(cur));\n  }\n\n  /**\n   * Close the boundary identified by `key` and return its FINAL\n   * transient state (for any cleanup the subclass wants — e.g., emit a\n   * snapshot to a SequenceRecorder for durable storage).\n   *\n   * @param key Boundary identifier.\n   * @returns The final state, or `undefined` if no boundary was active.\n   */\n  protected stopBoundary(key: string): TState | undefined {\n    const final = this.active.get(key);\n    this.active.delete(key);\n    return final;\n  }\n\n  // ── Read API (consumers call these — O(1)) ─────────────────────────\n\n  /** Current transient state of ONE active boundary. `undefined` if no\n   *  boundary is active for `key`. */\n  getActive(key: string): TState | undefined {\n    return this.active.get(key);\n  }\n\n  /**\n   * All currently-active boundaries.\n   *\n   * **Type-only readonly:** the returned reference IS the internal Map.\n   * TypeScript prevents mutation through the `ReadonlyMap` type, but a\n   * runtime cast or non-TS consumer can mutate it and corrupt internal\n   * state. **Do not mutate.**\n   */\n  getAllActive(): ReadonlyMap<string, TState> {\n    return this.active;\n  }\n\n  /** True if any boundary is currently active. O(1). */\n  get hasActive(): boolean {\n    return this.active.size > 0;\n  }\n\n  /** Number of currently-active boundaries. O(1). */\n  get activeCount(): number {\n    return this.active.size;\n  }\n\n  // ── Lifecycle ───────────────────────────────────────────────────────\n\n  /**\n   * Reset all transient state. Called by executors before each `run()`\n   * so consumers get a clean slate per run — same lifecycle contract\n   * as `SequenceRecorder.clear()`.\n   *\n   * In dev mode, warns if any boundaries are still active when called\n   * — likely indicates a missed `stopBoundary` upstream. The leaked\n   * keys are listed (truncated to 10) so the wiring bug is findable.\n   */\n  clear(): void {\n    if (this.active.size > 0 && isDevMode()) {\n      const keys = [...this.active.keys()];\n      const head = keys.slice(0, 10).join(', ');\n      const more = keys.length > 10 ? ` ...(+${keys.length - 10} more)` : '';\n      console.warn(\n        `[${this.id}] clear() called with ${this.active.size} ` +\n          'still-active boundaries. Missed stopBoundary? ' +\n          `Leaked keys: ${head}${more}`,\n      );\n    }\n    this.active.clear();\n    this.missedUpdates.clear();\n  }\n}\n"]}

package/dist/lib/recorder/CombinedRecorder.js

@@ -8,9 +8,9 @@
  *
  * Before `CombinedRecorder`, a consumer who wanted to observe both streams
  * had to:
- *   1. Implement both `Recorder` (8 methods) and `FlowRecorder` (12 methods)
+ *   1. Implement both `ScopeRecorder` (8 methods) and `FlowRecorder` (12 methods)
  *      fully — stubbing every event they didn't care about.
- *   2. Remember to call BOTH `attachRecorder(r)` AND `attachFlowRecorder(r)`.
+ *   2. Remember to call BOTH `attachScopeRecorder(r)` AND `attachFlowRecorder(r)`.
  *      Forgetting the second call silently dropped half their events — no
  *      warning, no runtime error.
  *   3. Re-implement coordination logic (buffering, ordering) themselves.
@@ -37,7 +37,7 @@
  *
  * const audit: CombinedRecorder = {
  *   id: 'audit',
- *   onWrite: (e) => logWrite(e.key, e.value),        // Recorder method
+ *   onWrite: (e) => logWrite(e.key, e.value),        // ScopeRecorder method
  *   onDecision: (e) => logDecision(e.chosen),        // FlowRecorder method
  * };
  *
@@ -47,7 +47,7 @@
  *
  * ## Contract with existing APIs
  *
- * - `attachRecorder(r)` and `attachFlowRecorder(r)` remain unchanged.
+ * - `attachScopeRecorder(r)` and `attachFlowRecorder(r)` remain unchanged.
  *   Consumers who want only ONE channel keep using them — explicit is good.
  * - `attachCombinedRecorder(r)` is the ONLY way to guarantee an object is
  *   hooked into every stream it has methods for, without maintaining two
@@ -89,9 +89,9 @@ function isFlowEvent(event) {
 }
 exports.isFlowEvent = isFlowEvent;
 /**
- * Method names belonging to the `Recorder` (data-flow) interface.
+ * Method names belonging to the `ScopeRecorder` (data-flow) interface.
  * Kept as a single source of truth so the runtime duck-type detector stays
- * in sync with the interface. If a method is added to `Recorder`, adding it
+ * in sync with the interface. If a method is added to `ScopeRecorder`, adding it
  * here is the ONLY change required to route combined-recorders correctly.
  */
 const RECORDER_EVENT_METHODS = [
@@ -187,10 +187,10 @@ function hasOwnOrClassMethod(r, m) {
  *
  * ## Return type
  *
- * Returns plain `boolean` (not a type predicate). The full `Recorder`
+ * Returns plain `boolean` (not a type predicate). The full `ScopeRecorder`
  * interface has payload types that diverge from `CombinedRecorder`'s union
  * variants for shared methods, so a narrowing predicate would be unsound.
- * Callers that need to treat the recorder as a `Recorder` do so explicitly
+ * Callers that need to treat the recorder as a `ScopeRecorder` do so explicitly
  * at the attach site — the cast is the contract that each channel passes
  * its own payload variant.
  */
@@ -215,4 +215,4 @@ function hasEmitRecorderMethods(r) {
     return EMIT_RECORDER_EVENT_METHODS.some((m) => hasOwnOrClassMethod(r, m));
 }
 exports.hasEmitRecorderMethods = hasEmitRecorderMethods;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CombinedRecorder.js","sourceRoot":"","sources":["../../../src/lib/recorder/CombinedRecorder.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;;;AAmFH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,SAAgB,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;AAHD,kCAGC;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;CACF,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,SAAgB,kBAAkB,CAAC,CAAmB;IACpD,OAAO,sBAAsB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AACvE,CAAC;AAFD,gDAEC;AAED;;;GAGG;AACH,SAAgB,sBAAsB,CAAC,CAAmB;IACxD,OAAO,2BAA2B,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAC5E,CAAC;AAFD,wDAEC;AAED;;;;GAIG;AACH,SAAgB,sBAAsB,CAAC,CAAmB;IACxD,OAAO,2BAA2B,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAC5E,CAAC;AAFD,wDAEC","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 `Recorder` (8 methods) and `FlowRecorder` (12 methods)\n *      fully — stubbing every event they didn't care about.\n *   2. Remember to call BOTH `attachRecorder(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),        // Recorder 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 * - `attachRecorder(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, Recorder, ResumeEvent } from '../scope/types.js';\nimport type { EmitRecorder } from './EmitRecorder.js';\n\n/**\n * Method names that appear on BOTH `Recorder` 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 (`Recorder`: 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 `Recorder` 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<Recorder, 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 `Recorder` (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 `Recorder`, 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] 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 `Recorder`\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 `Recorder` 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;;;AAmFH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,SAAgB,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;AAHD,kCAGC;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;CACF,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,SAAgB,kBAAkB,CAAC,CAAmB;IACpD,OAAO,sBAAsB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AACvE,CAAC;AAFD,gDAEC;AAED;;;GAGG;AACH,SAAgB,sBAAsB,CAAC,CAAmB;IACxD,OAAO,2BAA2B,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAC5E,CAAC;AAFD,wDAEC;AAED;;;;GAIG;AACH,SAAgB,sBAAsB,CAAC,CAAmB;IACxD,OAAO,2BAA2B,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAC5E,CAAC;AAFD,wDAEC","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] 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"]}