footprintjs 6.1.0 → 6.1.2

package/AGENTS.md

@@ -16,7 +16,7 @@ src/lib/
 ├── scope/     → Per-stage facades + recorders + providers
 ├── reactive/  → TypedScope<T> deep Proxy (typed property access, $-methods, cycle-safe)
 ├── decide/    → decide()/select() decision evidence capture (filter + function)
-├── recorder/  → CompositeRecorder, KeyedRecorder<T>, SequenceRecorder<T>, BoundaryStateTracker<TState>, composition primitives
+├── recorder/  → CompositeRecorder, KeyedStore<T>, SequenceStore<T>, BoundaryStateStore<TState>, composition primitives
 ├── pause/     → Pause/Resume (PauseSignal, FlowchartCheckpoint, PausableHandler)
 ├── engine/    → DFS traversal + narrative + 13 handlers
 ├── runner/    → High-level executor (FlowChartExecutor)
@@ -27,7 +27,7 @@ Dependency DAG: `memory <- scope <- reactive <- engine <- runner`, `schema <- en
 
 Three entry points:
 - `import { ... } from 'footprintjs'` — public API
-- `import { ... } from 'footprintjs/trace'` — execution tracing: runtimeStageId, commitLog queries, KeyedRecorder, SequenceRecorder, BoundaryStateTracker
+- `import { ... } from 'footprintjs/trace'` — execution tracing: runtimeStageId, commitLog queries, storage primitives (KeyedStore, SequenceStore, BoundaryStateStore)
 - `import { ... } from 'footprintjs/advanced'` — engine internals (also re-exports trace)
 
 ## Key API
@@ -120,7 +120,7 @@ scope.getEnv()                     // frozen execution environment (NOT tracked)
 ```typescript
 const executor = new FlowChartExecutor(chart);
 // With options (preferred over positional params):
-const executor = new FlowChartExecutor(chart, { scopeFactory: myFactory, enrichSnapshots: true });
+const executor = new FlowChartExecutor(chart, { scopeFactory: myFactory });
 await executor.run({ input: data, env: { traceId: 'req-123' } });
 
 executor.attachRecorder(recorder) // plug scope observer
@@ -187,9 +187,9 @@ const subtree = getSubtreeSnapshot(snapshot, 'sf-payment');
 listSubflowPaths(snapshot); // ['sf-payment', 'sf-outer/sf-inner']
 ```
 
-## Two Observer Systems
+## Observer Channels
 
-Both use `{ id, hooks } -> dispatcher -> error isolation -> attach/detach`. Intentionally NOT unified.
+Four pluggable observer channels — three fire at runtime (Scope, Flow, Emit) and one fires at build time (Structure). All share `{ id, hooks } -> dispatcher -> error isolation -> attach/detach`. A recorder is routed to channels by runtime duck-typing of its `on*` methods. Intentionally NOT unified into one interface — each channel has a distinct invariant set.
 
 **Recorder ID contract:**
 - `attachRecorder` is **idempotent by ID** — same ID replaces, different IDs coexist. Prevents accidental double-counting.
@@ -201,22 +201,31 @@ Both use `{ id, hooks } -> dispatcher -> error isolation -> attach/detach`. Inte
 - Built-in: `MetricRecorder`, `DebugRecorder`
 
 **FlowRecorder** (control flow — fires AFTER stage execution):
-- `onStageExecuted`, `onNext`, `onDecision`, `onFork`, `onSelected`, `onSubflowEntry/Exit`, `onLoop`, `onBreak`, `onError`
-- All events carry `traversalContext: TraversalContext`
+- `onStageExecuted` (universal "did this stage run", carries `stageType: 'linear' | 'decider' | 'fork' | 'selector' | 'subflow-mount'`), `onNext`, `onDecision`, `onFork`, `onSelected`, `onSubflowEntry/Exit`, `onSubflowRegistered`, `onLoop`, `onBreak`, `onError`, `onPause`/`onResume`, `onRunStart`/`onRunEnd`, `onRunFailed`
+- All events carry `traversalContext: TraversalContext` (includes per-run `runId`)
 - `onDecision`/`onSelected` carry optional `evidence` from decide()/select()
 - Built-in: 8 strategies (Narrative, Adaptive, Windowed, RLE, Milestone, Progressive, Separate, Manifest, Silent)
 
-**CombinedNarrativeRecorder** implements BOTH interfaces. Attached via `executor.recorder(narrative())` at runtime.
+**Emit Recorder** (consumer-emitted events — fired by `scope.$emit(name, payload)`):
+- `onEmit(EmitEvent)` — see the "Emit Channel" section below.
+
+**Structure Recorder** (build-time chart shape — fires SYNCHRONOUSLY during builder operations, NOT runtime):
+- `onStageAdded`, `onEdgeAdded`, `onLoopEdgeAdded`, `onDeciderComplete`, `onSubflowMounted`
+- Attach via options bag — `flowChart('seed', fn, 'seed', { structureRecorders: [rec] })` — or fluent `.attachStructureRecorder(rec)`. MOUNT-ONLY: a builder's recorder sees only that builder's events; subflow internals arrive via the mount event's `subflowSpec` (walk with `walkSubflowSpec` from `footprintjs/trace`). Exported from the main `footprintjs` barrel.
+
+**CombinedNarrativeRecorder** implements the Scope + Flow + Emit interfaces. Attached via `chart.recorder(narrative())` (fluent) or `executor.attachCombinedRecorder(narrative())` / `executor.enableNarrative()` at runtime.
 
 ## Event Ordering
 
 ```
+0. FlowRecorder.onRunStart      — once per executor.run(), carries the run input
 1. Recorder.onStageStart        — stage begins
 2. Recorder.onRead/onWrite      — DURING execution (buffered per-stage)
 3. Recorder.onCommit            — transaction flush
 4. Recorder.onStageEnd          — stage completes
