footprintjs 4.17.2 → 5.0.0

package/dist/lib/recorder/CommitRangeIndex.js

@@ -0,0 +1,211 @@
+"use strict";
+/**
+ * CommitRangeIndex<TLabel> — interval index over commit indices.
+ *
+ * Built incrementally during traversal: `open(label, startIdx)` when a
+ * boundary begins, `close(token, endIdx)` when it ends. Query at any
+ * commit position with `enclosing(idx)` (returns ranges containing
+ * that index, ordered outer→inner) or `overlapping(start, end)`
+ * (returns ranges intersecting a slice).
+ *
+ * See `docs/design/commit-range-index.md` for the full contract. In
+ * one paragraph: this is a generic interval data structure for
+ * commit-range queries. footprintjs owns ZERO knowledge of what
+ * labels mean — consumers (agentfootprint, lens, OTel exporters)
+ * pick their own `TLabel` type. Open ranges (mid-run, no end yet)
+ * are first-class — query results carry `endIdx: undefined` for them.
+ *
+ * Pattern: incremental builder + interval query. Same "collect during
+ *          traversal, never post-process" rule footprintjs's CLAUDE.md
+ *          requires of every observer.
+ * Role:    structural primitive for time-travel UIs and per-boundary
+ *          aggregation.
+ * Channel: consumer-driven (no engine subscription).
+ *
+ * @example
+ * ```typescript
+ * import { CommitRangeIndex } from 'footprintjs/trace';
+ *
+ * const idx = new CommitRangeIndex<string>();
+ * const t = idx.open('LLMCall', executor.getCommitCount());
+ * // ... LLM call runs, scope writes happen ...
+ * idx.close(t, executor.getCommitCount());
+ *
+ * idx.enclosing(50);  // → ranges containing commit 50, outer→inner
+ * idx.overlapping(40, 60);  // → ranges sharing the slice [40,60]
+ * idx.clear();        // wipe (e.g., on new run)
+ * ```
+ *
+ * REDACTION NOTE: labels are stored verbatim and returned verbatim in
+ * query results — the index does NOT redact `TLabel` content. If a
+ * consumer attaches a label containing PII (user email, scope reads
+ * with sensitive keys, etc.) and then serializes the index for
+ * logging or telemetry, that data leaves the trust boundary. Use
+ * `RedactionPolicy` (or your own scrubbing) on the consumer side
+ * BEFORE attaching labels. The index follows the same contract as
+ * other footprintjs storage primitives (SequenceStore, KeyedStore):
+ * storage is verbatim; redaction is the caller's responsibility.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommitRangeIndex = void 0;
+class CommitRangeIndex {
+    entries = [];
+    byId = new Map();
+    nextId = 0;
+    /** Identity for token scoping — each index gets a fresh symbol so
+     *  tokens from one index can't accidentally close ranges in another.
+     *  ROTATED on `clear()` to invalidate stale tokens that survived a
+     *  run reset (would otherwise hit a recycled id and silently mutate
+     *  a different range — see DS+logic panel review RED #1). */
+    owner = Symbol('CommitRangeIndex');
+    /**
+     * Open a new range. Returns a token the caller MUST hold and pass
+     * to `close()` later. Each `open()` gets a fresh token; tokens
+     * cannot be reused or shared across indices (silent no-op if
+     * misused — see Law 2 in the design doc). Tokens from BEFORE
+     * the most recent `clear()` are also invalid (owner symbol
+     * rotates on clear).
+     */
+    open(label, startIdx) {
+        const id = this.nextId++;
+        const entry = {
+            label,
+            startIdx,
+            endIdx: undefined,
+            id,
+            closed: false,
+        };
+        this.entries.push(entry);
+        this.byId.set(id, entry);
+        return { _id: id, _owner: this.owner };
+    }
+    /**
+     * Close an open range at `endIdx` (inclusive). After close, the
+     * range is queryable with both bounds. Closing an already-closed
+     * token is a no-op. Closing an unknown token (from another index,
+     * or fabricated) is a no-op.
+     */
+    close(token, endIdx) {
+        if (token._owner !== this.owner)
+            return; // cross-index misuse — silent no-op
+        const entry = this.findById(token._id);
+        if (!entry || entry.closed)
+            return;
+        entry.endIdx = endIdx;
+        entry.closed = true;
+    }
+    /**
+     * Returns ALL ranges enclosing `commitIdx`, ordered outer→inner.
+     * Includes both closed and open ranges. For a closed range to
+     * enclose: `startIdx <= commitIdx <= endIdx`. For an open range:
+     * `startIdx <= commitIdx` (no upper bound check).
+     *
+     * Ordering rule: ascending by `startIdx`, with TIES BROKEN BY
+     * descending `endIdx` (wider range = outer). Open ranges (endIdx
+     * undefined) are treated as `+Infinity` for tie-break — they
+     * always sort outer of any closed range starting at the same idx.
+     * This is the only deterministic outer→inner ordering when two
+     * boundaries open at the same commit (e.g., Parallel root +
+     * its first branch).
+     *
+     * Returns a SHALLOW IMMUTABLE COPY — caller mutations don't affect
+     * internal state.
+     */
+    enclosing(commitIdx) {
+        const matches = [];
+        for (const e of this.entries) {
+            if (e.startIdx > commitIdx)
+                continue;
+            if (e.endIdx === undefined || e.endIdx >= commitIdx) {
+                matches.push(toEntry(e));
+            }
+        }
+        matches.sort(outerToInnerComparator);
+        return matches;
+    }
+    /**
+     * Returns all ranges OVERLAPPING the slice `[startIdx, endIdx]`. A
+     * range overlaps if it shares at least one commit position with the
+     * slice. Use for parallel-branch detection, time-window queries,
+     * or "what boundaries fired during this slice."
+     *
+     * Sorted by the SAME outer→inner comparator as `enclosing()`:
+     * ascending by `startIdx`, ties broken by descending `endIdx`
+     * (wider = outer; open ranges treated as +Infinity).
+     *
+     * Returns a SHALLOW IMMUTABLE COPY.
+     */
+    overlapping(startIdx, endIdx) {
+        const matches = [];
+        for (const e of this.entries) {
+            // Overlap test:
+            //   range starts after slice ends → no overlap
+            //   range ends (closed) before slice starts → no overlap
+            //   otherwise → overlap (open ranges always overlap if they start <= endIdx)
+            if (e.startIdx > endIdx)
+                continue;
+            if (e.endIdx !== undefined && e.endIdx < startIdx)
+                continue;
+            matches.push(toEntry(e));
+        }
+        matches.sort(outerToInnerComparator);
+        return matches;
+    }
+    /** Total range count (open + closed). */
+    get size() {
+        return this.entries.length;
+    }
+    /**
+     * Wipe all ranges + reset the token counter AND rotate the owner
+     * symbol so any token from before this clear becomes invalid.
+     * Critical: without rotating the owner, a stale token whose `_id`
+     * happens to match a recycled id after clear would silently mutate
+     * the wrong entry. Owner rotation makes stale-token close a no-op
+     * via the `_owner !== this.owner` guard.
+     *
+     * Call from a consumer's runId guard when a new run starts (e.g.,
+     * agentfootprint's `observeRunId(onNewRun)` from Phase 2).
+     */
+    clear() {
+        this.entries.length = 0;
+        this.byId.clear();
+        this.nextId = 0;
+        this.owner = Symbol('CommitRangeIndex');
+    }
+    // ─── Internals ────────────────────────────────────────────────────
+    /** O(1) lookup by token id. Always returns the entry that the token
+     *  references (or undefined if the id was never opened in this index). */
+    findById(id) {
+        return this.byId.get(id);
+    }
+}
+exports.CommitRangeIndex = CommitRangeIndex;
+/** Project the internal mutable shape into the public readonly entry.
+ *  The OUTER object is a fresh allocation per query (so caller array
+ *  mutations don't leak). The `label` field is a REFERENCE COPY —
+ *  if `TLabel` is an object, mutating its fields will affect the
+ *  internal entry too. Consumers MUST treat labels as immutable
+ *  (or pass primitives). Documented in the class JSDoc as the
+ *  "labels are stored verbatim" contract. */
+function toEntry(e) {
+    return e.endIdx === undefined
+        ? { label: e.label, startIdx: e.startIdx }
+        : { label: e.label, startIdx: e.startIdx, endIdx: e.endIdx };
+}
+/**
+ * Shared outer→inner comparator for both `enclosing()` and
+ * `overlapping()`. Primary key: `startIdx` ascending. Tie-break:
+ * `endIdx` descending (wider range is outer). Open ranges (undefined
+ * `endIdx`) sort as +Infinity → outermost when tied. Deterministic
+ * ordering required so consumers (Lens breadcrumb, time-travel UIs)
+ * never see flicker on equal-start boundaries (e.g., a Parallel
+ * root and its first branch opening at the same commit).
+ */
+function outerToInnerComparator(a, b) {
+    if (a.startIdx !== b.startIdx)
+        return a.startIdx - b.startIdx;
+    const ae = a.endIdx ?? Number.POSITIVE_INFINITY;
+    const be = b.endIdx ?? Number.POSITIVE_INFINITY;
+    return be - ae;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CommitRangeIndex.js","sourceRoot":"","sources":["../../../src/lib/recorder/CommitRangeIndex.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;;;AA4CH,MAAa,gBAAgB;IACnB,OAAO,GAA4B,EAAE,CAAC;IACtC,IAAI,GAAG,IAAI,GAAG,EAAiC,CAAC;IAChD,MAAM,GAAG,CAAC,CAAC;IACnB;;;;iEAI6D;IACrD,KAAK,GAAG,MAAM,CAAC,kBAAkB,CAAC,CAAC;IAE3C;;;;;;;OAOG;IACH,IAAI,CAAC,KAAa,EAAE,QAAgB;QAClC,MAAM,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;QACzB,MAAM,KAAK,GAA0B;YACnC,KAAK;YACL,QAAQ;YACR,MAAM,EAAE,SAAS;YACjB,EAAE;YACF,MAAM,EAAE,KAAK;SACd,CAAC;QACF,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACzB,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;QACzB,OAAO,EAAE,GAAG,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC;IACzC,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,KAAiB,EAAE,MAAc;QACrC,IAAI,KAAK,CAAC,MAAM,KAAK,IAAI,CAAC,KAAK;YAAE,OAAO,CAAC,oCAAoC;QAC7E,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACvC,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,MAAM;YAAE,OAAO;QACnC,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC;QACtB,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC;IACtB,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,CAAC,SAAiB;QACzB,MAAM,OAAO,GAAyB,EAAE,CAAC;QACzC,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YAC7B,IAAI,CAAC,CAAC,QAAQ,GAAG,SAAS;gBAAE,SAAS;YACrC,IAAI,CAAC,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,CAAC,MAAM,IAAI,SAAS,EAAE,CAAC;gBACpD,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;YAC3B,CAAC;QACH,CAAC;QACD,OAAO,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC;QACrC,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;;;;;;;;;;OAWG;IACH,WAAW,CAAC,QAAgB,EAAE,MAAc;QAC1C,MAAM,OAAO,GAAyB,EAAE,CAAC;QACzC,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YAC7B,gBAAgB;YAChB,+CAA+C;YAC/C,yDAAyD;YACzD,6EAA6E;YAC7E,IAAI,CAAC,CAAC,QAAQ,GAAG,MAAM;gBAAE,SAAS;YAClC,IAAI,CAAC,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,CAAC,MAAM,GAAG,QAAQ;gBAAE,SAAS;YAC5D,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;QAC3B,CAAC;QACD,OAAO,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC;QACrC,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,yCAAyC;IACzC,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;IAC7B,CAAC;IAED;;;;;;;;;;OAUG;IACH,KAAK;QACH,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC;QACxB,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;QAClB,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;QAChB,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,kBAAkB,CAAC,CAAC;IAC1C,CAAC;IAED,qEAAqE;IAErE;8EAC0E;IAClE,QAAQ,CAAC,EAAU;QACzB,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAC3B,CAAC;CACF;AArID,4CAqIC;AAED;;;;;;6CAM6C;AAC7C,SAAS,OAAO,CAAS,CAAwB;IAC/C,OAAO,CAAC,CAAC,MAAM,KAAK,SAAS;QAC3B,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE;QAC1C,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC;AACjE,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,sBAAsB,CAAS,CAAqB,EAAE,CAAqB;IAClF,IAAI,CAAC,CAAC,QAAQ,KAAK,CAAC,CAAC,QAAQ;QAAE,OAAO,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,QAAQ,CAAC;IAC9D,MAAM,EAAE,GAAG,CAAC,CAAC,MAAM,IAAI,MAAM,CAAC,iBAAiB,CAAC;IAChD,MAAM,EAAE,GAAG,CAAC,CAAC,MAAM,IAAI,MAAM,CAAC,iBAAiB,CAAC;IAChD,OAAO,EAAE,GAAG,EAAE,CAAC;AACjB,CAAC","sourcesContent":["/**\n * CommitRangeIndex<TLabel> — interval index over commit indices.\n *\n * Built incrementally during traversal: `open(label, startIdx)` when a\n * boundary begins, `close(token, endIdx)` when it ends. Query at any\n * commit position with `enclosing(idx)` (returns ranges containing\n * that index, ordered outer→inner) or `overlapping(start, end)`\n * (returns ranges intersecting a slice).\n *\n * See `docs/design/commit-range-index.md` for the full contract. In\n * one paragraph: this is a generic interval data structure for\n * commit-range queries. footprintjs owns ZERO knowledge of what\n * labels mean — consumers (agentfootprint, lens, OTel exporters)\n * pick their own `TLabel` type. Open ranges (mid-run, no end yet)\n * are first-class — query results carry `endIdx: undefined` for them.\n *\n * Pattern: incremental builder + interval query. Same \"collect during\n *          traversal, never post-process\" rule footprintjs's CLAUDE.md\n *          requires of every observer.\n * Role:    structural primitive for time-travel UIs and per-boundary\n *          aggregation.\n * Channel: consumer-driven (no engine subscription).\n *\n * @example\n * ```typescript\n * import { CommitRangeIndex } from 'footprintjs/trace';\n *\n * const idx = new CommitRangeIndex<string>();\n * const t = idx.open('LLMCall', executor.getCommitCount());\n * // ... LLM call runs, scope writes happen ...\n * idx.close(t, executor.getCommitCount());\n *\n * idx.enclosing(50);  // → ranges containing commit 50, outer→inner\n * idx.overlapping(40, 60);  // → ranges sharing the slice [40,60]\n * idx.clear();        // wipe (e.g., on new run)\n * ```\n *\n * REDACTION NOTE: labels are stored verbatim and returned verbatim in\n * query results — the index does NOT redact `TLabel` content. If a\n * consumer attaches a label containing PII (user email, scope reads\n * with sensitive keys, etc.) and then serializes the index for\n * logging or telemetry, that data leaves the trust boundary. Use\n * `RedactionPolicy` (or your own scrubbing) on the consumer side\n * BEFORE attaching labels. The index follows the same contract as\n * other footprintjs storage primitives (SequenceStore, KeyedStore):\n * storage is verbatim; redaction is the caller's responsibility.\n */\n\n/** Opaque token identifying an open range. Hold onto it; pass to `close()`.\n *  Index-scoped — using a token from one CommitRangeIndex on another is\n *  a silent no-op (verified by the per-index `_owner` symbol).\n *\n *  SECURITY NOTE: the `_owner` symbol is enumerable on the token object\n *  via `Object.getOwnPropertySymbols(token)`. This means tokens are NOT\n *  adversary-safe — a malicious caller with access to ANY token from\n *  this index can recover the owner symbol and forge new tokens. The\n *  index is designed for in-process trust boundaries (cooperative\n *  recorders sharing one runner), not for hostile-input scenarios.\n *  If adversary-safety becomes a requirement, switch to a WeakMap-\n *  scoped token model (see security panel review Y2). */\nexport interface RangeToken {\n  /** Per-index sequential id. Opaque to consumers — they shouldn't read it. */\n  readonly _id: number;\n  /** Per-index identity — prevents accidental cross-index token misuse. */\n  readonly _owner: symbol;\n}\n\n/** A single range as returned by query methods. Frozen-shape — readonly fields. */\nexport interface RangeEntry<TLabel> {\n  readonly label: TLabel;\n  readonly startIdx: number;\n  /** Undefined while the range is still open (mid-run boundary). */\n  readonly endIdx?: number;\n}\n\n/**\n * Internal storage shape. Mutable while the range is open; once\n * closed, `endIdx` is set and never changes. Tokens reference these\n * by their position in the `entries` array (the `_id`).\n */\ninterface InternalEntry<TLabel> {\n  label: TLabel;\n  startIdx: number;\n  endIdx: number | undefined;\n  /** Internal cursor — assigned on `open()`, used to identify by token. */\n  id: number;\n  /** True after `close()` runs. Prevents double-close mutation. */\n  closed: boolean;\n}\n\nexport class CommitRangeIndex<TLabel> {\n  private entries: InternalEntry<TLabel>[] = [];\n  private byId = new Map<number, InternalEntry<TLabel>>();\n  private nextId = 0;\n  /** Identity for token scoping — each index gets a fresh symbol so\n   *  tokens from one index can't accidentally close ranges in another.\n   *  ROTATED on `clear()` to invalidate stale tokens that survived a\n   *  run reset (would otherwise hit a recycled id and silently mutate\n   *  a different range — see DS+logic panel review RED #1). */\n  private owner = Symbol('CommitRangeIndex');\n\n  /**\n   * Open a new range. Returns a token the caller MUST hold and pass\n   * to `close()` later. Each `open()` gets a fresh token; tokens\n   * cannot be reused or shared across indices (silent no-op if\n   * misused — see Law 2 in the design doc). Tokens from BEFORE\n   * the most recent `clear()` are also invalid (owner symbol\n   * rotates on clear).\n   */\n  open(label: TLabel, startIdx: number): RangeToken {\n    const id = this.nextId++;\n    const entry: InternalEntry<TLabel> = {\n      label,\n      startIdx,\n      endIdx: undefined,\n      id,\n      closed: false,\n    };\n    this.entries.push(entry);\n    this.byId.set(id, entry);\n    return { _id: id, _owner: this.owner };\n  }\n\n  /**\n   * Close an open range at `endIdx` (inclusive). After close, the\n   * range is queryable with both bounds. Closing an already-closed\n   * token is a no-op. Closing an unknown token (from another index,\n   * or fabricated) is a no-op.\n   */\n  close(token: RangeToken, endIdx: number): void {\n    if (token._owner !== this.owner) return; // cross-index misuse — silent no-op\n    const entry = this.findById(token._id);\n    if (!entry || entry.closed) return;\n    entry.endIdx = endIdx;\n    entry.closed = true;\n  }\n\n  /**\n   * Returns ALL ranges enclosing `commitIdx`, ordered outer→inner.\n   * Includes both closed and open ranges. For a closed range to\n   * enclose: `startIdx <= commitIdx <= endIdx`. For an open range:\n   * `startIdx <= commitIdx` (no upper bound check).\n   *\n   * Ordering rule: ascending by `startIdx`, with TIES BROKEN BY\n   * descending `endIdx` (wider range = outer). Open ranges (endIdx\n   * undefined) are treated as `+Infinity` for tie-break — they\n   * always sort outer of any closed range starting at the same idx.\n   * This is the only deterministic outer→inner ordering when two\n   * boundaries open at the same commit (e.g., Parallel root +\n   * its first branch).\n   *\n   * Returns a SHALLOW IMMUTABLE COPY — caller mutations don't affect\n   * internal state.\n   */\n  enclosing(commitIdx: number): readonly RangeEntry<TLabel>[] {\n    const matches: RangeEntry<TLabel>[] = [];\n    for (const e of this.entries) {\n      if (e.startIdx > commitIdx) continue;\n      if (e.endIdx === undefined || e.endIdx >= commitIdx) {\n        matches.push(toEntry(e));\n      }\n    }\n    matches.sort(outerToInnerComparator);\n    return matches;\n  }\n\n  /**\n   * Returns all ranges OVERLAPPING the slice `[startIdx, endIdx]`. A\n   * range overlaps if it shares at least one commit position with the\n   * slice. Use for parallel-branch detection, time-window queries,\n   * or \"what boundaries fired during this slice.\"\n   *\n   * Sorted by the SAME outer→inner comparator as `enclosing()`:\n   * ascending by `startIdx`, ties broken by descending `endIdx`\n   * (wider = outer; open ranges treated as +Infinity).\n   *\n   * Returns a SHALLOW IMMUTABLE COPY.\n   */\n  overlapping(startIdx: number, endIdx: number): readonly RangeEntry<TLabel>[] {\n    const matches: RangeEntry<TLabel>[] = [];\n    for (const e of this.entries) {\n      // Overlap test:\n      //   range starts after slice ends → no overlap\n      //   range ends (closed) before slice starts → no overlap\n      //   otherwise → overlap (open ranges always overlap if they start <= endIdx)\n      if (e.startIdx > endIdx) continue;\n      if (e.endIdx !== undefined && e.endIdx < startIdx) continue;\n      matches.push(toEntry(e));\n    }\n    matches.sort(outerToInnerComparator);\n    return matches;\n  }\n\n  /** Total range count (open + closed). */\n  get size(): number {\n    return this.entries.length;\n  }\n\n  /**\n   * Wipe all ranges + reset the token counter AND rotate the owner\n   * symbol so any token from before this clear becomes invalid.\n   * Critical: without rotating the owner, a stale token whose `_id`\n   * happens to match a recycled id after clear would silently mutate\n   * the wrong entry. Owner rotation makes stale-token close a no-op\n   * via the `_owner !== this.owner` guard.\n   *\n   * Call from a consumer's runId guard when a new run starts (e.g.,\n   * agentfootprint's `observeRunId(onNewRun)` from Phase 2).\n   */\n  clear(): void {\n    this.entries.length = 0;\n    this.byId.clear();\n    this.nextId = 0;\n    this.owner = Symbol('CommitRangeIndex');\n  }\n\n  // ─── Internals ────────────────────────────────────────────────────\n\n  /** O(1) lookup by token id. Always returns the entry that the token\n   *  references (or undefined if the id was never opened in this index). */\n  private findById(id: number): InternalEntry<TLabel> | undefined {\n    return this.byId.get(id);\n  }\n}\n\n/** Project the internal mutable shape into the public readonly entry.\n *  The OUTER object is a fresh allocation per query (so caller array\n *  mutations don't leak). The `label` field is a REFERENCE COPY —\n *  if `TLabel` is an object, mutating its fields will affect the\n *  internal entry too. Consumers MUST treat labels as immutable\n *  (or pass primitives). Documented in the class JSDoc as the\n *  \"labels are stored verbatim\" contract. */\nfunction toEntry<TLabel>(e: InternalEntry<TLabel>): RangeEntry<TLabel> {\n  return e.endIdx === undefined\n    ? { label: e.label, startIdx: e.startIdx }\n    : { label: e.label, startIdx: e.startIdx, endIdx: e.endIdx };\n}\n\n/**\n * Shared outer→inner comparator for both `enclosing()` and\n * `overlapping()`. Primary key: `startIdx` ascending. Tie-break:\n * `endIdx` descending (wider range is outer). Open ranges (undefined\n * `endIdx`) sort as +Infinity → outermost when tied. Deterministic\n * ordering required so consumers (Lens breadcrumb, time-travel UIs)\n * never see flicker on equal-start boundaries (e.g., a Parallel\n * root and its first branch opening at the same commit).\n */\nfunction outerToInnerComparator<TLabel>(a: RangeEntry<TLabel>, b: RangeEntry<TLabel>): number {\n  if (a.startIdx !== b.startIdx) return a.startIdx - b.startIdx;\n  const ae = a.endIdx ?? Number.POSITIVE_INFINITY;\n  const be = b.endIdx ?? Number.POSITIVE_INFINITY;\n  return be - ae;\n}\n"]}

package/dist/lib/recorder/CompositeRecorder.js

@@ -2,8 +2,8 @@
 /**
  * CompositeRecorder — fan-out a single recorder attachment to multiple child recorders.
  *
- * Implements both Recorder (scope data ops) and FlowRecorder (control flow events)
- * so it works with both `executor.attachRecorder()` and `executor.attachFlowRecorder()`.
+ * Implements both ScopeRecorder (scope data ops) and FlowRecorder (control flow events)
+ * so it works with both `executor.attachScopeRecorder()` and `executor.attachFlowRecorder()`.
  *
  * The composite has a single ID for idempotent attach/detach. Child recorders
  * keep their own IDs internally but are not individually visible to the executor.
@@ -21,7 +21,7 @@
  *   new DebugRecorder({ verbosity: 'minimal' }),
  * ]);
  *
- * executor.attachRecorder(observability);
+ * executor.attachScopeRecorder(observability);
  *
  * // Access child recorders by type
  * const metrics = observability.get(MetricRecorder);
@@ -40,7 +40,7 @@
  * }
  *
  * // Consumer
- * executor.attachRecorder(agentObservability());
+ * executor.attachScopeRecorder(agentObservability());
  * ```
  */
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -68,7 +68,7 @@ class CompositeRecorder {
     getChildren() {
         return this.children;
     }
-    // ── Scope Recorder hooks (fan-out to children that implement Recorder) ─
+    // ── Scope ScopeRecorder hooks (fan-out to children that implement ScopeRecorder) ─
     onRead(event) {
         for (const c of this.children)
             if (c.onRead)
@@ -175,4 +175,4 @@ class CompositeRecorder {
     }
 }
 exports.CompositeRecorder = 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":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;;;AAyBH,MAAa,iBAAiB;IACnB,EAAE,CAAS;IACH,QAAQ,CAAsC;IAE/D,YAAY,EAAU,EAAE,QAA6C;QACnE,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;QACb,IAAI,CAAC,QAAQ,GAAG,CAAC,GAAG,QAAQ,CAAC,CAAC;IAChC,CAAC;IAED,yEAAyE;IAEzE;;;;;;;OAOG;IACH,GAAG,CAAI,IAA+B;QACpC,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,YAAY,IAAI,CAAkB,CAAC;IACvE,CAAC;IAED,+BAA+B;IAC/B,WAAW;QACT,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAED,oFAAoF;IAEpF,MAAM,CAAC,KAAgB;QACrB,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,QAAQ;YAAE,IAAK,CAAmB,CAAC,MAAM;gBAAG,CAAmB,CAAC,MAAO,CAAC,KAAK,CAAC,CAAC;IACtG,CAAC;IAED,OAAO,CAAC,KAAiB;QACvB,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,QAAQ;YAAE,IAAK,CAAmB,CAAC,OAAO;gBAAG,CAAmB,CAAC,OAAQ,CAAC,KAAK,CAAC,CAAC;IACxG,CAAC;IAED,QAAQ,CAAC,KAAkB;QACzB,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,QAAQ;YAAE,IAAK,CAAmB,CAAC,QAAQ;gBAAG,CAAmB,CAAC,QAAS,CAAC,KAAK,CAAC,CAAC;IAC1G,CAAC;IAED,OAAO,CAAC,KAAkC;QACxC,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,QAAQ;YAAE,IAAK,CAAmB,CAAC,OAAO;gBAAG,CAAmB,CAAC,OAAQ,CAAC,KAAY,CAAC,CAAC;IAC/G,CAAC;IAED,YAAY,CAAC,KAAiB;QAC5B,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,QAAQ;YAAE,IAAK,CAAmB,CAAC,YAAY;gBAAG,CAAmB,CAAC,YAAa,CAAC,KAAK,CAAC,CAAC;IAClH,CAAC;IAED,UAAU,CAAC,KAAiB;QAC1B,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,QAAQ;YAAE,IAAK,CAAmB,CAAC,UAAU;gBAAG,CAAmB,CAAC,UAAW,CAAC,KAAK,CAAC,CAAC;IAC9G,CAAC;IAED,4EAA4E;IAE5E,eAAe,CAAC,KAAqB;QACnC,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,QAAQ;YAAE,IAAK,CAAkB,CAAC,eAAe;gBAAG,CAAkB,CAAC,eAAgB,CAAC,KAAK,CAAC,CAAC;IACtH,CAAC;IAED,MAAM,CAAC,KAAoB;QACzB,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,QAAQ;YAAE,IAAK,CAAkB,CAAC,MAAM;gBAAG,CAAkB,CAAC,MAAO,CAAC,KAAK,CAAC,CAAC;IACpG,CAAC;IAED,UAAU,CAAC,KAAwB;QACjC,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,QAAQ;YAAE,IAAK,CAAkB,CAAC,UAAU;gBAAG,CAAkB,CAAC,UAAW,CAAC,KAAK,CAAC,CAAC;IAC5G,CAAC;IAED,MAAM,CAAC,KAAoB;QACzB,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,QAAQ;YAAE,IAAK,CAAkB,CAAC,MAAM;gBAAG,CAAkB,CAAC,MAAO,CAAC,KAAK,CAAC,CAAC;IACpG,CAAC;IAED,UAAU,CAAC,KAAwB;QACjC,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,QAAQ;YAAE,IAAK,CAAkB,CAAC,UAAU;gBAAG,CAAkB,CAAC,UAAW,CAAC,KAAK,CAAC,CAAC;IAC5G,CAAC;IAED,cAAc,CAAC,KAAuB;QACpC,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,QAAQ;YAAE,IAAK,CAAkB,CAAC,cAAc;gBAAG,CAAkB,CAAC,cAAe,CAAC,KAAK,CAAC,CAAC;IACpH,CAAC;IAED,aAAa,CAAC,KAAuB;QACnC,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,QAAQ;YAAE,IAAK,CAAkB,CAAC,aAAa;gBAAG,CAAkB,CAAC,aAAc,CAAC,KAAK,CAAC,CAAC;IAClH,CAAC;IAED,mBAAmB,CAAC,KAAiC;QACnD,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,QAAQ;YAC3B,IAAK,CAAkB,CAAC,mBAAmB;gBAAG,CAAkB,CAAC,mBAAoB,CAAC,KAAK,CAAC,CAAC;IACjG,CAAC;IAED,MAAM,CAAC,KAAoB;QACzB,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,QAAQ;YAAE,IAAK,CAAkB,CAAC,MAAM;gBAAG,CAAkB,CAAC,MAAO,CAAC,KAAK,CAAC,CAAC;IACpG,CAAC;IAED,OAAO,CAAC,KAAqB;QAC3B,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,QAAQ;YAAE,IAAK,CAAkB,CAAC,OAAO;gBAAG,CAAkB,CAAC,OAAQ,CAAC,KAAK,CAAC,CAAC;IACtG,CAAC;IAED,yEAAyE;IAEzE,KAAK;QACH,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,QAAQ;YAAE,IAAI,CAAC,CAAC,KAAK;gBAAE,CAAC,CAAC,KAAK,EAAE,CAAC;IACxD,CAAC;IAED;;;OAGG;IACH,UAAU;QACR,MAAM,cAAc,GAAuD,EAAE,CAAC;QAC9E,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAC9B,IAAI,CAAC,CAAC,UAAU,EAAE,CAAC;gBACjB,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC,UAAU,EAAE,CAAC;gBACtC,cAAc,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;YAChD,CAAC;QACH,CAAC;QACD,OAAO;YACL,IAAI,EAAE,WAAW;YACjB,IAAI,EAAE,EAAE,QAAQ,EAAE,cAAc,EAAE;SACnC,CAAC;IACJ,CAAC;CACF;AAxHD,8CAwHC","sourcesContent":["/**\n * CompositeRecorder — fan-out a single recorder attachment to multiple child recorders.\n *\n * Implements both ScopeRecorder (scope data ops) and FlowRecorder (control flow events)\n * so it works with both `executor.attachScopeRecorder()` 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.attachScopeRecorder(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.attachScopeRecorder(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, ScopeRecorder, 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 ScopeRecorder, FlowRecorder {\n  readonly id: string;\n  private readonly children: Array<ScopeRecorder | FlowRecorder>;\n\n  constructor(id: string, children: Array<ScopeRecorder | 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<ScopeRecorder | FlowRecorder> {\n    return this.children;\n  }\n\n  // ── Scope ScopeRecorder hooks (fan-out to children that implement ScopeRecorder) ─\n\n  onRead(event: ReadEvent): void {\n    for (const c of this.children) if ((c as ScopeRecorder).onRead) (c as ScopeRecorder).onRead!(event);\n  }\n\n  onWrite(event: WriteEvent): void {\n    for (const c of this.children) if ((c as ScopeRecorder).onWrite) (c as ScopeRecorder).onWrite!(event);\n  }\n\n  onCommit(event: CommitEvent): void {\n    for (const c of this.children) if ((c as ScopeRecorder).onCommit) (c as ScopeRecorder).onCommit!(event);\n  }\n\n  onError(event: ErrorEvent | FlowErrorEvent): void {\n    for (const c of this.children) if ((c as ScopeRecorder).onError) (c as ScopeRecorder).onError!(event as any);\n  }\n\n  onStageStart(event: StageEvent): void {\n    for (const c of this.children) if ((c as ScopeRecorder).onStageStart) (c as ScopeRecorder).onStageStart!(event);\n  }\n\n  onStageEnd(event: StageEvent): void {\n    for (const c of this.children) if ((c as ScopeRecorder).onStageEnd) (c as ScopeRecorder).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/lib/recorder/EmitRecorder.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * EmitRecorder — the third observer channel, alongside `Recorder`
+ * EmitRecorder — the third observer channel, alongside `ScopeRecorder`
  * (scope data-flow) and `FlowRecorder` (control-flow).
  *
  * ## Why this exists
@@ -35,7 +35,7 @@
  *
  * | Channel         | Fires when                         | Built-in consumers     |
  * |-----------------|------------------------------------|------------------------|
- * | `Recorder`      | scope read/write/commit            | DebugRecorder, MetricRecorder |
+ * | `ScopeRecorder`      | scope read/write/commit            | DebugRecorder, MetricRecorder |
  * | `FlowRecorder`  | traversal transitions              | NarrativeFlowRecorder, etc. |
  * | `EmitRecorder`  | consumer calls `scope.$emit(...)`  | (none ships today; Phase 3.X adds MemoryEmitRecorder) |
  *
@@ -60,4 +60,4 @@
  * ```
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/recorder/InOutRecorder.js

@@ -207,4 +207,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":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;;;AAGH,+DAAyD;AAMzD,0DAA0D;AAC7C,QAAA,eAAe,GAAG,UAAU,CAAC;AAE1C,oEAAoE;AACvD,QAAA,qBAAqB,GAAG,YAAY,CAAC;AAmDlD,IAAI,QAAQ,GAAG,CAAC,CAAC;AAEjB;;GAEG;AACH,SAAgB,aAAa,CAAC,UAAgC,EAAE;IAC9D,OAAO,IAAI,aAAa,CAAC,OAAO,CAAC,CAAC;AACpC,CAAC;AAFD,sCAEC;AAED;;;;;;;GAOG;AACH,MAAa,aAAc,SAAQ,sCAA4B;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,6BAAqB,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;AA3ED,sCA2EC;AAED,yEAAyE;AAEzE;;;;GAIG;AACH,SAAS,cAAc,CAAC,KAAiB,EAAE,OAAgB;IACzD,OAAO;QACL,cAAc,EAAE,6BAAqB;QACrC,SAAS,EAAE,uBAAe;QAC1B,cAAc,EAAE,uBAAe;QAC/B,WAAW,EAAE,KAAK;QAClB,WAAW,EAAE,CAAC,uBAAe,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,uBAAe,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"]}
+//# 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  /** ScopeRecorder 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"]}