footprintjs 4.16.0 → 4.17.2

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

@@ -0,0 +1,263 @@
+/**
+ * BoundaryStateTracker<TState> — third storage primitive on the recorder
+ * shelf, alongside `SequenceRecorder<T>` and `KeyedRecorder<T>`.
+ *
+ * **Mental model — observers vs. bookkeepers:**
+ *
+ *   `Recorder` / `FlowRecorder` / `EmitRecorder` / `CombinedRecorder`
+ *     are OBSERVER interfaces — they describe how a recorder hears
+ *     events from the executor.
+ *
+ *   `SequenceRecorder<T>` / `KeyedRecorder<T>` / `BoundaryStateTracker<TState>`
+ *     are STORAGE primitives — three different bookkeeping shelves with
+ *     different durability and indexing properties. A real recorder
+ *     class typically picks ONE observer interface AND ONE storage
+ *     shelf, combining them via `extends + implements`.
+ *
+ * **What this primitive answers:** "At any moment during the run, what
+ * is the LIVE transient state of every currently-active boundary?"
+ *
+ * A "boundary" is a matched event pair `[start, stop]` bracketing an
+ * interval — for example, `(llm_start, llm_end)` for an LLM call,
+ * `(tool_start, tool_end)` for tool execution, `(turn_start, turn_end)`
+ * for an agent turn. Between the brackets, intermediate events evolve
+ * the boundary's state (token chunks accumulating into a partial
+ * answer, args streaming in, etc.). On `stop`, the state clears.
+ *
+ * Algorithmically this is the **DFS bracket-sequence pattern** —
+ * stack-frame state during a graph-traversal interval. Same shape used
+ * by Tarjan's SCC algorithm, tree decomposition, and push-down
+ * automata. The `active` map is the open-brackets stack at any moment.
+ *
+ * **Comparison with the other storage primitives:**
+ *
+ * | Primitive                       | Stores                               | Time scope          | Memory      |
+ * |---------------------------------|--------------------------------------|---------------------|-------------|
+ * | `SequenceRecorder<T>`           | append-only ordered + keyed entries  | durable across run  | O(N events) |
+ * | `KeyedRecorder<T>`              | 1:1 entry per `runtimeStageId`       | durable across run  | O(N steps)  |
+ * | `BoundaryStateTracker<TState>`  | transient bracket-scoped state       | live; clears on stop | O(K active) |
+ *
+ * **When to pick which:**
+ *
+ *   - "I need to keep a permanent log of every event for time-travel"
+ *      → `SequenceRecorder<T>`
+ *   - "I want one durable record per stage execution (e.g., metrics)"
+ *      → `KeyedRecorder<T>`
+ *   - "I need to know what's happening RIGHT NOW inside an in-flight
+ *     boundary (e.g., partial LLM stream, partial tool args)"
+ *      → `BoundaryStateTracker<TState>` (this class)
+ *
+ * **What this is NOT for:**
+ *
+ *   - Time-travel queries ("what was the state at past slider step N?")
+ *     — transient state clears on stop. For time-travel, snapshot the
+ *     state at each emit into a separate `SequenceRecorder<TState>`,
+ *     or wait for a future `BoundarySnapshotRecorder<TState>` primitive.
+ *
+ *   - 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
+ *     granularity (events emitted DURING a stage execution).
+ *
+ * **Lifecycle contract — STRICT:**
+ *
+ *   Every `startBoundary(key, ...)` call MUST be paired with a
+ *   `stopBoundary(key)` call. Failure to wire the stop side produces a
+ *   memory leak: the active map grows without bound, and `getAllActive()`
+ *   returns stale entries that look in-flight but aren't. Common cause:
+ *   subclass wires `start` to one event handler and forgets to wire
+ *   `stop`. **Always wire both at the same time.**
+ *
+ *   Dev mode (`enableDevMode()`) detects leaks at `clear()` time —
+ *   warning includes the leaked keys so you can find the missing wiring.
+ *
+ * **Concurrency / nesting:**
+ *
+ *   - Concurrent boundaries (parallel branches with two LLM calls
+ *     active at once) work correctly: each is keyed independently in
+ *     the active map.
+ *   - Nested boundaries of DIFFERENT KINDS (Agent boundary contains
+ *     LLM boundary) require SEPARATE tracker instances — one per kind.
+ *     The base class tracks one boundary kind per instance.
+ *
+ * **Key convention:**
+ *
+ *   The `key: string` is whatever your subclass picks. Convention:
+ *   use `runtimeStageId` when the boundary maps 1:1 to a stage
+ *   execution — this gives free interop with `SequenceRecorder
+ *   .getEntriesForStep`, `KeyedRecorder.getByKey`, `findCommit` /
+ *   `findLastWriter`, and the rest of the trace ecosystem. Use a more
+ *   granular key (e.g., `toolCallId`) only when there are multiple
+ *   concurrent boundaries WITHIN one stage execution.
+ *
+ * @example Build a live LLM tracker (combining storage + observer):
+ *
+ * ```typescript
+ * import {
+ *   BoundaryStateTracker,
+ *   type CombinedRecorder,
+ *   type EmitEvent,
+ * } from 'footprintjs';
+ *
+ * interface LLMLiveState {
+ *   readonly partial: string;
+ *   readonly tokens: number;
+ * }
+ *
+ * class LiveLLMTracker
+ *   extends BoundaryStateTracker<LLMLiveState>   // STORAGE shelf
+ *   implements CombinedRecorder                   // OBSERVER interface
+ * {
+ *   readonly id = 'live-llm';
+ *
+ *   // Observer half — translate events into bracket mutations.
+ *   onEmit(event: EmitEvent): void {
+ *     if (event.name === 'agentfootprint.stream.llm_start') {
+ *       this.startBoundary(event.runtimeStageId, { partial: '', tokens: 0 });
+ *     } else if (event.name === 'agentfootprint.stream.llm_end') {
+ *       this.stopBoundary(event.runtimeStageId);
+ *     } else if (event.name === 'agentfootprint.stream.token') {
+ *       this.updateBoundary(event.runtimeStageId, (s) => ({
+ *         partial: s.partial + (event.payload as { content: string }).content,
+ *         tokens: s.tokens + 1,
+ *       }));
+ *     }
+ *   }
+ *
+ *   // Public read API — O(1) at any moment.
+ *   isInFlight(): boolean { return this.hasActive; }
+ *   getPartial(stageId: string): string {
+ *     return this.getActive(stageId)?.partial ?? '';
+ *   }
+ * }
+ *
+ * // Attached the same way as any other CombinedRecorder.
+ * const tracker = new LiveLLMTracker();
+ * executor.attachCombinedRecorder(tracker);
+ * await executor.run({ input });
+ *
+ * // Read live state at any time during or after the run.
+ * tracker.isInFlight();
+ * tracker.getPartial(rid);
+ * ```
+ */
+import { isDevMode } from '../scope/detectCircular.js';
+export class BoundaryStateTracker {
+    /** Open-brackets stack: key → current transient state. */
+    active = new Map();
+    /** Per-key count of `updateBoundary` 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();
+    // ── Mutator API (subclass calls these from observer hooks) ──────────
+    /**
+     * 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). In dev mode, a warning
+     * is logged because re-starting an active key usually indicates a
+     * missed `stopBoundary` call upstream.
+     *
+     * @param key Boundary identifier — by convention, `runtimeStageId`
+     *            for 1:1-with-stage boundaries, or a more granular id
+     *            (e.g., `toolCallId`) when multiple concurrent boundaries
+     *            run within one stage execution.
+     * @param initial Initial state — typed by `TState`.
+     */
+    startBoundary(key, initial) {
+        if (this.active.has(key) && isDevMode()) {
+            console.warn(`[${this.id}] startBoundary('${key}') called while an active boundary already exists. ` +
+                'Overwriting prior state — likely a missed stopBoundary upstream.');
+        }
+        this.active.set(key, initial);
+    }
+    /**
+     * Evolve the transient state of an active boundary using an updater
+     * function. Silent no-op if no boundary is active for `key`
+     * (defensive against out-of-order events). In dev mode, a rate-limited
+     * warning is logged on the 1st, 10th, and 100th missed update per key.
+     *
+     * @param key      Boundary identifier (must match a prior `startBoundary`).
+     * @param updater  Pure function: previous state → next state.
+     */
+    updateBoundary(key, updater) {
+        const cur = this.active.get(key);
+        if (cur === undefined) {
+            if (isDevMode()) {
+                const n = (this.missedUpdates.get(key) ?? 0) + 1;
+                this.missedUpdates.set(key, n);
+                if (n === 1) {
+                    console.warn(`[${this.id}] updateBoundary('${key}') — no active boundary. Update dropped.`);
+                }
+                else if (n === 10 || n === 100) {
+                    console.warn(`[${this.id}] updateBoundary('${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 (for any cleanup the subclass wants — e.g., emit a
+     * snapshot to a SequenceRecorder for durable storage).
+     *
+     * @param key Boundary identifier.
+     * @returns The final state, or `undefined` if no boundary was active.
+     */
+    stopBoundary(key) {
+        const final = this.active.get(key);
+        this.active.delete(key);
+        return final;
+    }
+    // ── Read API (consumers call these — O(1)) ─────────────────────────
+    /** Current transient state of ONE active boundary. `undefined` if no
+     *  boundary is active for `key`. */
+    getActive(key) {
+        return this.active.get(key);
+    }
+    /**
+     * All currently-active boundaries.
+     *
+     * **Type-only readonly:** the returned reference IS the internal Map.
+     * TypeScript prevents mutation through the `ReadonlyMap` type, but a
+     * runtime cast or non-TS consumer can mutate it and corrupt internal
+     * state. **Do not mutate.**
+     */
+    getAllActive() {
+        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 executors before each `run()`
+     * so consumers get a clean slate per run — same lifecycle contract
+     * as `SequenceRecorder.clear()`.
+     *
+     * In dev mode, warns if any boundaries are still active when called
+     * — likely indicates a missed `stopBoundary` upstream. The leaked
+     * keys are listed (truncated to 10) so the wiring bug is findable.
+     */
+    clear() {
+        if (this.active.size > 0 && 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.id}] clear() called with ${this.active.size} ` +
+                'still-active boundaries. Missed stopBoundary? ' +
+                `Leaked keys: ${head}${more}`);
+        }
+        this.active.clear();
+        this.missedUpdates.clear();
+    }
+}
+//# 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"]}

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

@@ -43,6 +43,8 @@
  * ```
  */
 export class CompositeRecorder {
+    id;
+    children;
     constructor(id, children) {
         this.id = id;
         this.children = [...children];
@@ -169,4 +171,4 @@ export class CompositeRecorder {
         };
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CompositeRecorder.js","sourceRoot":"","sources":["../../../../src/lib/recorder/CompositeRecorder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * CompositeRecorder — fan-out a single recorder attachment to multiple child recorders.\n *\n * Implements both Recorder (scope data ops) and FlowRecorder (control flow events)\n * so it works with both `executor.attachRecorder()` and `executor.attachFlowRecorder()`.\n *\n * The composite has a single ID for idempotent attach/detach. Child recorders\n * keep their own IDs internally but are not individually visible to the executor.\n *\n * Domain libraries (e.g., agentfootprint) use this to bundle multiple recorders\n * into a single preset — the consumer calls one function, gets full observability.\n *\n * @example\n * ```typescript\n * import { CompositeRecorder, MetricRecorder, DebugRecorder } from 'footprintjs';\n *\n * // Bundle metrics + debug into a single recorder\n * const observability = new CompositeRecorder('observability', [\n *   new MetricRecorder({ stageFilter: (name) => name === 'CallLLM' }),\n *   new DebugRecorder({ verbosity: 'minimal' }),\n * ]);\n *\n * executor.attachRecorder(observability);\n *\n * // Access child recorders by type\n * const metrics = observability.get(MetricRecorder);\n * metrics?.getMetrics(); // timing data\n * ```\n *\n * @example\n * ```typescript\n * // Domain library preset (e.g., agentfootprint)\n * export function agentObservability(options?: AgentObservabilityOptions) {\n *   return new CompositeRecorder('agent-observability', [\n *     new MetricRecorder(options?.stageFilter ? { stageFilter: options.stageFilter } : undefined),\n *     new TokenRecorder(),\n *     new ToolUsageRecorder(),\n *   ]);\n * }\n *\n * // Consumer\n * executor.attachRecorder(agentObservability());\n * ```\n */\n\nimport type {\n  FlowBreakEvent,\n  FlowDecisionEvent,\n  FlowErrorEvent,\n  FlowForkEvent,\n  FlowLoopEvent,\n  FlowNextEvent,\n  FlowRecorder,\n  FlowSelectedEvent,\n  FlowStageEvent,\n  FlowSubflowEvent,\n  FlowSubflowRegisteredEvent,\n} from '../engine/narrative/types.js';\nimport type { CommitEvent, ErrorEvent, ReadEvent, Recorder, StageEvent, WriteEvent } from '../scope/types.js';\n\n/** Snapshot format for composite recorders — wraps child snapshots. */\nexport interface CompositeSnapshot {\n  name: string;\n  data: {\n    children: Array<{ id: string; name: string; data: unknown }>;\n  };\n}\n\nexport class CompositeRecorder implements Recorder, FlowRecorder {\n  readonly id: string;\n  private readonly children: Array<Recorder | FlowRecorder>;\n\n  constructor(id: string, children: Array<Recorder | FlowRecorder>) {\n    this.id = id;\n    this.children = [...children];\n  }\n\n  // ── Child access ──────────────────────────────────────────────────────\n\n  /**\n   * Get a child recorder by class type.\n   *\n   * @example\n   * ```typescript\n   * const metrics = composite.get(MetricRecorder);\n   * ```\n   */\n  get<T>(type: new (...args: any[]) => T): T | undefined {\n    return this.children.find((c) => c instanceof type) as T | undefined;\n  }\n\n  /** Get all child recorders. */\n  getChildren(): ReadonlyArray<Recorder | FlowRecorder> {\n    return this.children;\n  }\n\n  // ── Scope Recorder hooks (fan-out to children that implement Recorder) ─\n\n  onRead(event: ReadEvent): void {\n    for (const c of this.children) if ((c as Recorder).onRead) (c as Recorder).onRead!(event);\n  }\n\n  onWrite(event: WriteEvent): void {\n    for (const c of this.children) if ((c as Recorder).onWrite) (c as Recorder).onWrite!(event);\n  }\n\n  onCommit(event: CommitEvent): void {\n    for (const c of this.children) if ((c as Recorder).onCommit) (c as Recorder).onCommit!(event);\n  }\n\n  onError(event: ErrorEvent | FlowErrorEvent): void {\n    for (const c of this.children) if ((c as Recorder).onError) (c as Recorder).onError!(event as any);\n  }\n\n  onStageStart(event: StageEvent): void {\n    for (const c of this.children) if ((c as Recorder).onStageStart) (c as Recorder).onStageStart!(event);\n  }\n\n  onStageEnd(event: StageEvent): void {\n    for (const c of this.children) if ((c as Recorder).onStageEnd) (c as Recorder).onStageEnd!(event);\n  }\n\n  // ── FlowRecorder hooks (fan-out to children that implement FlowRecorder) ─\n\n  onStageExecuted(event: FlowStageEvent): void {\n    for (const c of this.children) if ((c as FlowRecorder).onStageExecuted) (c as FlowRecorder).onStageExecuted!(event);\n  }\n\n  onNext(event: FlowNextEvent): void {\n    for (const c of this.children) if ((c as FlowRecorder).onNext) (c as FlowRecorder).onNext!(event);\n  }\n\n  onDecision(event: FlowDecisionEvent): void {\n    for (const c of this.children) if ((c as FlowRecorder).onDecision) (c as FlowRecorder).onDecision!(event);\n  }\n\n  onFork(event: FlowForkEvent): void {\n    for (const c of this.children) if ((c as FlowRecorder).onFork) (c as FlowRecorder).onFork!(event);\n  }\n\n  onSelected(event: FlowSelectedEvent): void {\n    for (const c of this.children) if ((c as FlowRecorder).onSelected) (c as FlowRecorder).onSelected!(event);\n  }\n\n  onSubflowEntry(event: FlowSubflowEvent): void {\n    for (const c of this.children) if ((c as FlowRecorder).onSubflowEntry) (c as FlowRecorder).onSubflowEntry!(event);\n  }\n\n  onSubflowExit(event: FlowSubflowEvent): void {\n    for (const c of this.children) if ((c as FlowRecorder).onSubflowExit) (c as FlowRecorder).onSubflowExit!(event);\n  }\n\n  onSubflowRegistered(event: FlowSubflowRegisteredEvent): void {\n    for (const c of this.children)\n      if ((c as FlowRecorder).onSubflowRegistered) (c as FlowRecorder).onSubflowRegistered!(event);\n  }\n\n  onLoop(event: FlowLoopEvent): void {\n    for (const c of this.children) if ((c as FlowRecorder).onLoop) (c as FlowRecorder).onLoop!(event);\n  }\n\n  onBreak(event: FlowBreakEvent): void {\n    for (const c of this.children) if ((c as FlowRecorder).onBreak) (c as FlowRecorder).onBreak!(event);\n  }\n\n  // ── Lifecycle ─────────────────────────────────────────────────────────\n\n  clear(): void {\n    for (const c of this.children) if (c.clear) c.clear();\n  }\n\n  /**\n   * Snapshot merges all child snapshots into a single composite entry.\n   * Each child's snapshot is preserved with its own id/name/data.\n   */\n  toSnapshot(): CompositeSnapshot {\n    const childSnapshots: Array<{ id: string; name: string; data: unknown }> = [];\n    for (const c of this.children) {\n      if (c.toSnapshot) {\n        const { name, data } = c.toSnapshot();\n        childSnapshots.push({ id: c.id, name, data });\n      }\n    }\n    return {\n      name: 'Composite',\n      data: { children: childSnapshots },\n    };\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CompositeRecorder.js","sourceRoot":"","sources":["../../../../src/lib/recorder/CompositeRecorder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * CompositeRecorder — fan-out a single recorder attachment to multiple child recorders.\n *\n * Implements both Recorder (scope data ops) and FlowRecorder (control flow events)\n * so it works with both `executor.attachRecorder()` and `executor.attachFlowRecorder()`.\n *\n * The composite has a single ID for idempotent attach/detach. Child recorders\n * keep their own IDs internally but are not individually visible to the executor.\n *\n * Domain libraries (e.g., agentfootprint) use this to bundle multiple recorders\n * into a single preset — the consumer calls one function, gets full observability.\n *\n * @example\n * ```typescript\n * import { CompositeRecorder, MetricRecorder, DebugRecorder } from 'footprintjs';\n *\n * // Bundle metrics + debug into a single recorder\n * const observability = new CompositeRecorder('observability', [\n *   new MetricRecorder({ stageFilter: (name) => name === 'CallLLM' }),\n *   new DebugRecorder({ verbosity: 'minimal' }),\n * ]);\n *\n * executor.attachRecorder(observability);\n *\n * // Access child recorders by type\n * const metrics = observability.get(MetricRecorder);\n * metrics?.getMetrics(); // timing data\n * ```\n *\n * @example\n * ```typescript\n * // Domain library preset (e.g., agentfootprint)\n * export function agentObservability(options?: AgentObservabilityOptions) {\n *   return new CompositeRecorder('agent-observability', [\n *     new MetricRecorder(options?.stageFilter ? { stageFilter: options.stageFilter } : undefined),\n *     new TokenRecorder(),\n *     new ToolUsageRecorder(),\n *   ]);\n * }\n *\n * // Consumer\n * executor.attachRecorder(agentObservability());\n * ```\n */\n\nimport type {\n  FlowBreakEvent,\n  FlowDecisionEvent,\n  FlowErrorEvent,\n  FlowForkEvent,\n  FlowLoopEvent,\n  FlowNextEvent,\n  FlowRecorder,\n  FlowSelectedEvent,\n  FlowStageEvent,\n  FlowSubflowEvent,\n  FlowSubflowRegisteredEvent,\n} from '../engine/narrative/types.js';\nimport type { CommitEvent, ErrorEvent, ReadEvent, Recorder, StageEvent, WriteEvent } from '../scope/types.js';\n\n/** Snapshot format for composite recorders — wraps child snapshots. */\nexport interface CompositeSnapshot {\n  name: string;\n  data: {\n    children: Array<{ id: string; name: string; data: unknown }>;\n  };\n}\n\nexport class CompositeRecorder implements Recorder, FlowRecorder {\n  readonly id: string;\n  private readonly children: Array<Recorder | FlowRecorder>;\n\n  constructor(id: string, children: Array<Recorder | FlowRecorder>) {\n    this.id = id;\n    this.children = [...children];\n  }\n\n  // ── Child access ──────────────────────────────────────────────────────\n\n  /**\n   * Get a child recorder by class type.\n   *\n   * @example\n   * ```typescript\n   * const metrics = composite.get(MetricRecorder);\n   * ```\n   */\n  get<T>(type: new (...args: any[]) => T): T | undefined {\n    return this.children.find((c) => c instanceof type) as T | undefined;\n  }\n\n  /** Get all child recorders. */\n  getChildren(): ReadonlyArray<Recorder | FlowRecorder> {\n    return this.children;\n  }\n\n  // ── Scope Recorder hooks (fan-out to children that implement Recorder) ─\n\n  onRead(event: ReadEvent): void {\n    for (const c of this.children) if ((c as Recorder).onRead) (c as Recorder).onRead!(event);\n  }\n\n  onWrite(event: WriteEvent): void {\n    for (const c of this.children) if ((c as Recorder).onWrite) (c as Recorder).onWrite!(event);\n  }\n\n  onCommit(event: CommitEvent): void {\n    for (const c of this.children) if ((c as Recorder).onCommit) (c as Recorder).onCommit!(event);\n  }\n\n  onError(event: ErrorEvent | FlowErrorEvent): void {\n    for (const c of this.children) if ((c as Recorder).onError) (c as Recorder).onError!(event as any);\n  }\n\n  onStageStart(event: StageEvent): void {\n    for (const c of this.children) if ((c as Recorder).onStageStart) (c as Recorder).onStageStart!(event);\n  }\n\n  onStageEnd(event: StageEvent): void {\n    for (const c of this.children) if ((c as Recorder).onStageEnd) (c as Recorder).onStageEnd!(event);\n  }\n\n  // ── FlowRecorder hooks (fan-out to children that implement FlowRecorder) ─\n\n  onStageExecuted(event: FlowStageEvent): void {\n    for (const c of this.children) if ((c as FlowRecorder).onStageExecuted) (c as FlowRecorder).onStageExecuted!(event);\n  }\n\n  onNext(event: FlowNextEvent): void {\n    for (const c of this.children) if ((c as FlowRecorder).onNext) (c as FlowRecorder).onNext!(event);\n  }\n\n  onDecision(event: FlowDecisionEvent): void {\n    for (const c of this.children) if ((c as FlowRecorder).onDecision) (c as FlowRecorder).onDecision!(event);\n  }\n\n  onFork(event: FlowForkEvent): void {\n    for (const c of this.children) if ((c as FlowRecorder).onFork) (c as FlowRecorder).onFork!(event);\n  }\n\n  onSelected(event: FlowSelectedEvent): void {\n    for (const c of this.children) if ((c as FlowRecorder).onSelected) (c as FlowRecorder).onSelected!(event);\n  }\n\n  onSubflowEntry(event: FlowSubflowEvent): void {\n    for (const c of this.children) if ((c as FlowRecorder).onSubflowEntry) (c as FlowRecorder).onSubflowEntry!(event);\n  }\n\n  onSubflowExit(event: FlowSubflowEvent): void {\n    for (const c of this.children) if ((c as FlowRecorder).onSubflowExit) (c as FlowRecorder).onSubflowExit!(event);\n  }\n\n  onSubflowRegistered(event: FlowSubflowRegisteredEvent): void {\n    for (const c of this.children)\n      if ((c as FlowRecorder).onSubflowRegistered) (c as FlowRecorder).onSubflowRegistered!(event);\n  }\n\n  onLoop(event: FlowLoopEvent): void {\n    for (const c of this.children) if ((c as FlowRecorder).onLoop) (c as FlowRecorder).onLoop!(event);\n  }\n\n  onBreak(event: FlowBreakEvent): void {\n    for (const c of this.children) if ((c as FlowRecorder).onBreak) (c as FlowRecorder).onBreak!(event);\n  }\n\n  // ── Lifecycle ─────────────────────────────────────────────────────────\n\n  clear(): void {\n    for (const c of this.children) if (c.clear) c.clear();\n  }\n\n  /**\n   * Snapshot merges all child snapshots into a single composite entry.\n   * Each child's snapshot is preserved with its own id/name/data.\n   */\n  toSnapshot(): CompositeSnapshot {\n    const childSnapshots: Array<{ id: string; name: string; data: unknown }> = [];\n    for (const c of this.children) {\n      if (c.toSnapshot) {\n        const { name, data } = c.toSnapshot();\n        childSnapshots.push({ id: c.id, name, data });\n      }\n    }\n    return {\n      name: 'Composite',\n      data: { children: childSnapshots },\n    };\n  }\n}\n"]}

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

@@ -81,10 +81,10 @@ export function inOutRecorder(options = {}) {
  * detects the `FlowRecorder` method shape and routes events.
  */
 export class InOutRecorder extends SequenceRecorder {
+    id;
     constructor(options = {}) {
-        var _a;
         super();
-        this.id = (_a = options.id) !== null && _a !== void 0 ? _a : `inout-${++_counter}`;
+        this.id = options.id ?? `inout-${++_counter}`;
     }
     // ── FlowRecorder hooks ────────────────────────────────────────────────
     onRunStart(event) {
@@ -180,15 +180,14 @@ function buildRootEntry(phase, payload) {
  * complete: a top-level subflow has path `['__root__', 'sf-x']` and depth 1.
  */
 function buildSubflowEntry(event, phase) {
-    var _a, _b, _c;
     const subflowId = event.subflowId;
     if (!subflowId)
         return undefined;
-    const runtimeStageId = (_b = (_a = event.traversalContext) === null || _a === void 0 ? void 0 : _a.runtimeStageId) !== null && _b !== void 0 ? _b : '';
+    const runtimeStageId = event.traversalContext?.runtimeStageId ?? '';
     const segments = subflowId.split('/').filter((s) => s.length > 0);
     const subflowPath = [ROOT_SUBFLOW_ID, ...segments];
     const depth = subflowPath.length - 1;
-    const localSubflowId = (_c = segments[segments.length - 1]) !== null && _c !== void 0 ? _c : subflowId;
+    const localSubflowId = segments[segments.length - 1] ?? subflowId;
     const payload = phase === 'entry' ? event.mappedInput : event.outputState;
     return {
         runtimeStageId,
@@ -203,4 +202,4 @@ function buildSubflowEntry(event, phase) {
         isRoot: false,
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"InOutRecorder.js","sourceRoot":"","sources":["../../../../src/lib/recorder/InOutRecorder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * InOutRecorder — captures every chart's input/output as entry/exit pairs.\n *\n * The gap this fills:\n *   Every chart in footprintjs has two natural data boundaries:\n *     - the **input** that flowed in (top-level: `run({input})`;\n *       subflow: `inputMapper` result)\n *     - the **output** that flowed out (top-level: chart return value;\n *       subflow: shared state at exit / `outputMapper` result)\n *\n *   Together with `TopologyRecorder` (composition shape) this is the\n *   universal \"step\" primitive that downstream layers project — a Lens\n *   StepGraph, a Trace view, custom dashboards. All bind by `runtimeStageId`.\n *\n *   The root chart is treated identically to any subflow: an `entry`\n *   boundary on `onRunStart` and an `exit` boundary on `onRunEnd`, with\n *   `subflowId: '__root__'`. So consumers building \"every step has an\n *   in/out arrow\" views can close the chain at the top level — no\n *   special-case rendering required.\n *\n * Two boundary phases per chart execution:\n *   1. `phase: 'entry'` — payload = the input crossing the boundary IN\n *   2. `phase: 'exit'`  — payload = the output crossing the boundary OUT\n *\n *   Loops re-entering the same subflow get distinct `runtimeStageId`s\n *   automatically (parent stage's executionIndex increments per iteration).\n *\n * Pause semantics:\n *   When a stage pauses inside a subflow, the engine re-throws the pause\n *   signal without firing `onSubflowExit` (or `onRunEnd`). The subflow\n *   has an `entry` with no matching `exit` until the run resumes and\n *   exits cleanly. Consumers should handle entry-without-exit gracefully\n *   (it means \"in progress\" or \"paused\"). The `getBoundary()` helper\n *   returns `{ entry, exit: undefined }` in that case.\n *\n * Redaction:\n *   Payload redaction is the engine's responsibility (`RedactionPolicy`).\n *   By the time payloads reach this recorder via `FlowSubflowEvent` or\n *   `FlowRunEvent`, redactable values are already scrubbed. The recorder\n *   does not (and should not) re-redact.\n *\n * @example\n * ```typescript\n * import { inOutRecorder } from 'footprintjs/trace';\n *\n * const inOut = inOutRecorder();\n * executor.attachCombinedRecorder(inOut);\n * await executor.run({ input });\n *\n * inOut.getSteps();                    // entry boundaries — timeline projection\n * inOut.getBoundary(runtimeStageId);   // { entry, exit } pair for one execution\n * inOut.getBoundaries();               // flat list (entry+exit interleaved)\n * inOut.getRootBoundary();             // { entry, exit } for the top-level run\n * ```\n *\n * @example Filtering by subflow path\n * ```typescript\n * const agentSteps = inOut\n *   .getSteps()\n *   .filter((b) => b.subflowPath[1] === 'sf-agent');  // path[0] is the root\n * ```\n */\n\nimport type { FlowRecorder, FlowRunEvent, FlowSubflowEvent } from '../engine/narrative/types.js';\nimport { SequenceRecorder } from './SequenceRecorder.js';\n\n// ── Types ─────────────────────────────────────────────────────────────\n\nexport type InOutPhase = 'entry' | 'exit';\n\n/** Synthetic id for the top-level run's boundary pair. */\nexport const ROOT_SUBFLOW_ID = '__root__';\n\n/** Synthetic runtimeStageId for the top-level run boundary pair. */\nexport const ROOT_RUNTIME_STAGE_ID = '__root__#0';\n\n/**\n * One half of a chart execution boundary. Entry/exit pairs share `runtimeStageId`.\n *\n * Naming follows the engine: `subflowId` is the path-prefixed identifier the\n * engine emits (e.g. `'sf-outer/sf-inner'` for nested subflows). For the\n * top-level run, it's the synthetic `'__root__'`. `subflowPath` is the\n * decomposition into segments — provided as a convenience because consumers\n * often query / group by the path tree.\n */\nexport interface InOutEntry {\n  /** runtimeStageId — same value for the entry/exit pair of one execution.\n   *  Top-level run uses the synthetic `ROOT_RUNTIME_STAGE_ID`. */\n  readonly runtimeStageId: string;\n  /** Path-prefixed subflow identifier (matches the engine's `FlowSubflowEvent.subflowId`).\n   *  Top-level → `'__root__'`. Subflow → `'sf-outer'` or `'sf-outer/sf-inner'`. */\n  readonly subflowId: string;\n  /** Last segment of `subflowId` — convenience for consumers that group by leaf name.\n   *  Top-level → `'__root__'`. */\n  readonly localSubflowId: string;\n  /** Human-readable display name (from the builder; `'Run'` for the top-level run). */\n  readonly subflowName: string;\n  /** Build-time description from the subflow's root stage.\n   *  Carries taxonomy markers (e.g. `'Agent: ReAct loop'`). Undefined for root. */\n  readonly description?: string;\n  /** Decomposition of `subflowId` into segments. Top-level → `['__root__']`.\n   *  Subflows live UNDER the root: a top-level subflow has path `['__root__', 'sf-x']`. */\n  readonly subflowPath: readonly string[];\n  /** Depth in the subflow tree. Root → 0. First-level subflow → 1. */\n  readonly depth: number;\n  /** Which side of the boundary this entry represents. */\n  readonly phase: InOutPhase;\n  /** Data crossing the boundary.\n   *  - `phase: 'entry'` → `inputMapper` result (subflow) or `run({input})` (root)\n   *  - `phase: 'exit'`  → subflow shared state at exit (subflow) or chart return value (root)\n   *\n   *  Undefined when no mapper / no input was provided. */\n  readonly payload?: unknown;\n  /** True when this entry came from the top-level run (`onRunStart` / `onRunEnd`)\n   *  rather than from a subflow (`onSubflowEntry` / `onSubflowExit`).\n   *  Lens uses this to render the root pair as `user → run → user` instead of\n   *  the regular subflow shape. */\n  readonly isRoot: boolean;\n}\n\nexport interface InOutRecorderOptions {\n  /** Recorder id. Defaults to `inout-N` (auto-incremented). */\n  id?: string;\n}\n\nlet _counter = 0;\n\n/**\n * Factory — matches the `topologyRecorder()` / `narrative()` style.\n */\nexport function inOutRecorder(options: InOutRecorderOptions = {}): InOutRecorder {\n  return new InOutRecorder(options);\n}\n\n/**\n * Stateful accumulator that watches `FlowRecorder` chart-boundary events\n * (run start/end + subflow entry/exit) and emits `InOutEntry` records to\n * its underlying `SequenceRecorder` storage.\n *\n * Attach via `executor.attachCombinedRecorder(recorder)` — footprintjs\n * detects the `FlowRecorder` method shape and routes events.\n */\nexport class InOutRecorder extends SequenceRecorder<InOutEntry> implements FlowRecorder {\n  readonly id: string;\n\n  constructor(options: InOutRecorderOptions = {}) {\n    super();\n    this.id = options.id ?? `inout-${++_counter}`;\n  }\n\n  // ── FlowRecorder hooks ────────────────────────────────────────────────\n\n  onRunStart(event: FlowRunEvent): void {\n    this.emit(buildRootEntry('entry', event.payload));\n  }\n\n  onRunEnd(event: FlowRunEvent): void {\n    this.emit(buildRootEntry('exit', event.payload));\n  }\n\n  onSubflowEntry(event: FlowSubflowEvent): void {\n    const entry = buildSubflowEntry(event, 'entry');\n    if (entry) this.emit(entry);\n  }\n\n  onSubflowExit(event: FlowSubflowEvent): void {\n    const entry = buildSubflowEntry(event, 'exit');\n    if (entry) this.emit(entry);\n  }\n\n  // ── Query API ─────────────────────────────────────────────────────────\n\n  /** All entries in execution order (entry+exit interleaved).\n   *  Alias for `getEntries()` with domain-clearer naming. */\n  getBoundaries(): InOutEntry[] {\n    return this.getEntries();\n  }\n\n  /** Entry/exit pair for one chart execution.\n   *  Returns `{ entry, exit }` — `exit` is `undefined` for in-progress / paused\n   *  charts or if `runtimeStageId` is unknown. */\n  getBoundary(runtimeStageId: string): { entry?: InOutEntry; exit?: InOutEntry } {\n    const entries = this.getEntriesForStep(runtimeStageId);\n    return {\n      entry: entries.find((e) => e.phase === 'entry'),\n      exit: entries.find((e) => e.phase === 'exit'),\n    };\n  }\n\n  /** Just the `entry`-phase boundaries — the \"step list\" projection in\n   *  execution order. This is the natural timeline of chart executions\n   *  for slider / scrubbing UIs. The top-level run's entry is the first\n   *  step (depth 0). */\n  getSteps(): InOutEntry[] {\n    const steps: InOutEntry[] = [];\n    for (const b of this.getEntries()) {\n      if (b.phase === 'entry') steps.push(b);\n    }\n    return steps;\n  }\n\n  /** The root run's entry/exit pair, if the run has started.\n   *  Convenience for consumers that want to bracket the timeline by the\n   *  outermost in/out. */\n  getRootBoundary(): { entry?: InOutEntry; exit?: InOutEntry } {\n    return this.getBoundary(ROOT_RUNTIME_STAGE_ID);\n  }\n\n  /** Snapshot bundle for inclusion in `executor.getSnapshot()`. */\n  toSnapshot() {\n    return {\n      name: 'InOut',\n      description: 'Chart in/out stream — entry/exit pairs at every chart boundary (root + subflows)',\n      preferredOperation: 'translate' as const,\n      data: this.getBoundaries(),\n    };\n  }\n}\n\n// ── Internal helpers ──────────────────────────────────────────────────\n\n/**\n * Build the synthetic root entry/exit. Depth is `0` and the path is\n * `[ROOT_SUBFLOW_ID]` so consumers grouping by path see the root as a\n * regular top-level container.\n */\nfunction buildRootEntry(phase: InOutPhase, payload: unknown): InOutEntry {\n  return {\n    runtimeStageId: ROOT_RUNTIME_STAGE_ID,\n    subflowId: ROOT_SUBFLOW_ID,\n    localSubflowId: ROOT_SUBFLOW_ID,\n    subflowName: 'Run',\n    subflowPath: [ROOT_SUBFLOW_ID],\n    depth: 0,\n    phase,\n    payload,\n    isRoot: true,\n  };\n}\n\n/**\n * Build a subflow `InOutEntry` from a `FlowSubflowEvent`.\n *\n * Returns `undefined` when the event lacks a `subflowId` (anonymous /\n * malformed subflow events — same defensive policy as `TopologyRecorder`).\n *\n * Path derivation: the engine emits `subflowId` already prefixed with the\n * full path of parent subflows (e.g. `'sf-outer/sf-inner'`). We decompose\n * that into segments to populate `subflowPath` and compute `depth`.\n *\n * Subflows nest UNDER the synthetic root in `subflowPath` so the tree is\n * complete: a top-level subflow has path `['__root__', 'sf-x']` and depth 1.\n */\nfunction buildSubflowEntry(event: FlowSubflowEvent, phase: InOutPhase): InOutEntry | undefined {\n  const subflowId = event.subflowId;\n  if (!subflowId) return undefined;\n\n  const runtimeStageId = event.traversalContext?.runtimeStageId ?? '';\n  const segments = subflowId.split('/').filter((s) => s.length > 0);\n  const subflowPath: readonly string[] = [ROOT_SUBFLOW_ID, ...segments];\n  const depth = subflowPath.length - 1;\n  const localSubflowId = segments[segments.length - 1] ?? subflowId;\n  const payload = phase === 'entry' ? event.mappedInput : event.outputState;\n\n  return {\n    runtimeStageId,\n    subflowId,\n    localSubflowId,\n    subflowName: event.name,\n    description: event.description,\n    subflowPath,\n    depth,\n    phase,\n    payload,\n    isRoot: false,\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"InOutRecorder.js","sourceRoot":"","sources":["../../../../src/lib/recorder/InOutRecorder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AAGH,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAMzD,0DAA0D;AAC1D,MAAM,CAAC,MAAM,eAAe,GAAG,UAAU,CAAC;AAE1C,oEAAoE;AACpE,MAAM,CAAC,MAAM,qBAAqB,GAAG,YAAY,CAAC;AAmDlD,IAAI,QAAQ,GAAG,CAAC,CAAC;AAEjB;;GAEG;AACH,MAAM,UAAU,aAAa,CAAC,UAAgC,EAAE;IAC9D,OAAO,IAAI,aAAa,CAAC,OAAO,CAAC,CAAC;AACpC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,OAAO,aAAc,SAAQ,gBAA4B;IACpD,EAAE,CAAS;IAEpB,YAAY,UAAgC,EAAE;QAC5C,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,EAAE,GAAG,OAAO,CAAC,EAAE,IAAI,SAAS,EAAE,QAAQ,EAAE,CAAC;IAChD,CAAC;IAED,yEAAyE;IAEzE,UAAU,CAAC,KAAmB;QAC5B,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;IACpD,CAAC;IAED,QAAQ,CAAC,KAAmB;QAC1B,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;IACnD,CAAC;IAED,cAAc,CAAC,KAAuB;QACpC,MAAM,KAAK,GAAG,iBAAiB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QAChD,IAAI,KAAK;YAAE,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC9B,CAAC;IAED,aAAa,CAAC,KAAuB;QACnC,MAAM,KAAK,GAAG,iBAAiB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QAC/C,IAAI,KAAK;YAAE,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC9B,CAAC;IAED,yEAAyE;IAEzE;+DAC2D;IAC3D,aAAa;QACX,OAAO,IAAI,CAAC,UAAU,EAAE,CAAC;IAC3B,CAAC;IAED;;oDAEgD;IAChD,WAAW,CAAC,cAAsB;QAChC,MAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAAC,cAAc,CAAC,CAAC;QACvD,OAAO;YACL,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,OAAO,CAAC;YAC/C,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,MAAM,CAAC;SAC9C,CAAC;IACJ,CAAC;IAED;;;0BAGsB;IACtB,QAAQ;QACN,MAAM,KAAK,GAAiB,EAAE,CAAC;QAC/B,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC;YAClC,IAAI,CAAC,CAAC,KAAK,KAAK,OAAO;gBAAE,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACzC,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;4BAEwB;IACxB,eAAe;QACb,OAAO,IAAI,CAAC,WAAW,CAAC,qBAAqB,CAAC,CAAC;IACjD,CAAC;IAED,iEAAiE;IACjE,UAAU;QACR,OAAO;YACL,IAAI,EAAE,OAAO;YACb,WAAW,EAAE,kFAAkF;YAC/F,kBAAkB,EAAE,WAAoB;YACxC,IAAI,EAAE,IAAI,CAAC,aAAa,EAAE;SAC3B,CAAC;IACJ,CAAC;CACF;AAED,yEAAyE;AAEzE;;;;GAIG;AACH,SAAS,cAAc,CAAC,KAAiB,EAAE,OAAgB;IACzD,OAAO;QACL,cAAc,EAAE,qBAAqB;QACrC,SAAS,EAAE,eAAe;QAC1B,cAAc,EAAE,eAAe;QAC/B,WAAW,EAAE,KAAK;QAClB,WAAW,EAAE,CAAC,eAAe,CAAC;QAC9B,KAAK,EAAE,CAAC;QACR,KAAK;QACL,OAAO;QACP,MAAM,EAAE,IAAI;KACb,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAS,iBAAiB,CAAC,KAAuB,EAAE,KAAiB;IACnE,MAAM,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC;IAClC,IAAI,CAAC,SAAS;QAAE,OAAO,SAAS,CAAC;IAEjC,MAAM,cAAc,GAAG,KAAK,CAAC,gBAAgB,EAAE,cAAc,IAAI,EAAE,CAAC;IACpE,MAAM,QAAQ,GAAG,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAClE,MAAM,WAAW,GAAsB,CAAC,eAAe,EAAE,GAAG,QAAQ,CAAC,CAAC;IACtE,MAAM,KAAK,GAAG,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC;IACrC,MAAM,cAAc,GAAG,QAAQ,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,IAAI,SAAS,CAAC;IAClE,MAAM,OAAO,GAAG,KAAK,KAAK,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,WAAW,CAAC;IAE1E,OAAO;QACL,cAAc;QACd,SAAS;QACT,cAAc;QACd,WAAW,EAAE,KAAK,CAAC,IAAI;QACvB,WAAW,EAAE,KAAK,CAAC,WAAW;QAC9B,WAAW;QACX,KAAK;QACL,KAAK;QACL,OAAO;QACP,MAAM,EAAE,KAAK;KACd,CAAC;AACJ,CAAC","sourcesContent":["/**\n * InOutRecorder — captures every chart's input/output as entry/exit pairs.\n *\n * The gap this fills:\n *   Every chart in footprintjs has two natural data boundaries:\n *     - the **input** that flowed in (top-level: `run({input})`;\n *       subflow: `inputMapper` result)\n *     - the **output** that flowed out (top-level: chart return value;\n *       subflow: shared state at exit / `outputMapper` result)\n *\n *   Together with `TopologyRecorder` (composition shape) this is the\n *   universal \"step\" primitive that downstream layers project — a Lens\n *   StepGraph, a Trace view, custom dashboards. All bind by `runtimeStageId`.\n *\n *   The root chart is treated identically to any subflow: an `entry`\n *   boundary on `onRunStart` and an `exit` boundary on `onRunEnd`, with\n *   `subflowId: '__root__'`. So consumers building \"every step has an\n *   in/out arrow\" views can close the chain at the top level — no\n *   special-case rendering required.\n *\n * Two boundary phases per chart execution:\n *   1. `phase: 'entry'` — payload = the input crossing the boundary IN\n *   2. `phase: 'exit'`  — payload = the output crossing the boundary OUT\n *\n *   Loops re-entering the same subflow get distinct `runtimeStageId`s\n *   automatically (parent stage's executionIndex increments per iteration).\n *\n * Pause semantics:\n *   When a stage pauses inside a subflow, the engine re-throws the pause\n *   signal without firing `onSubflowExit` (or `onRunEnd`). The subflow\n *   has an `entry` with no matching `exit` until the run resumes and\n *   exits cleanly. Consumers should handle entry-without-exit gracefully\n *   (it means \"in progress\" or \"paused\"). The `getBoundary()` helper\n *   returns `{ entry, exit: undefined }` in that case.\n *\n * Redaction:\n *   Payload redaction is the engine's responsibility (`RedactionPolicy`).\n *   By the time payloads reach this recorder via `FlowSubflowEvent` or\n *   `FlowRunEvent`, redactable values are already scrubbed. The recorder\n *   does not (and should not) re-redact.\n *\n * @example\n * ```typescript\n * import { inOutRecorder } from 'footprintjs/trace';\n *\n * const inOut = inOutRecorder();\n * executor.attachCombinedRecorder(inOut);\n * await executor.run({ input });\n *\n * inOut.getSteps();                    // entry boundaries — timeline projection\n * inOut.getBoundary(runtimeStageId);   // { entry, exit } pair for one execution\n * inOut.getBoundaries();               // flat list (entry+exit interleaved)\n * inOut.getRootBoundary();             // { entry, exit } for the top-level run\n * ```\n *\n * @example Filtering by subflow path\n * ```typescript\n * const agentSteps = inOut\n *   .getSteps()\n *   .filter((b) => b.subflowPath[1] === 'sf-agent');  // path[0] is the root\n * ```\n */\n\nimport type { FlowRecorder, FlowRunEvent, FlowSubflowEvent } from '../engine/narrative/types.js';\nimport { SequenceRecorder } from './SequenceRecorder.js';\n\n// ── Types ─────────────────────────────────────────────────────────────\n\nexport type InOutPhase = 'entry' | 'exit';\n\n/** Synthetic id for the top-level run's boundary pair. */\nexport const ROOT_SUBFLOW_ID = '__root__';\n\n/** Synthetic runtimeStageId for the top-level run boundary pair. */\nexport const ROOT_RUNTIME_STAGE_ID = '__root__#0';\n\n/**\n * One half of a chart execution boundary. Entry/exit pairs share `runtimeStageId`.\n *\n * Naming follows the engine: `subflowId` is the path-prefixed identifier the\n * engine emits (e.g. `'sf-outer/sf-inner'` for nested subflows). For the\n * top-level run, it's the synthetic `'__root__'`. `subflowPath` is the\n * decomposition into segments — provided as a convenience because consumers\n * often query / group by the path tree.\n */\nexport interface InOutEntry {\n  /** runtimeStageId — same value for the entry/exit pair of one execution.\n   *  Top-level run uses the synthetic `ROOT_RUNTIME_STAGE_ID`. */\n  readonly runtimeStageId: string;\n  /** Path-prefixed subflow identifier (matches the engine's `FlowSubflowEvent.subflowId`).\n   *  Top-level → `'__root__'`. Subflow → `'sf-outer'` or `'sf-outer/sf-inner'`. */\n  readonly subflowId: string;\n  /** Last segment of `subflowId` — convenience for consumers that group by leaf name.\n   *  Top-level → `'__root__'`. */\n  readonly localSubflowId: string;\n  /** Human-readable display name (from the builder; `'Run'` for the top-level run). */\n  readonly subflowName: string;\n  /** Build-time description from the subflow's root stage.\n   *  Carries taxonomy markers (e.g. `'Agent: ReAct loop'`). Undefined for root. */\n  readonly description?: string;\n  /** Decomposition of `subflowId` into segments. Top-level → `['__root__']`.\n   *  Subflows live UNDER the root: a top-level subflow has path `['__root__', 'sf-x']`. */\n  readonly subflowPath: readonly string[];\n  /** Depth in the subflow tree. Root → 0. First-level subflow → 1. */\n  readonly depth: number;\n  /** Which side of the boundary this entry represents. */\n  readonly phase: InOutPhase;\n  /** Data crossing the boundary.\n   *  - `phase: 'entry'` → `inputMapper` result (subflow) or `run({input})` (root)\n   *  - `phase: 'exit'`  → subflow shared state at exit (subflow) or chart return value (root)\n   *\n   *  Undefined when no mapper / no input was provided. */\n  readonly payload?: unknown;\n  /** True when this entry came from the top-level run (`onRunStart` / `onRunEnd`)\n   *  rather than from a subflow (`onSubflowEntry` / `onSubflowExit`).\n   *  Lens uses this to render the root pair as `user → run → user` instead of\n   *  the regular subflow shape. */\n  readonly isRoot: boolean;\n}\n\nexport interface InOutRecorderOptions {\n  /** Recorder id. Defaults to `inout-N` (auto-incremented). */\n  id?: string;\n}\n\nlet _counter = 0;\n\n/**\n * Factory — matches the `topologyRecorder()` / `narrative()` style.\n */\nexport function inOutRecorder(options: InOutRecorderOptions = {}): InOutRecorder {\n  return new InOutRecorder(options);\n}\n\n/**\n * Stateful accumulator that watches `FlowRecorder` chart-boundary events\n * (run start/end + subflow entry/exit) and emits `InOutEntry` records to\n * its underlying `SequenceRecorder` storage.\n *\n * Attach via `executor.attachCombinedRecorder(recorder)` — footprintjs\n * detects the `FlowRecorder` method shape and routes events.\n */\nexport class InOutRecorder extends SequenceRecorder<InOutEntry> implements FlowRecorder {\n  readonly id: string;\n\n  constructor(options: InOutRecorderOptions = {}) {\n    super();\n    this.id = options.id ?? `inout-${++_counter}`;\n  }\n\n  // ── FlowRecorder hooks ────────────────────────────────────────────────\n\n  onRunStart(event: FlowRunEvent): void {\n    this.emit(buildRootEntry('entry', event.payload));\n  }\n\n  onRunEnd(event: FlowRunEvent): void {\n    this.emit(buildRootEntry('exit', event.payload));\n  }\n\n  onSubflowEntry(event: FlowSubflowEvent): void {\n    const entry = buildSubflowEntry(event, 'entry');\n    if (entry) this.emit(entry);\n  }\n\n  onSubflowExit(event: FlowSubflowEvent): void {\n    const entry = buildSubflowEntry(event, 'exit');\n    if (entry) this.emit(entry);\n  }\n\n  // ── Query API ─────────────────────────────────────────────────────────\n\n  /** All entries in execution order (entry+exit interleaved).\n   *  Alias for `getEntries()` with domain-clearer naming. */\n  getBoundaries(): InOutEntry[] {\n    return this.getEntries();\n  }\n\n  /** Entry/exit pair for one chart execution.\n   *  Returns `{ entry, exit }` — `exit` is `undefined` for in-progress / paused\n   *  charts or if `runtimeStageId` is unknown. */\n  getBoundary(runtimeStageId: string): { entry?: InOutEntry; exit?: InOutEntry } {\n    const entries = this.getEntriesForStep(runtimeStageId);\n    return {\n      entry: entries.find((e) => e.phase === 'entry'),\n      exit: entries.find((e) => e.phase === 'exit'),\n    };\n  }\n\n  /** Just the `entry`-phase boundaries — the \"step list\" projection in\n   *  execution order. This is the natural timeline of chart executions\n   *  for slider / scrubbing UIs. The top-level run's entry is the first\n   *  step (depth 0). */\n  getSteps(): InOutEntry[] {\n    const steps: InOutEntry[] = [];\n    for (const b of this.getEntries()) {\n      if (b.phase === 'entry') steps.push(b);\n    }\n    return steps;\n  }\n\n  /** The root run's entry/exit pair, if the run has started.\n   *  Convenience for consumers that want to bracket the timeline by the\n   *  outermost in/out. */\n  getRootBoundary(): { entry?: InOutEntry; exit?: InOutEntry } {\n    return this.getBoundary(ROOT_RUNTIME_STAGE_ID);\n  }\n\n  /** Snapshot bundle for inclusion in `executor.getSnapshot()`. */\n  toSnapshot() {\n    return {\n      name: 'InOut',\n      description: 'Chart in/out stream — entry/exit pairs at every chart boundary (root + subflows)',\n      preferredOperation: 'translate' as const,\n      data: this.getBoundaries(),\n    };\n  }\n}\n\n// ── Internal helpers ──────────────────────────────────────────────────\n\n/**\n * Build the synthetic root entry/exit. Depth is `0` and the path is\n * `[ROOT_SUBFLOW_ID]` so consumers grouping by path see the root as a\n * regular top-level container.\n */\nfunction buildRootEntry(phase: InOutPhase, payload: unknown): InOutEntry {\n  return {\n    runtimeStageId: ROOT_RUNTIME_STAGE_ID,\n    subflowId: ROOT_SUBFLOW_ID,\n    localSubflowId: ROOT_SUBFLOW_ID,\n    subflowName: 'Run',\n    subflowPath: [ROOT_SUBFLOW_ID],\n    depth: 0,\n    phase,\n    payload,\n    isRoot: true,\n  };\n}\n\n/**\n * Build a subflow `InOutEntry` from a `FlowSubflowEvent`.\n *\n * Returns `undefined` when the event lacks a `subflowId` (anonymous /\n * malformed subflow events — same defensive policy as `TopologyRecorder`).\n *\n * Path derivation: the engine emits `subflowId` already prefixed with the\n * full path of parent subflows (e.g. `'sf-outer/sf-inner'`). We decompose\n * that into segments to populate `subflowPath` and compute `depth`.\n *\n * Subflows nest UNDER the synthetic root in `subflowPath` so the tree is\n * complete: a top-level subflow has path `['__root__', 'sf-x']` and depth 1.\n */\nfunction buildSubflowEntry(event: FlowSubflowEvent, phase: InOutPhase): InOutEntry | undefined {\n  const subflowId = event.subflowId;\n  if (!subflowId) return undefined;\n\n  const runtimeStageId = event.traversalContext?.runtimeStageId ?? '';\n  const segments = subflowId.split('/').filter((s) => s.length > 0);\n  const subflowPath: readonly string[] = [ROOT_SUBFLOW_ID, ...segments];\n  const depth = subflowPath.length - 1;\n  const localSubflowId = segments[segments.length - 1] ?? subflowId;\n  const payload = phase === 'entry' ? event.mappedInput : event.outputState;\n\n  return {\n    runtimeStageId,\n    subflowId,\n    localSubflowId,\n    subflowName: event.name,\n    description: event.description,\n    subflowPath,\n    depth,\n    phase,\n    payload,\n    isRoot: false,\n  };\n}\n"]}

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

@@ -29,9 +29,7 @@
  * ```
  */
 export class KeyedRecorder {
-    constructor() {
-        this.data = new Map();
-    }
+    data = new Map();
     /** Store an entry keyed by runtimeStageId. */
     store(runtimeStageId, entry) {
         this.data.set(runtimeStageId, entry);
@@ -93,4 +91,4 @@ export class KeyedRecorder {
         this.data.clear();
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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