footprintjs 4.12.2 → 4.13.0

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

@@ -0,0 +1,211 @@
+/**
+ * CombinedRecorder — a single observer that can hook into MULTIPLE event
+ * streams (currently: scope data-flow + control-flow). One object, one `id`,
+ * one consistent view of the execution.
+ *
+ * ## Why this exists
+ *
+ * Before `CombinedRecorder`, a consumer who wanted to observe both streams
+ * had to:
+ *   1. Implement both `Recorder` (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)`.
+ *      Forgetting the second call silently dropped half their events — no
+ *      warning, no runtime error.
+ *   3. Re-implement coordination logic (buffering, ordering) themselves.
+ *
+ * `CombinedRecorder` collapses that into a single type and a single attach
+ * call (`executor.attachCombinedRecorder(r)`), with the library handling the
+ * routing internally. Consumers implement only the events they care about
+ * (`Partial<...>`) and the attach method duck-types at runtime to dispatch
+ * to the relevant channels.
+ *
+ * ## Forward compatibility
+ *
+ * When a third observer type is added (e.g. an `OperationRecorder`), the
+ * `CombinedRecorder` type gains an `& Partial<OperationRecorder>` clause and
+ * `attachCombinedRecorder` gains one more runtime branch in its dispatch.
+ * Consumers writing a `CombinedRecorder` today are NOT affected — their
+ * code keeps compiling and attaching correctly, because every new layer is
+ * optional.
+ *
+ * ## Example
+ *
+ * ```typescript
+ * import type { CombinedRecorder } from 'footprintjs';
+ *
+ * const audit: CombinedRecorder = {
+ *   id: 'audit',
+ *   onWrite: (e) => logWrite(e.key, e.value),        // Recorder method
+ *   onDecision: (e) => logDecision(e.chosen),        // FlowRecorder method
+ * };
+ *
+ * executor.attachCombinedRecorder(audit);
+ * // ^ internally: detects both sets of methods, routes to both channels.
+ * ```
+ *
+ * ## Contract with existing APIs
+ *
+ * - `attachRecorder(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
+ *   attach calls at the call site.
+ * - Idempotency by `id` is preserved across channels: re-attaching with the
+ *   same `id` replaces the previous instance on BOTH channels, not just one.
+ */
+/**
+ * Discriminator for the union payload types on `CombinedRecorder`'s shared
+ * methods (`onError`, `onPause`, `onResume`). Returns `true` if the event
+ * was emitted from the control-flow channel (FlowRecorder).
+ *
+ * ## How it discriminates
+ *
+ * Scope-channel events extend `RecorderContext`, which carries `pipelineId`.
+ * Flow-channel events do not carry `pipelineId` (they carry an optional
+ * `traversalContext` instead, but that field is optional and cannot be
+ * relied on as a positive signal). We detect the flow variant by the
+ * ABSENCE of `pipelineId` — this is schema-stable as long as scope events
+ * continue to extend `RecorderContext`.
+ *
+ * @example
+ * ```ts
+ * onError: (e) => {
+ *   if (isFlowEvent(e)) {
+ *     // Narrowed to FlowErrorEvent: has stageName, message, structuredError
+ *   } else {
+ *     // Narrowed to ErrorEvent: has error, operation, key?
+ *   }
+ * }
+ * ```
+ */
+export function isFlowEvent(event) {
+    if (typeof event !== 'object' || event === null)
+        return false;
+    return event.pipelineId === undefined;
+}
+/**
+ * Method names belonging to the `Recorder` (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
+ * here is the ONLY change required to route combined-recorders correctly.
+ */
+const RECORDER_EVENT_METHODS = [
+    'onRead',
+    'onWrite',
+    'onCommit',
+    'onError',
+    'onStageStart',
+    'onStageEnd',
+    'onPause',
+    'onResume',
+];
+/**
+ * Method names belonging to the `FlowRecorder` (control-flow) interface.
+ * See the note on `RECORDER_EVENT_METHODS`.
+ *
+ * NOTE: the `onError`, `onPause`, `onResume` methods exist on BOTH interfaces
+ * with DIFFERENT event payload shapes. A `CombinedRecorder` that implements
+ * any of these receives both variants (one from each channel). Consumers who
+ * care about the distinction can discriminate on the presence of
+ * `traversalContext` (which only control-flow events carry).
+ */
+const FLOW_RECORDER_EVENT_METHODS = [
+    'onStageExecuted',
+    'onNext',
+    'onDecision',
+    'onFork',
+    'onSelected',
+    'onSubflowEntry',
+    'onSubflowExit',
+    'onSubflowRegistered',
+    'onLoop',
+    'onBreak',
+    'onError',
+    'onPause',
+    'onResume',
+];
+/**
+ * Method names belonging to the `EmitRecorder` (user-emitted events)
+ * interface. Same convention as the other two arrays above — kept as
+ * the single source of truth for duck-type detection.
+ */
+const EMIT_RECORDER_EVENT_METHODS = ['onEmit'];
+/**
+ * True iff the recorder declares a method named `m` either as an own
+ * property OR on its class-prototype chain — but NOT inherited from
+ * `Object.prototype`.
+ *
+ * ## Why this layered check
+ *
+ * A `CombinedRecorder` can be either a plain object literal (handlers as
+ * own properties) OR a class instance (handlers as class-prototype
+ * methods). Both are legitimate consumer patterns and both MUST attach.
+ *
+ * But handlers inherited from `Object.prototype` are ALWAYS accidental or
+ * malicious (nobody legitimately attaches recorder methods there). So we
+ * walk the prototype chain, STOPPING before `Object.prototype`. This
+ * accepts class methods while still blocking `Object.prototype`
+ * pollution attacks.
+ */
+function hasOwnOrClassMethod(r, m) {
+    if (r === null || typeof r !== 'object')
+        return false;
+    if (Object.prototype.hasOwnProperty.call(r, m)) {
+        return typeof r[m] === 'function';
+    }
+    let proto = Object.getPrototypeOf(r);
+    while (proto !== null && proto !== Object.prototype) {
+        if (Object.prototype.hasOwnProperty.call(proto, m)) {
+            return typeof proto[m] === 'function';
+        }
+        proto = Object.getPrototypeOf(proto);
+    }
+    return false;
+}
+/**
+ * True iff the recorder implements at least one data-flow event method.
+ * Used by `executor.attachCombinedRecorder` to decide whether to hook into
+ * the scope data-flow channel.
+ *
+ * ## Detection rule
+ *
+ * Accepts both object-literal recorders (own-property handlers) AND class
+ * instances (handlers declared on the class prototype). Rejects handlers
+ * inherited from `Object.prototype` — that's always accidental or
+ * malicious pollution, never a legitimate recorder.
+ *
+ * ## Lifecycle exclusions
+ *
+ * `clear` and `toSnapshot` are NOT counted as event methods — a recorder
+ * that only implements those has nothing to observe and would be a no-op
+ * on either channel.
+ *
+ * ## Return type
+ *
+ * Returns plain `boolean` (not a type predicate). The full `Recorder`
+ * 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
+ * at the attach site — the cast is the contract that each channel passes
+ * its own payload variant.
+ */
+export function hasRecorderMethods(r) {
+    return RECORDER_EVENT_METHODS.some((m) => hasOwnOrClassMethod(r, m));
+}
+/**
+ * True iff the recorder implements at least one control-flow event method.
+ * See `hasRecorderMethods`.
+ */
+export function hasFlowRecorderMethods(r) {
+    return FLOW_RECORDER_EVENT_METHODS.some((m) => hasOwnOrClassMethod(r, m));
+}
+/**
+ * True iff the recorder implements at least one emit-channel event method.
+ * See `hasRecorderMethods` for the ownership-detection rules (own or
+ * class-prototype methods count; `Object.prototype` pollution does not).
+ */
+export function hasEmitRecorderMethods(r) {
+    return EMIT_RECORDER_EVENT_METHODS.some((m) => hasOwnOrClassMethod(r, m));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CombinedRecorder.js","sourceRoot":"","sources":["../../../../src/lib/recorder/CombinedRecorder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AAmFH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,WAAW,CAAI,KAAQ;IACrC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAC9D,OAAQ,KAAiC,CAAC,UAAU,KAAK,SAAS,CAAC;AACrE,CAAC;AAED;;;;;GAKG;AACH,MAAM,sBAAsB,GAAG;IAC7B,QAAQ;IACR,SAAS;IACT,UAAU;IACV,SAAS;IACT,cAAc;IACd,YAAY;IACZ,SAAS;IACT,UAAU;CACF,CAAC;AAEX;;;;;;;;;GASG;AACH,MAAM,2BAA2B,GAAG;IAClC,iBAAiB;IACjB,QAAQ;IACR,YAAY;IACZ,QAAQ;IACR,YAAY;IACZ,gBAAgB;IAChB,eAAe;IACf,qBAAqB;IACrB,QAAQ;IACR,SAAS;IACT,SAAS;IACT,SAAS;IACT,UAAU;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,MAAM,UAAU,kBAAkB,CAAC,CAAmB;IACpD,OAAO,sBAAsB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AACvE,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,sBAAsB,CAAC,CAAmB;IACxD,OAAO,2BAA2B,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAC5E,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,sBAAsB,CAAC,CAAmB;IACxD,OAAO,2BAA2B,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAC5E,CAAC","sourcesContent":["/**\n * CombinedRecorder — a single observer that can hook into MULTIPLE event\n * streams (currently: scope data-flow + control-flow). One object, one `id`,\n * one consistent view of the execution.\n *\n * ## Why this exists\n *\n * Before `CombinedRecorder`, a consumer who wanted to observe both streams\n * had to:\n *   1. Implement both `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"]}

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

@@ -0,0 +1,62 @@
+/**
+ * EmitRecorder — the third observer channel, alongside `Recorder`
+ * (scope data-flow) and `FlowRecorder` (control-flow).
+ *
+ * ## Why this exists
+ *
+ * The first two channels capture what the LIBRARY knows about — scope
+ * reads/writes fired by `setValue`, and control-flow events fired by the
+ * traverser. But **user-emitted structured events** — things a stage
+ * function wants to surface for observability (LLM tokens, billing metrics,
+ * auth decisions, domain milestones) — have nowhere to go today. They land
+ * in unobserved `DiagnosticCollector` side bags that no recorder watches.
+ *
+ * This channel closes that gap. Consumer calls `scope.$emit(name, payload)`
+ * from inside a stage; the library enriches the event with stage context
+ * and dispatches it synchronously to every attached `EmitRecorder`.
+ *
+ * ## Design properties
+ *
+ * - **Pass-through, not buffered.** Zero allocation when no recorder is
+ *   attached. Events delivered synchronously, in-order, at call time.
+ *   Same semantics as `onRead`/`onWrite` already use.
+ * - **Library-agnostic vocabulary.** Event names are consumer-chosen strings.
+ *   Convention: hierarchical dotted names, e.g. `'agentfootprint.llm.tokens'`,
+ *   `'myapp.billing.spend'`. Library enforces no registry.
+ * - **Auto-enriched context.** Every event carries `stageName`,
+ *   `runtimeStageId`, `subflowPath`, `pipelineId`, `timestamp`. Consumers
+ *   never need to thread execution context through their emit payloads.
+ * - **Redaction-aware.** `RedactionPolicy.emitPatterns` matches event names
+ *   before dispatch — matched events have their payload replaced with
+ *   `'[REDACTED]'` so secrets can't leak via emit.
+ *
+ * ## Relationship to existing channels
+ *
+ * | Channel         | Fires when                         | Built-in consumers     |
+ * |-----------------|------------------------------------|------------------------|
+ * | `Recorder`      | scope read/write/commit            | DebugRecorder, MetricRecorder |
+ * | `FlowRecorder`  | traversal transitions              | NarrativeFlowRecorder, etc. |
+ * | `EmitRecorder`  | consumer calls `scope.$emit(...)`  | (none ships today; Phase 3.X adds MemoryEmitRecorder) |
+ *
+ * `CombinedRecorder` (from `./CombinedRecorder.ts`) intersects all three
+ * via `Partial<...>`. A consumer can write ONE object implementing any
+ * combination; `executor.attachCombinedRecorder(r)` duck-types and routes
+ * to the right channel(s).
+ *
+ * @example
+ * ```typescript
+ * const tokenMeter: EmitRecorder = {
+ *   id: 'token-meter',
+ *   onEmit(event) {
+ *     if (event.name === 'agentfootprint.llm.tokens') {
+ *       this.total += (event.payload as { input: number; output: number }).input;
+ *     }
+ *   },
+ *   total: 0,
+ * } as any;
+ *
+ * executor.attachEmitRecorder(tokenMeter);
+ * ```
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,5 +1,6 @@
+export { hasEmitRecorderMethods, hasFlowRecorderMethods, hasRecorderMethods, isFlowEvent } from './CombinedRecorder.js';
 export { CompositeRecorder } from './CompositeRecorder.js';
 export { KeyedRecorder } from './KeyedRecorder.js';
 export { RecorderOperation } from './RecorderOperation.js';
 export { SequenceRecorder } from './SequenceRecorder.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3JlY29yZGVyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQzNELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUNuRCxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUMzRCxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIHsgQ29tcG9zaXRlU25hcHNob3QgfSBmcm9tICcuL0NvbXBvc2l0ZVJlY29yZGVyLmpzJztcbmV4cG9ydCB7IENvbXBvc2l0ZVJlY29yZGVyIH0gZnJvbSAnLi9Db21wb3NpdGVSZWNvcmRlci5qcyc7XG5leHBvcnQgeyBLZXllZFJlY29yZGVyIH0gZnJvbSAnLi9LZXllZFJlY29yZGVyLmpzJztcbmV4cG9ydCB7IFJlY29yZGVyT3BlcmF0aW9uIH0gZnJvbSAnLi9SZWNvcmRlck9wZXJhdGlvbi5qcyc7XG5leHBvcnQgeyBTZXF1ZW5jZVJlY29yZGVyIH0gZnJvbSAnLi9TZXF1ZW5jZVJlY29yZGVyLmpzJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3JlY29yZGVyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxzQkFBc0IsRUFBRSxrQkFBa0IsRUFBRSxXQUFXLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUV4SCxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUUzRCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDbkQsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDM0QsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sdUJBQXVCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSB7IENvbWJpbmVkUmVjb3JkZXIgfSBmcm9tICcuL0NvbWJpbmVkUmVjb3JkZXIuanMnO1xuZXhwb3J0IHsgaGFzRW1pdFJlY29yZGVyTWV0aG9kcywgaGFzRmxvd1JlY29yZGVyTWV0aG9kcywgaGFzUmVjb3JkZXJNZXRob2RzLCBpc0Zsb3dFdmVudCB9IGZyb20gJy4vQ29tYmluZWRSZWNvcmRlci5qcyc7XG5leHBvcnQgdHlwZSB7IENvbXBvc2l0ZVNuYXBzaG90IH0gZnJvbSAnLi9Db21wb3NpdGVSZWNvcmRlci5qcyc7XG5leHBvcnQgeyBDb21wb3NpdGVSZWNvcmRlciB9IGZyb20gJy4vQ29tcG9zaXRlUmVjb3JkZXIuanMnO1xuZXhwb3J0IHR5cGUgeyBFbWl0RXZlbnQsIEVtaXRSZWNvcmRlciB9IGZyb20gJy4vRW1pdFJlY29yZGVyLmpzJztcbmV4cG9ydCB7IEtleWVkUmVjb3JkZXIgfSBmcm9tICcuL0tleWVkUmVjb3JkZXIuanMnO1xuZXhwb3J0IHsgUmVjb3JkZXJPcGVyYXRpb24gfSBmcm9tICcuL1JlY29yZGVyT3BlcmF0aW9uLmpzJztcbmV4cG9ydCB7IFNlcXVlbmNlUmVjb3JkZXIgfSBmcm9tICcuL1NlcXVlbmNlUmVjb3JkZXIuanMnO1xuIl19