-5. FlowRecorder.onStageExecuted — CombinedNarrativeRecorder flushes buffered ops
-6. FlowRecorder.onNext/onDecision/onFork — control flow continues
+5. FlowRecorder.onStageExecuted — universal "stage ran" (stageType discriminator); CombinedNarrativeRecorder flushes buffered ops for LINEAR stages here
+6. FlowRecorder.onNext/onDecision/onFork/onSelected — control flow continues (non-linear onStageExecuted fires AFTER its specialized event)
+7. FlowRecorder.onRunEnd (clean) or onRunFailed (error) — once per run, closes the boundary symmetrically
 ```
 
 ## Execution Tracing (`footprintjs/trace`)
@@ -266,9 +275,13 @@ const llmCommit = findCommit(commitLog, 'call-llm', 'adapterRawResponse');
 | `findCommit(commitLog, stageId, key?)` | `CommitBundle \| undefined` | Find first commit by stageId |
 | `findCommits(commitLog, stageId)` | `CommitBundle[]` | Find all commits by stageId |
 | `findLastWriter(commitLog, key, beforeIdx?)` | `CommitBundle \| undefined` | Search backwards for who wrote a key |
-| `KeyedRecorder<T>` | abstract class | Base for 1:1 Map-based recorders (durable) |
-| `SequenceRecorder<T>` | abstract class | Base for 1:N ordered sequence recorders (durable; has `getEntryRanges()` for O(1) time-travel) |
-| `BoundaryStateTracker<TState>` | abstract class | Base for transient bracket-scoped state — live state DURING a `[start, stop]` interval; clears on stop. O(1) reads via `getActive` / `hasActive` / `activeCount`. Subclass calls `startBoundary` / `updateBoundary` / `stopBoundary` from observer hooks. |
+| `splitStageId(prefixedId)` | `{ localStageId, subflowPath }` | Decompose a bare prefixed id (`spec.id`, `CommitBundle.stageId`) |
+| `walkSubflowSpec(spec, subflowPath, opts?)` | `Generator<WalkerItem>` | Walk a subflow spec from `StructureSubflowMountedEvent.subflowSpec` |
+| `KeyedStore<T>` | class (v5 primary) | Storage shelf for 1:1 Map keyed by runtimeStageId (`set`/`get`/`aggregate`/`accumulate`/`filterByKeys`) |
+| `SequenceStore<T>` | class (v5 primary) | Storage shelf for 1:N ordered entries (`push`/`getByKey`/`getEntryRanges()` for O(1) time-travel/`getEntriesUpTo`) |
+| `BoundaryStateStore<TState>` | class (v5 primary) | Storage shelf for transient bracket-scoped state — live state DURING a `[start, stop]` interval; clears on stop. O(1) reads via `get` / `hasActive` / `activeCount`; lifecycle via `start` / `update` / `stop`. |
+| `KeyedRecorder<T>` / `SequenceRecorder<T>` / `BoundaryStateTracker<TState>` | abstract bases — **DEPRECATED** | v5 migration window only, slated for removal. Superseded by the `*Store` classes above — new code MUST own a store as a field and implement the channel interface itself. |
+| `CommitRangeIndex<TLabel>` | class | Interval index over commit indices (`open`/`close`/`enclosing`/`overlapping`) |
 | `topologyRecorder()` / `TopologyRecorder` | factory / class | Live composition graph for streaming consumers (subflow nodes + control-flow edges) |
 | `inOutRecorder()` / `InOutRecorder` | factory / class | Chart in/out stream — `entry`/`exit` pairs at every chart boundary (top-level run + every subflow) |
 
@@ -422,56 +435,54 @@ inOut.getEntryRanges();              // O(1) per-step range index for time-trave
 
 Example: [examples/runtime-features/flow-recorder/07-inout.ts](examples/runtime-features/flow-recorder/07-inout.ts)
 
-**Three recorder storage primitives** — choose based on data shape and durability:
+**Three recorder STORAGE PRIMITIVES (v5 primary API)** — "one purpose per recorder": a store is storage ONLY. You own one as a field and implement the channel interface (`ScopeRecorder` / `FlowRecorder` / `EmitRecorder` / `CombinedRecorder`) yourself, delegating storage to the store. The abstract base classes (`KeyedRecorder` / `SequenceRecorder` / `BoundaryStateTracker`) are DEPRECATED — they exist only for the v5 migration window and are slated for removal. Choose a store by data shape and durability:
 
-| Base Class | Relationship | Time scope | Use When |
+| Store | Relationship | Time scope | Use When |
 |------------|-------------|------------|----------|
-| `KeyedRecorder<T>` | 1:1 Map | durable | Each step produces one record (MetricRecorder, TokenRecorder) |
-| `SequenceRecorder<T>` | 1:N sequence + Map | durable | Multiple records per step, ordering matters (CombinedNarrativeRecorder) |
-| `BoundaryStateTracker<TState>` | Map\<key, TState\> active stack | transient — clears on stop | Live state DURING a `[start, stop]` bracket (LLM stream partial, tool args streaming) |
-
-A real recorder picks ONE observer interface AND ONE storage shelf, combining via `extends + implements`. Existing example: `BoundaryRecorder extends SequenceRecorder<DomainEvent> implements CombinedRecorder`.
+| `KeyedStore<T>` | 1:1 Map | durable | Each step produces one record (token totals per step) |
+| `SequenceStore<T>` | 1:N sequence + Map | durable | Multiple records per step, ordering matters (narrative, audit) |
+| `BoundaryStateStore<TState>` | Map\<key, TState\> active bracket | transient — clears on stop | Live state DURING a `[start, stop]` bracket (LLM stream partial, tool args streaming) |
 
 ```typescript
-import { KeyedRecorder, SequenceRecorder } from 'footprintjs/trace';
+import { KeyedStore, SequenceStore, BoundaryStateStore } from 'footprintjs/trace';
+import type { FlowRecorder, EmitRecorder } from 'footprintjs';
 
-// KeyedRecorder: one entry per step
-class TokenRecorder extends KeyedRecorder<TokenEntry> {
+// KeyedStore: one entry per step. Own the store; implement the channel.
+class TokenRecorder implements FlowRecorder {
   readonly id = 'tokens';
-  onLLMCall(event) { this.store(event.runtimeStageId, { tokens: event.usage }); }
+  private store = new KeyedStore<{ tokens: number }>();
+  onStageExecuted(e) { this.store.set(e.traversalContext.runtimeStageId, { tokens: 0 }); }
+  byStep(rid: string) { return this.store.get(rid); }                       // Translate: per-step value
+  total() { return this.store.aggregate((sum, e) => sum + e.tokens, 0); }   // Aggregate: grand total
+  upTo(keys: ReadonlySet<string>) {                                          // Accumulate: up to slider
+    return this.store.accumulate((sum, e) => sum + e.tokens, 0, keys);
+  }
 }
-recorder.getByKey('call-llm#5');                               // Translate: per-step value
-recorder.aggregate((sum, e) => sum + e.tokens, 0);             // Aggregate: grand total
-recorder.accumulate((sum, e) => sum + e.tokens, 0, visibleKeys); // Accumulate: up to slider
 
-// SequenceRecorder: multiple entries per step, ordered
-class AuditRecorder extends SequenceRecorder<AuditEntry> {
+// SequenceStore: multiple entries per step, ordered.
+class AuditRecorder implements FlowRecorder {
   readonly id = 'audit';
-  onRead(event) { this.emit({ runtimeStageId: event.runtimeStageId, type: 'read', key: event.key }); }
-  onDecision(event) { this.emit({ runtimeStageId: event.traversalContext?.runtimeStageId, ... }); }
+  private store = new SequenceStore<{ runtimeStageId: string; type: string }>();
+  onDecision(e) { this.store.push({ runtimeStageId: e.traversalContext?.runtimeStageId, type: 'decision' }); }
+  forStep(rid: string) { return this.store.getByKey(rid); }                  // Translate: per-step entries
+  upTo(keys: ReadonlySet<string>) { return this.store.getEntriesUpTo(keys); } // Progressive: up to slider
+  ranges() { return this.store.getEntryRanges(); }                           // Range index: O(1) slider sync
 }
-recorder.getEntriesForStep('call-llm#5');                      // Translate: per-step entries
-recorder.aggregate((count, _) => count + 1, 0);                // Aggregate: grand total
-recorder.getEntriesUpTo(visibleKeys);                           // Progressive: up to slider
-recorder.getEntryRanges();                                      // Range index: O(1) slider sync
-
-// BoundaryStateTracker: transient state DURING a bracket; clears on stop
-class LiveLLMTracker extends BoundaryStateTracker<{ partial: string; tokens: number }>
-  implements EmitRecorder
-{
+
+// BoundaryStateStore: transient state DURING a bracket; clears on stop.
+class LiveLLMTracker implements EmitRecorder {
   readonly id = 'live-llm';
+  private store = new BoundaryStateStore<{ partial: string; tokens: number }>();
   onEmit(e) {
-    if (e.name === 'llm.start') this.startBoundary(e.runtimeStageId, { partial: '', tokens: 0 });
-    if (e.name === 'llm.token') this.updateBoundary(e.runtimeStageId, s => ({ partial: s.partial + e.payload.content, tokens: s.tokens + 1 }));
-    if (e.name === 'llm.end')   this.stopBoundary(e.runtimeStageId);
+    if (e.name === 'llm.start') this.store.start(e.runtimeStageId, { partial: '', tokens: 0 });
+    if (e.name === 'llm.token') this.store.update(e.runtimeStageId, s => ({ partial: s.partial + e.payload.content, tokens: s.tokens + 1 }));
+    if (e.name === 'llm.end')   this.store.stop(e.runtimeStageId);
   }
-  isInFlight(): boolean { return this.hasActive; }
-  getPartial(rid: string): string { return this.getActive(rid)?.partial ?? ''; }
+  isInFlight() { return this.store.hasActive; }                              // O(1) — live read
+  getPartial(rid: string) { return this.store.get(rid)?.partial ?? ''; }     // O(1) — current state of one boundary
+  concurrent() { return this.store.activeCount; }                            // O(1) — how many concurrent boundaries
 }
-tracker.isInFlight();              // O(1) — live read
-tracker.getActive(rid);            // O(1) — current state of one boundary
-tracker.activeCount;               // O(1) — how many concurrent boundaries
-// Lifecycle: clear() between runs; dev-mode warns on leaked-stop bugs.
+// Lifecycle: call store.clear() between runs; dev-mode warns on leaked-stop bugs.
 ```
 
 **`getEntryRanges()`** returns a precomputed `Map<runtimeStageId, {firstIdx, endIdx}>` maintained during `emit()`. Use for O(1) per-step range lookups during time-travel scrubbing. Same shape as `buildEntryRangeIndex()` in `footprint-explainable-ui`.

package/CLAUDE.md

@@ -16,7 +16,7 @@ src/lib/
 ├── scope/     → Per-stage facades + recorders + providers
 ├── reactive/  → TypedScope<T> deep Proxy (typed property access, $-methods, cycle-safe)
 ├── decide/    → decide()/select() decision evidence capture (filter + function)
-├── recorder/  → CompositeRecorder, KeyedRecorder<T>, SequenceRecorder<T>, composition primitives
+├── recorder/  → CompositeRecorder, stores (KeyedStore/SequenceStore/BoundaryStateStore), CommitRangeIndex, composition primitives
 ├── pause/     → Pause/Resume (PauseSignal, FlowchartCheckpoint, PausableHandler)
 ├── engine/    → DFS traversal + narrative + 13 handlers
 ├── runner/    → High-level executor (FlowChartExecutor)
@@ -27,7 +27,7 @@ Dependency DAG: `memory <- scope <- reactive <- engine <- runner`, `schema <- en
 
 Three entry points:
 - `import { ... } from 'footprintjs'` — public API
-- `import { ... } from 'footprintjs/trace'` — execution tracing: runtimeStageId, commitLog queries, KeyedRecorder, SequenceRecorder
+- `import { ... } from 'footprintjs/trace'` — execution tracing: runtimeStageId, commitLog queries, causal chain, recorder stores (`KeyedStore`/`SequenceStore`/`BoundaryStateStore`), `CommitRangeIndex`, `TopologyRecorder`/`InOutRecorder`/`QualityRecorder`
 - `import { ... } from 'footprintjs/advanced'` — engine internals (also re-exports trace)
 
 ## Key API
@@ -89,7 +89,7 @@ import { decide, select } from 'footprintjs';
 ```typescript
 import { flowChart, FlowChartBuilder } from 'footprintjs';
 
-const chart = flowChart('Stage1', fn1, 'stage-1', undefined, 'Description')
+const chart = flowChart('Stage1', fn1, 'stage-1', { description: 'Description' })
   .addFunction('Stage2', fn2, 'stage-2', 'Description')
   .addDeciderFunction('Decide', deciderFn, 'decide', 'Route based on risk')
     .addFunctionBranch('high', 'Reject', rejectFn)
@@ -123,13 +123,14 @@ const executor = new FlowChartExecutor(chart);
 const executor = new FlowChartExecutor(chart, { scopeFactory: myFactory });
 await executor.run({ input: data, env: { traceId: 'req-123' } });
 
-executor.attachRecorder(recorder) // plug scope observer
-executor.getNarrative()           // combined flow + data narrative
-executor.getNarrativeEntries()    // structured entries with type/depth/stageName/stageId
-executor.getFlowNarrative()       // flow-only (no data ops)
-executor.getSnapshot()            // full memory state (includes recorder snapshots)
-executor.attachFlowRecorder(r)    // plug flow observer
-executor.setRedactionPolicy({})   // PII protection
+executor.attachScopeRecorder(recorder)  // plug scope (data) observer
+executor.attachFlowRecorder(r)          // plug flow observer
+executor.attachCombinedRecorder(r)      // plug observer across all channels (routed by method-shape)
+executor.attachEmitRecorder(r)          // plug emit observer
+executor.enableNarrative()              // turn on the built-in combined narrative recorder
+executor.getNarrativeEntries()          // structured entries with type/depth/stageName/stageId
+executor.getSnapshot()                  // full memory state (includes recorder snapshots)
+executor.setRedactionPolicy({})         // PII protection
 
 // Pause/Resume — human-in-the-loop
 executor.isPaused()               // true if last run paused
@@ -174,7 +175,7 @@ if (executor.isPaused()) {
 
 - `execute` returns data → pauses. Returns void → continues normally (conditional pause).
 - Checkpoint is JSON-serializable — no functions, no class instances.
-- `resume()` reuses the execution runtime — narrative, metrics, execution tree all accumulate.
+- `resume()` resets narrative/recorder state — collect any narrative you need from the paused run BEFORE resuming. A fresh `runId` is generated for the resumed run.
 - `FlowRecorder.onPause`/`onResume` and `Recorder.onPause`/`onResume` fire on both observer systems.
 
 ### ComposableRunner & Snapshot Navigation
@@ -195,20 +196,20 @@ Intentionally NOT unified into one giant interface — each channel has
 a distinct invariant set.
 
 **Recorder ID contract:**
-- `attachRecorder` is **idempotent by ID** — same ID replaces, different IDs coexist. Prevents accidental double-counting.
+- Every `attach*Recorder` call (`attachScopeRecorder` / `attachFlowRecorder` / `attachEmitRecorder` / `attachCombinedRecorder`) is **idempotent by ID** — same ID replaces, different IDs coexist. Prevents accidental double-counting.
 - Built-in recorders use auto-increment default IDs (`metrics-1`, `debug-1`, ...) so multiple instances with different configs coexist naturally.
 - Frameworks that auto-attach recorders should use a well-known ID (e.g., `new MetricRecorder('metrics')`) so the consumer can override it by passing the same ID, or add a second instance with `new MetricRecorder()` (gets unique ID).
 
-**Scope Recorder** (data ops — fires DURING stage execution):
-- `onRead`, `onWrite`, `onCommit`, `onError`, `onStageStart`, `onStageEnd`
+**Scope Recorder** (`ScopeRecorder`; data ops — fires DURING stage execution):
+- `onRead`, `onWrite`, `onCommit`, `onError`, `onStageStart`, `onStageEnd`, `onPause`/`onResume`, `onEmit`
 - Built-in: `MetricRecorder`, `DebugRecorder`
 
 **FlowRecorder** (control flow — fires AFTER stage execution):
-- `onStageExecuted`, `onNext`, `onDecision`, `onFork`, `onSelected`, `onSubflowEntry/Exit`, `onLoop`, `onBreak`, `onError`, `onPause`/`onResume`, `onRunStart`/`onRunEnd`
+- `onStageExecuted`, `onNext`, `onDecision`, `onFork`, `onSelected`, `onSubflowEntry/Exit`, `onSubflowRegistered`, `onLoop`, `onBreak`, `onError`, `onPause`/`onResume`, `onRunStart`/`onRunEnd`, `onRunFailed` (terminal counterpart to `onRunEnd` — closes the run boundary on error)
 - All events carry `traversalContext: TraversalContext`
 - `onDecision`/`onSelected` carry optional `evidence` from decide()/select()
 - **`onStageExecuted` fires UNIFORMLY for every stage kind** (linear / decider / fork / selector / subflow-mount) as of v6.0+ proposal #003. Event payload carries `stageType: 'linear' | 'decider' | 'fork' | 'selector' | 'subflow-mount'`. Specialized events (`onDecision`/`onFork`/`onSelected`/`onSubflowEntry`) STILL fire — `onStageExecuted` is the universal "did this stage run" signal AFTER them.
-- Built-in: 8 strategies (Narrative, Adaptive, Windowed, RLE, Milestone, Progressive, Separate, Manifest, Silent)
+- Built-in: 9 strategies (Narrative, Adaptive, Windowed, RLE, Milestone, Progressive, Separate, Manifest, Silent)
 
 **StructureRecorder** (build-time chart shape — fires SYNCHRONOUSLY during builder operations, NOT runtime):
 - `onStageAdded`, `onEdgeAdded`, `onLoopEdgeAdded`, `onDeciderComplete`, `onSubflowMounted`
@@ -218,7 +219,7 @@ a distinct invariant set.
 
 **EmitRecorder** (consumer-emitted events — third channel, see "Emit Channel" section below).
 
-**CombinedRecorder** is a union shape that routes by runtime method-shape detection — implement only the hooks you care about across all three channels; one `attachCombinedRecorder` call. `CombinedNarrativeRecorder` is the canonical built-in; attach via `executor.recorder(narrative())`.
+**CombinedRecorder** is a union shape that routes by runtime method-shape detection — implement only the hooks you care about across all three channels; one `attachCombinedRecorder` call. `CombinedNarrativeRecorder` is the canonical built-in; attach via `chart.recorder(narrative())` (the chart's `.recorder()` sugar) or `executor.attachCombinedRecorder(narrative())`.
 
 **Stage type discrimination on `onStageExecuted`** — under proposal #003, consumers wanting linear-only behavior must filter:
 ```ts
@@ -290,10 +291,15 @@ const llmCommit = findCommit(commitLog, 'call-llm', 'adapterRawResponse');
 | `findCommit(commitLog, stageId, key?)` | `CommitBundle \| undefined` | Find first commit by stageId |
 | `findCommits(commitLog, stageId)` | `CommitBundle[]` | Find all commits by stageId |
 | `findLastWriter(commitLog, key, beforeIdx?)` | `CommitBundle \| undefined` | Search backwards for who wrote a key |
-| `KeyedRecorder<T>` | abstract class | Base for 1:1 Map-based recorders |
-| `SequenceRecorder<T>` | abstract class | Base for 1:N ordered sequence recorders (has `getEntryRanges()` for O(1) time-travel) |
+| `causalChain` / `flattenCausalDAG` / `formatCausalChain` | functions | Backward program slicing over the commit-log DAG |
+| `KeyedStore<T>` | class | **Primary** 1:1 Map store — own as a field on your recorder |
+| `SequenceStore<T>` | class | **Primary** 1:N ordered store (has `getEntryRanges()` for O(1) time-travel) |
+| `BoundaryStateStore<T>` | class | **Primary** transient bracket-scoped state store |
+| `CommitRangeIndex<TLabel>` | class | Interval index over commit indices (`open`/`close`/`enclosing`/`overlapping`) |
+| `KeyedRecorder<T>` / `SequenceRecorder<T>` / `BoundaryStateTracker<T>` | abstract classes (DEPRECATED) | Legacy bases — migrate to the stores above |
 | `topologyRecorder()` / `TopologyRecorder` | factory / class | Live composition graph for streaming consumers (subflow nodes + control-flow edges) |
 | `inOutRecorder()` / `InOutRecorder` | factory / class | Chart in/out stream — `entry`/`exit` pairs at every chart boundary (top-level run + every subflow) |
+| `QualityRecorder` + `qualityTrace`/`formatQualityTrace` | class / functions | Per-step quality scoring + Quality Stack Trace backtracking |
 
 ### TopologyRecorder — Composition Graph for Streaming Consumers
 
@@ -445,12 +451,13 @@ inOut.getEntryRanges();              // O(1) per-step range index for time-trave
 
 Example: [examples/runtime-features/flow-recorder/07-inout.ts](examples/runtime-features/flow-recorder/07-inout.ts)
 
-**Two recorder base classes** — choose based on data shape:
+**Two recorder base classes (DEPRECATED — v5 migration window, slated for removal)** — choose based on data shape. New code MUST use the v5 stores instead (own a `KeyedStore<T>` / `SequenceStore<T>` / `BoundaryStateStore<T>` field and implement the channel interface yourself — see "Project conventions" Convention 1). These bases are kept only for downstream consumers that still extend them:
 
-| Base Class | Relationship | Use When |
-|------------|-------------|----------|
-| `KeyedRecorder<T>` | 1:1 Map | Each step produces one record (MetricRecorder, TokenRecorder) |
-| `SequenceRecorder<T>` | 1:N sequence + Map | Multiple records per step, ordering matters (CombinedNarrativeRecorder) |
+| Base Class | Store replacement | Relationship | Use When |
+|------------|-------------------|-------------|----------|
+| `KeyedRecorder<T>` | `KeyedStore<T>` | 1:1 Map | Each step produces one record (MetricRecorder, TokenRecorder) |
+| `SequenceRecorder<T>` | `SequenceStore<T>` | 1:N sequence + Map | Multiple records per step, ordering matters (CombinedNarrativeRecorder) |
+| `BoundaryStateTracker<T>` | `BoundaryStateStore<T>` | bracket-scoped state | Live transient state during a `[start, stop]` event interval |
 
 ```typescript
 import { KeyedRecorder, SequenceRecorder } from 'footprintjs/trace';
@@ -670,7 +677,7 @@ const audit: CombinedRecorder = {
 executor.attachCombinedRecorder(audit);
 ```
 
-Built on `CombinedRecorder`: `CombinedNarrativeRecorder` (the `executor.enableNarrative()` default). Consumers implement ONLY the events they care about — `Partial<Recorder> & Partial<FlowRecorder>` under the hood.
+Built on `CombinedRecorder`: `CombinedNarrativeRecorder` (the `executor.enableNarrative()` default). Consumers implement ONLY the events they care about — `Partial<ScopeRecorder> & Partial<FlowRecorder> & Partial<EmitRecorder>` under the hood.
 
 **Detection rule:** only OWN event-method properties count (prototype methods are ignored for security — prevents accidental `Object.prototype` pollution from attaching handlers).
 
@@ -683,7 +690,7 @@ Built on `CombinedRecorder`: `CombinedNarrativeRecorder` (the `executor.enableNa
 - Don't extract shared base for ScopeRecorder/FlowRecorder — two instances = coincidence
 - Don't use `getArgs()` for tracked data — use typed scope properties
 - Don't put infrastructure data in `getArgs()` — use `getEnv()` via `run({ env })`
-- Don't manually create `CombinedNarrativeRecorder` — `executor.recorder(narrative())` handles it
+- Don't manually create `CombinedNarrativeRecorder` — `chart.recorder(narrative())` (or `executor.attachCombinedRecorder(narrative())`) handles it
 - Don't return full arrays from `outputMapper` without `arrayMerge: ArrayMergeMode.Replace` — default `applyOutputMapping` **concatenates** arrays (`[...parent, ...subflow]`). Either return only the **delta** (new items), or set `arrayMerge: ArrayMergeMode.Replace` on `SubflowMountOptions` to overwrite instead of concatenate. Scalars are always replaced regardless.
 
 ## Project conventions (5.0+)

package/README.md

@@ -9,6 +9,8 @@
   <a href="https://github.com/footprintjs/footPrint/actions"><img src="https://github.com/footprintjs/footPrint/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
   <!-- coverage-badge --><img src="https://img.shields.io/badge/coverage-93%25-brightgreen.svg" alt="coverage: 93%"><!-- /coverage-badge -->
   <a href="https://www.npmjs.com/package/footprintjs"><img src="https://img.shields.io/npm/v/footprintjs.svg?style=flat" alt="npm version"></a>
+  <a href="https://bundlephobia.com/package/footprintjs"><img src="https://img.shields.io/bundlephobia/minzip/footprintjs?label=minzipped" alt="minzipped size"></a>
+  <a href="#tree-shakeable--esm-first"><img src="https://img.shields.io/badge/tree--shakeable-%E2%9C%93-success?style=flat" alt="tree-shakeable"></a>
   <a href="https://github.com/footprintjs/footPrint/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="MIT License"></a>
   <a href="https://www.npmjs.com/package/footprintjs"><img src="https://img.shields.io/npm/dm/footprintjs.svg" alt="Downloads"></a>
   <a href="https://footprintjs.github.io/footprint-playground/samples/llm-agent-tool"><img src="https://img.shields.io/badge/Try_with_LLM-Live_Demo-7c6cf0?style=flat" alt="Try with LLM"></a>
@@ -166,7 +168,24 @@ The LLM calls the tool, gets back the decision and causal trace, and explains th
 | **Subflow break propagation** | Mount a subflow with `propagateBreak: true` &mdash; inner `$break` terminates the parent loop, with drill-down preserved |
 | **Emit channel** | `scope.$emit(name, payload)` &mdash; user-authored structured events to `EmitRecorder`, pass-through, zero-allocation when no recorder attached, redactable via `emitPatterns` |
 | **Detach** *(new in 4.17)* | `scope.$detachAndForget(driver, child, input)` and `scope.$detachAndJoinLater(driver, child, input)` &mdash; fire-and-forget child flowcharts via the `footprintjs/detach` subpath. Six built-in drivers (microtask / immediate / setImmediate / setTimeout / sendBeacon / workerThread) + custom-driver protocol. Builder-native composition (`addDetachAndForget` / `addDetachAndJoinLater`) makes detach a labeled chart stage. `flushAllDetached()` for graceful shutdown. [Guide →](https://footprintjs.github.io/footPrint/guides/patterns/detach/) |
-| **Boundary state tracking** *(new in 4.17.2)* | `BoundaryStateTracker<TState>` &mdash; third storage primitive on the recorder shelf alongside `SequenceRecorder<T>` (durable ordered) and `KeyedRecorder<T>` (durable 1:1). Tracks live transient state DURING a `[start, stop]` event interval (LLM stream partial, tool args streaming, agent turn state) and clears on stop. O(1) reads via `getActive` / `hasActive` / `activeCount`. Mental model: existing recorder *interfaces* are observers; storage primitives are *bookkeeping shelves*. A real recorder picks ONE observer interface AND ONE storage shelf via `extends + implements`. [Guide →](https://footprintjs.github.io/footPrint/guides/features/recorder-storage-primitives/) |
+| **Recorder storage primitives** | `BoundaryStateStore<TState>` &mdash; one of three composable storage shelves alongside `SequenceStore<T>` (durable ordered, with `getEntryRanges()`) and `KeyedStore<T>` (durable 1:1). `BoundaryStateStore` tracks live transient state DURING a `[start, stop]` event interval (LLM stream partial, tool args streaming, agent turn state) and clears on stop. O(1) reads via `get` / `hasActive` / `activeCount`. Mental model: recorder *interfaces* (`ScopeRecorder` / `FlowRecorder` / `EmitRecorder`) are observers; stores are *bookkeeping shelves*. A real recorder picks ONE observer interface and OWNS the store as a field (composition &mdash; "one purpose per recorder"). The `Store` classes are exported from `footprintjs/trace`. (Older `KeyedRecorder` / `SequenceRecorder` / `BoundaryStateTracker` abstract bases are deprecated and slated for removal &mdash; use the stores.) [Guide →](https://footprintjs.github.io/footPrint/guides/features/recorder-storage-primitives/) |
+
+---
+
+## Tree-shakeable & ESM-first
+
+Import one thing, ship one thing. footprintjs is built so your bundle grows only with what you actually use:
+
+- **Dual build, true ESM.** Ships CommonJS (`require`) **and** real ECMAScript Modules (`import`) with TypeScript types. The ESM build is marked `type:module` and every internal import carries an explicit `.js` extension, so it loads as true ESM under Node, Vite, Next, Deno, and Bun — no compatibility shims.
+- **Per-file modules + `sideEffects:false`.** The dist is emitted file-by-file (never pre-bundled) and declares zero side effects, so bundlers can drop every export you don't touch.
+- **Subpath exports.** Pull execution tracing from `footprintjs/trace`, fire-and-forget children from `footprintjs/detach`, engine internals from `footprintjs/advanced` — each is independently tree-shakeable.
+
+**Proven, not promised.** A CI smoke test bundles a minimal `import { flowChart } from 'footprintjs'` and asserts the recorder, detach, and trace layers are pruned — your flowchart core doesn't drag them in. See [`test/esm-packaging.test.ts`](test/esm-packaging.test.ts).
+
+```ts
+// Only flowChart? The recorder/detach/trace layers are tree-shaken away.
+import { flowChart } from 'footprintjs';
+```
 
 ---
 

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

@@ -34,4 +34,4 @@
  *   - Type-level rejection of `outputMapper` on detach options
  */
 export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/lib/detach/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG","sourcesContent":["/**\n * detach/types.ts — Type definitions for the fire-and-forget primitive.\n *\n * Pattern:  Strategy + Bridge (GoF). Same shape as cache strategies in\n *           agentfootprint v2.6 — ONE interface, N concrete drivers,\n *           consumer picks via explicit import.\n * Role:     Foundation. Every other detach file imports from here.\n *           This is the lockable contract; downstream files implement it.\n *\n * Two sibling concepts:\n *\n *   1. `DetachDriver` — the algorithm that decides WHEN/HOW the work runs.\n *      Six built-in algorithms ship as algorithm-named exports\n *      (`microtaskBatchDriver`, `setImmediateDriver`, `sendBeaconDriver`,\n *      `setTimeoutDriver`, `immediateDriver`, `workerThreadDriver`).\n *      Consumers can implement their own (BYOS — bring your own driver).\n *\n *   2. `DetachHandle` — the consumer-facing handle returned by\n *      `detachAndJoinLater`. Exposes status as PROPERTIES (sync read)\n *      and `wait()` (Promise — opt-in async join). Style 2 from the\n *      panel review: properties for sync, single method for async.\n *\n * Naming policy (locked from naming review):\n *   - Public API uses simple verbs / properties (product-engineer friendly)\n *   - Internal class names CAN use CS terms (Scheduler, Continuation, etc.)\n *   - Drivers are algorithm-named (semantic at the algorithm level)\n *\n * Locked design decisions (panel review captured in\n * `docs/inspiration/detach-primitive.md`):\n *   - Sync hot path; async only at flush boundaries\n *   - Errors → commitLog + typed event, NEVER thrown to parent\n *   - Scope isolation between parent and detached child\n *   - Lifecycle tied to executor disposal\n *   - Type-level rejection of `outputMapper` on detach options\n */\n\nimport type { FlowChart } from '../builder/types.js';\n\n// ─── DetachHandle — what the consumer gets back ──────────────────────\n\n/**\n * Snapshot of a detached handle's state. Returned by `handle.poll()`\n * (when added in a follow-up; v1 exposes properties directly on\n * `DetachHandle`).\n */\nexport interface DetachPollResult {\n  readonly status: DetachHandle['status'];\n  /** Present iff status === 'done'. */\n  readonly result?: unknown;\n  /** Present iff status === 'failed'. */\n  readonly error?: Error;\n}\n\n/**\n * Result delivered when the handle's `wait()` Promise resolves\n * successfully (status reached 'done'). Rejection delivers the\n * native `Error` directly — no wrapping shape.\n */\nexport interface DetachWaitResult {\n  readonly result: unknown;\n}\n\n/**\n * Handle returned by `chart.detachAndJoinLater(...)` and\n * `executor.detachAndJoinLater(...)`. Exposes status as PROPERTIES so\n * sync access is property-read (cheap, no allocation). The single\n * method `wait()` returns a Promise for opt-in async join.\n *\n * The handle is **not** Promise-shaped (no `.then()`) — that would\n * make it accidentally awaitable, defeating the fire-and-forget\n * semantics. To await, the consumer must call `.wait()` explicitly.\n *\n * Lifecycle:\n *\n *   queued  → driver received the work, hasn't started it\n *   running → driver started the work\n *   done    → terminal: result available\n *   failed  → terminal: error available\n *\n * `done` and `failed` are TERMINAL — once reached, status never\n * changes again.\n */\nexport interface DetachHandle {\n  /** Stable id assigned at detach time. Used as the lookup key in\n   *  `detachRegistry` and as the scope-storage key prefix. */\n  readonly id: string;\n\n  /** Current state. Read directly for sync access. */\n  readonly status: 'queued' | 'running' | 'done' | 'failed';\n\n  /** The work's result. Present iff `status === 'done'`. Reading\n   *  before terminal returns `undefined`. */\n  readonly result?: unknown;\n\n  /** The work's error. Present iff `status === 'failed'`. Reading\n   *  before terminal returns `undefined`. */\n  readonly error?: Error;\n\n  /**\n   * Opt-in async join. Returns a Promise that:\n   *   - resolves with `{ result }` when status becomes 'done'\n   *   - rejects with the captured `Error` when status becomes 'failed'\n   *   - resolves/rejects IMMEDIATELY if status is already terminal\n   *   - returns the SAME cached Promise on repeated calls (no\n   *     re-running, no duplicated I/O)\n   *\n   * Calling `wait()` does NOT change the handle's lifecycle — it's\n   * passive observation. If never called, the work still completes;\n   * the handle just goes uncollected (parent execution unaffected).\n   *\n   * Use when:\n   *   - You actually need the result and want to await it\n   *   - Coordinating multiple handles via Promise.all / Promise.race\n   *   - Backpressure (\"don't fire more than N in flight\")\n   *\n   * Don't use when:\n   *   - Pure fire-and-forget (use `detachAndForget` — no handle returned)\n   *   - You just want to check status (read `handle.status` directly)\n   */\n  wait(): Promise<DetachWaitResult>;\n}\n\n// ─── DetachDriver — the algorithm interface ──────────────────────────\n\n/**\n * Capabilities a driver declares. Drives the runtime decision of\n * \"is this driver appropriate for the current environment?\" Consumers\n * inspect at construction; the framework doesn't enforce.\n *\n * All capabilities are optional flags — false / undefined means \"not\n * supported / no claim.\" A driver that supports everything sets all\n * to true.\n */\nexport interface DriverCapabilities {\n  /** Driver works in browser environments (window, document, etc.). */\n  readonly browserSafe?: boolean;\n  /** Driver works in Node.js environments. */\n  readonly nodeSafe?: boolean;\n  /** Driver works in edge runtimes (Cloudflare Workers, Deno Deploy,\n   *  Bun edge, etc. — restricted environments). */\n  readonly edgeSafe?: boolean;\n  /** Work survives page-unload / process-exit. e.g.,\n   *  `sendBeaconDriver` schedules via `navigator.sendBeacon` which\n   *  ships even on tab close. */\n  readonly survivesUnload?: boolean;\n  /** Work runs on a separate OS thread (no event-loop block).\n   *  e.g., `workerThreadDriver`. */\n  readonly cpuIsolated?: boolean;\n}\n\n/**\n * A driver is the WHEN/HOW of the detach. Maps `(child, input, refId)`\n * to a `DetachHandle` whose lifecycle the driver owns.\n *\n * Drivers are themselves footprintjs primitives — internally they may\n * be a single function or a multi-stage flowChart. Either way, the\n * interface they expose to consumers is `schedule(...)`.\n *\n * Drivers MUST:\n *   - Return synchronously (the agent loop never blocks on schedule)\n *   - Not throw — errors during scheduling route through the handle\n *     (`handle.status = 'failed'`, `handle.error = ...`)\n *   - Honor the passive-recorder rule: the parent's `detach*` call\n *     never waits for the driver's deferred work to complete\n *\n * Drivers MAY:\n *   - Implement `validate()` for one-time configuration checks at\n *     registration / use time (e.g., assert `navigator.sendBeacon` exists)\n *   - Build their internal pipeline as a footprintjs flowChart for\n *     observability — driver implementation detail, not consumer-facing\n *\n * @example Built-in\n *   import { microtaskBatchDriver } from 'footprintjs/detach';\n *   const handle = driver.schedule(child, input, refId);\n *\n * @example Custom (BYOS)\n *   const lambdaExtensionDriver: DetachDriver = {\n *     name: 'lambda-extension',\n *     capabilities: { nodeSafe: true, survivesUnload: true },\n *     schedule(child, input, refId) {\n *       sharedBuffer.push({ refId, child, input });\n *       return createHandle(refId, 'queued');\n *     },\n *   };\n */\nexport interface DetachDriver {\n  /** Stable name for diagnostics + registry lookup. Conventionally\n   *  algorithm-named (e.g. `'microtask-batch'`, `'send-beacon'`). */\n  readonly name: string;\n\n  /** What this driver supports. Used by consumers to pick the right\n   *  driver for their environment. */\n  readonly capabilities: DriverCapabilities;\n\n  /**\n   * Hand the work to the driver's scheduling mechanism. MUST return\n   * synchronously with a fresh `DetachHandle`. The actual work may\n   * run later (next microtask / setImmediate / browser-beacon-flush /\n   * worker-thread / etc.) on the driver's chosen mechanism.\n   */\n  schedule(child: FlowChart, input: unknown, refId: string): DetachHandle;\n\n  /**\n   * Optional one-time validation hook. Called at first use (or\n   * registration time, depending on driver) — drivers throw if their\n   * configuration is invalid (missing peer dep, unreachable endpoint,\n   * wrong API key shape, etc.).\n   *\n   * Example: `sendBeaconDriver.validate()` checks\n   * `typeof navigator?.sendBeacon === 'function'` and throws with a\n   * helpful message if absent (e.g., in Node).\n   *\n   * Per the New Relic panel review: early-fail-with-useful-message\n   * beats silent zero-emission.\n   */\n  validate?(): void;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/lib/detach/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG","sourcesContent":["/**\n * detach/types.ts — Type definitions for the fire-and-forget primitive.\n *\n * Pattern:  Strategy + Bridge (GoF). Same shape as cache strategies in\n *           agentfootprint v2.6 — ONE interface, N concrete drivers,\n *           consumer picks via explicit import.\n * Role:     Foundation. Every other detach file imports from here.\n *           This is the lockable contract; downstream files implement it.\n *\n * Two sibling concepts:\n *\n *   1. `DetachDriver` — the algorithm that decides WHEN/HOW the work runs.\n *      Six built-in algorithms ship as algorithm-named exports\n *      (`microtaskBatchDriver`, `setImmediateDriver`, `sendBeaconDriver`,\n *      `setTimeoutDriver`, `immediateDriver`, `workerThreadDriver`).\n *      Consumers can implement their own (BYOS — bring your own driver).\n *\n *   2. `DetachHandle` — the consumer-facing handle returned by\n *      `detachAndJoinLater`. Exposes status as PROPERTIES (sync read)\n *      and `wait()` (Promise — opt-in async join). Style 2 from the\n *      panel review: properties for sync, single method for async.\n *\n * Naming policy (locked from naming review):\n *   - Public API uses simple verbs / properties (product-engineer friendly)\n *   - Internal class names CAN use CS terms (Scheduler, Continuation, etc.)\n *   - Drivers are algorithm-named (semantic at the algorithm level)\n *\n * Locked design decisions (panel review captured in\n * `docs/inspiration/detach-primitive.md`):\n *   - Sync hot path; async only at flush boundaries\n *   - Errors → commitLog + typed event, NEVER thrown to parent\n *   - Scope isolation between parent and detached child\n *   - Lifecycle tied to executor disposal\n *   - Type-level rejection of `outputMapper` on detach options\n */\n\nimport type { FlowChart } from '../builder/types.js';\n\n// ─── DetachHandle — what the consumer gets back ──────────────────────\n\n/**\n * Snapshot of a detached handle's state. Returned by `handle.poll()`\n * (when added in a follow-up; v1 exposes properties directly on\n * `DetachHandle`).\n */\nexport interface DetachPollResult {\n  readonly status: DetachHandle['status'];\n  /** Present iff status === 'done'. */\n  readonly result?: unknown;\n  /** Present iff status === 'failed'. */\n  readonly error?: Error;\n}\n\n/**\n * Result delivered when the handle's `wait()` Promise resolves\n * successfully (status reached 'done'). Rejection delivers the\n * native `Error` directly — no wrapping shape.\n */\nexport interface DetachWaitResult {\n  readonly result: unknown;\n}\n\n/**\n * Handle returned by `chart.detachAndJoinLater(...)` and\n * `executor.detachAndJoinLater(...)`. Exposes status as PROPERTIES so\n * sync access is property-read (cheap, no allocation). The single\n * method `wait()` returns a Promise for opt-in async join.\n *\n * The handle is **not** Promise-shaped (no `.then()`) — that would\n * make it accidentally awaitable, defeating the fire-and-forget\n * semantics. To await, the consumer must call `.wait()` explicitly.\n *\n * Lifecycle:\n *\n *   queued  → driver received the work, hasn't started it\n *   running → driver started the work\n *   done    → terminal: result available\n *   failed  → terminal: error available\n *\n * `done` and `failed` are TERMINAL — once reached, status never\n * changes again.\n */\nexport interface DetachHandle {\n  /** Stable id assigned at detach time. Used as the lookup key in\n   *  `detachRegistry` and as the scope-storage key prefix. */\n  readonly id: string;\n\n  /** Current state. Read directly for sync access. */\n  readonly status: 'queued' | 'running' | 'done' | 'failed';\n\n  /** The work's result. Present iff `status === 'done'`. Reading\n   *  before terminal returns `undefined`. */\n  readonly result?: unknown;\n\n  /** The work's error. Present iff `status === 'failed'`. Reading\n   *  before terminal returns `undefined`. */\n  readonly error?: Error;\n\n  /**\n   * Opt-in async join. Returns a Promise that:\n   *   - resolves with `{ result }` when status becomes 'done'\n   *   - rejects with the captured `Error` when status becomes 'failed'\n   *   - resolves/rejects IMMEDIATELY if status is already terminal\n   *   - returns the SAME cached Promise on repeated calls (no\n   *     re-running, no duplicated I/O)\n   *\n   * Calling `wait()` does NOT change the handle's lifecycle — it's\n   * passive observation. If never called, the work still completes;\n   * the handle just goes uncollected (parent execution unaffected).\n   *\n   * Use when:\n   *   - You actually need the result and want to await it\n   *   - Coordinating multiple handles via Promise.all / Promise.race\n   *   - Backpressure (\"don't fire more than N in flight\")\n   *\n   * Don't use when:\n   *   - Pure fire-and-forget (use `detachAndForget` — no handle returned)\n   *   - You just want to check status (read `handle.status` directly)\n   */\n  wait(): Promise<DetachWaitResult>;\n}\n\n// ─── DetachDriver — the algorithm interface ──────────────────────────\n\n/**\n * Capabilities a driver declares. Drives the runtime decision of\n * \"is this driver appropriate for the current environment?\" Consumers\n * inspect at construction; the framework doesn't enforce.\n *\n * All capabilities are optional flags — false / undefined means \"not\n * supported / no claim.\" A driver that supports everything sets all\n * to true.\n */\nexport interface DriverCapabilities {\n  /** Driver works in browser environments (window, document, etc.). */\n  readonly browserSafe?: boolean;\n  /** Driver works in Node.js environments. */\n  readonly nodeSafe?: boolean;\n  /** Driver works in edge runtimes (Cloudflare Workers, Deno Deploy,\n   *  Bun edge, etc. — restricted environments). */\n  readonly edgeSafe?: boolean;\n  /** Work survives page-unload / process-exit. e.g.,\n   *  `sendBeaconDriver` schedules via `navigator.sendBeacon` which\n   *  ships even on tab close. */\n  readonly survivesUnload?: boolean;\n  /** Work runs on a separate OS thread (no event-loop block).\n   *  e.g., `workerThreadDriver`. */\n  readonly cpuIsolated?: boolean;\n}\n\n/**\n * A driver is the WHEN/HOW of the detach. Maps `(child, input, refId)`\n * to a `DetachHandle` whose lifecycle the driver owns.\n *\n * Drivers are themselves footprintjs primitives — internally they may\n * be a single function or a multi-stage flowChart. Either way, the\n * interface they expose to consumers is `schedule(...)`.\n *\n * Drivers MUST:\n *   - Return synchronously (the agent loop never blocks on schedule)\n *   - Not throw — errors during scheduling route through the handle\n *     (`handle.status = 'failed'`, `handle.error = ...`)\n *   - Honor the passive-recorder rule: the parent's `detach*` call\n *     never waits for the driver's deferred work to complete\n *\n * Drivers MAY:\n *   - Implement `validate()` for one-time configuration checks at\n *     registration / use time (e.g., assert `navigator.sendBeacon` exists)\n *   - Build their internal pipeline as a footprintjs flowChart for\n *     observability — driver implementation detail, not consumer-facing\n *\n * @example Built-in\n *   import { microtaskBatchDriver } from 'footprintjs/detach';\n *   const handle = driver.schedule(child, input, refId);\n *\n * @example Custom (BYOS)\n *   const lambdaExtensionDriver: DetachDriver = {\n *     name: 'lambda-extension',\n *     capabilities: { nodeSafe: true, survivesUnload: true },\n *     schedule(child, input, refId) {\n *       sharedBuffer.push({ refId, child, input });\n *       return createHandle(refId);\n *     },\n *   };\n */\nexport interface DetachDriver {\n  /** Stable name for diagnostics + registry lookup. Conventionally\n   *  algorithm-named (e.g. `'microtask-batch'`, `'send-beacon'`). */\n  readonly name: string;\n\n  /** What this driver supports. Used by consumers to pick the right\n   *  driver for their environment. */\n  readonly capabilities: DriverCapabilities;\n\n  /**\n   * Hand the work to the driver's scheduling mechanism. MUST return\n   * synchronously with a fresh `DetachHandle`. The actual work may\n   * run later (next microtask / setImmediate / browser-beacon-flush /\n   * worker-thread / etc.) on the driver's chosen mechanism.\n   */\n  schedule(child: FlowChart, input: unknown, refId: string): DetachHandle;\n\n  /**\n   * Optional one-time validation hook. Called at first use (or\n   * registration time, depending on driver) — drivers throw if their\n   * configuration is invalid (missing peer dep, unreachable endpoint,\n   * wrong API key shape, etc.).\n   *\n   * Example: `sendBeaconDriver.validate()` checks\n   * `typeof navigator?.sendBeacon === 'function'` and throws with a\n   * helpful message if absent (e.g., in Node).\n   *\n   * Per the New Relic panel review: early-fail-with-useful-message\n   * beats silent zero-emission.\n   */\n  validate?(): void;\n}\n"]}

package/dist/esm/lib/engine/narrative/recorders/SeparateNarrativeFlowRecorder.js

@@ -13,8 +13,8 @@
  * executor.attachFlowRecorder(recorder);
  * await executor.run();
  *
- * const mainNarrative = executor.getNarrative();     // No loop sentences
- * const loopDetail = recorder.getLoopSentences();    // All loop detail
+ * const mainEntries = executor.getNarrativeEntries(); // No loop sentences
+ * const loopDetail = recorder.getLoopSentences();     // All loop detail
  * ```
  */
 import { NarrativeFlowRecorder } from '../NarrativeFlowRecorder.js';
@@ -51,4 +51,4 @@ export class SeparateNarrativeFlowRecorder extends NarrativeFlowRecorder {
         this.loopCounts.clear();
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

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