footprintjs 9.17.0 → 9.18.1

package/CLAUDE.md

@@ -17,7 +17,7 @@ Entry points: `footprintjs` (public API) · `/recorders` (factories) · `/trace`
 | decide/ | decide()/select() evidence capture |
 | recorder/ | stores (KeyedStore/SequenceStore/BoundaryStateStore), CombinedRecorder routing, built-ins (Topology/InOut/ControlDep/Quality) |
 | slice/ | variable-first backward slicing (triage query layer): sliceForKey (anchor at last writer → causalChain) + arrayProvenance/elementProvenance (append-fold element births — the agent mega-key fix) + KeysReadSource strategies. Pure post-hoc queries; imports memory/ ONLY (see src/lib/slice/README.md) |
-| time-travel/ | the READER'S cursor over a finished trace (9.17.0): `timeTravel()` stops/moves/marks/`drill()`, `stateAt()` fold + honesty basis, `TimeTravelStrategy` seam (one shipped: `commitStops`). Read-time only — never a second live cursor. Imports memory/ + `engine/runtimeStageId` (see src/lib/time-travel/README.md) |
+| time-travel/ | the READER'S cursor over a finished trace (9.17.0): `timeTravel()` stops/moves/marks/`drill()`, `stateAt()` fold + honesty basis, `TimeTravelStrategy<TMeta>` seam (one shipped: `commitStops`). 9.18.0 composer's side: axis.ts (`splitAxis` = the ONE guard of the `[start,…stages,end]` contract; `filterStops` = filter + re-partition + `Stop.meta` vocabulary + `Stop.prologue` on an absorbing start — a FLAG, deliberately not a 5th StopKind), bundles.ts (per-bundle narrowing of `unknown[]` rows → index-holding GAPS in `FoldedState.skipped`), chain.ts (`timeTravel([paused, resumed])`: commit indices stay RUN-LOCAL + `Stop.sourceIdx`; refused unless execution indices are monotonic across legs and no id repeats). Read-time only — never a second live cursor. Imports memory/ + `engine/runtimeStageId` (see src/lib/time-travel/README.md) |
 | pause/ | PauseSignal / FlowchartCheckpoint types + `interrupt(scope, payload)` (throws InterruptSignal; converted to PauseSignal at the StageRunner boundary, `pausedBy:'interrupt'`) |
 | engine/ | FlowchartTraverser + handlers/; narrative/ = the whole FlowRecorder channel (dispatcher + 9 strategies), not just text; branchSegment.ts = the ONE owner of the generated-segment grammar (`<stageId>~<index>`, marker `~` RESERVED); `executeStage` (:720) = the ONE funnel every stage fn passes through — and therefore the ONE owner of the declarative `retry` loop |
 | runner/ | FlowChartExecutor wiring (runtime, recorders, pause/resume, snapshot, DeferredObserverTier). RunContext.ts is a fluent run builder, NOT the threaded per-run context |
@@ -66,7 +66,7 @@ loop: Phase 6 sees isLoopRef → ContinuationResolver.resolveTarget (:107): id-m
 end: onRunEnd (throw → onRunFailed; pause → neither) → deferred terminalFlush → getSnapshot() = {sharedState (LIVE view; dev-mode frozen clone), initialState (the fold base), commitLog (detached+frozen), executionTree, subflowResults (dual-keyed), recorders}.
 
 ## Backtracking
-Seven mechanisms, no state rollback anywhere: **M1** TransactionBuffer staging + net-change commit — commit-on-error by design, explicitly NOT rollback (TransactionBuffer.ts:13-18; error path commits then rethrows). **M2** Pause/Resume checkpointing — the only resume-from-prior-point; TWO raise shapes, ONE checkpoint: `addPausableFunction` (resume runs `resumeFn`) and `interrupt(scope, payload)` (resume RE-RUNS THE STAGE FUNCTION FROM ITS TOP — stages are atomic; the answer returns out of the `interrupt()` call via a WeakMap keyed by the scope), discriminated by `checkpoint.pausedBy`; checkpoint is one detached structuredClone; resume rebuilds the cursor from pausedStageId+subflowPath and only overrides the LEAF subflow root (2+-deep pause re-executes outer pre-mount stages). **M3** commit-log replay (EventLog.materialise, commitValueAt — required under delta mode). **M4** loopTo re-entry — forward execution over accumulated state, bounded by maxIterations + dynamicNextHops. **M5** causalChain backward slicing (read-only analysis; honesty flags for untracked reads; `edgeAttribution: 'per-write'` refines edges via `TraceEntry.readKeys` when the writeProvenance dial recorded them — worklist, subset-of-ceiling safe). **M6 (query layer)** slice/ — variable-first triage: sliceForKey + append-fold element provenance + the ONLY safe serializations (sliceToJSON/formatSlice — never JSON.stringify a slice root). **M7 (read-time cursor)** time-travel/ — `timeTravel(snapshot)` walks stops over the finished log with `stateAt()` folding M3's replay at each one (base = `RuntimeSnapshot.initialState`, which now travels with the log); it is a READER, never a second live cursor, and `drill(mount)` opens a separate cursor over a subflow's own isolated log. Deep dive + step tables: [.claude/rules/backtracking.md](.claude/rules/backtracking.md).
+Seven mechanisms, no state rollback anywhere: **M1** TransactionBuffer staging + net-change commit — commit-on-error by design, explicitly NOT rollback (TransactionBuffer.ts:13-18; error path commits then rethrows). **M2** Pause/Resume checkpointing — the only resume-from-prior-point; TWO raise shapes, ONE checkpoint: `addPausableFunction` (resume runs `resumeFn`) and `interrupt(scope, payload)` (resume RE-RUNS THE STAGE FUNCTION FROM ITS TOP — stages are atomic; the answer returns out of the `interrupt()` call via a WeakMap keyed by the scope), discriminated by `checkpoint.pausedBy`; checkpoint is one detached structuredClone; resume rebuilds the cursor from pausedStageId+subflowPath and only overrides the LEAF subflow root (2+-deep pause re-executes outer pre-mount stages). **M3** commit-log replay (EventLog.materialise, commitValueAt — required under delta mode). **M4** loopTo re-entry — forward execution over accumulated state, bounded by maxIterations + dynamicNextHops. **M5** causalChain backward slicing (read-only analysis; honesty flags for untracked reads; `edgeAttribution: 'per-write'` refines edges via `TraceEntry.readKeys` when the writeProvenance dial recorded them — worklist, subset-of-ceiling safe). **M6 (query layer)** slice/ — variable-first triage: sliceForKey + append-fold element provenance + the ONLY safe serializations (sliceToJSON/formatSlice — never JSON.stringify a slice root). **M7 (read-time cursor)** time-travel/ — `timeTravel(snapshot)` walks stops over the finished log with `stateAt()` folding M3's replay at each one (base = `RuntimeSnapshot.initialState`, which now travels with the log); it is a READER, never a second live cursor, and `drill(mount)` opens a separate cursor over a subflow's own isolated log. 9.18.0: `timeTravel([paused, resumed])` chains a cross-executor M2 resume into ONE axis — the resumed leg's `initialState` (= the state at the pause) restarts the fold, commit indices stay run-local (`Stop.sourceIdx` names the leg), and the chain is refused unless the never-reset execution counter is monotonic across legs. Deep dive + step tables: [.claude/rules/backtracking.md](.claude/rules/backtracking.md).
 
 ## Invariants (assumed, not stated)
 - Committed state immutable-after-swap; first-touch views hold bare references on that guarantee — in-place mutation of SharedMemory.context corrupts every in-flight stage.

package/dist/esm/lib/memory/utils.d.ts

@@ -79,11 +79,13 @@ export declare function normalisePath(path: (string | number)[]): string;
  *   - Primitive comparisons (the bulk of state) are O(1) via the `===` /
  *     `Object.is` fast paths; only nested objects/arrays incur a walk, bounded
  *     by the value's own size.
- *   - Assumes ACYCLIC, JSON-shaped values — the same contract the memory layer
- *     already relies on (committed state is `structuredClone`d and must be
- *     JSON-serialisable for checkpoints). A cyclic value is out of contract
- *     here exactly as it is for checkpointing; dev mode flags cycles at write
- *     time via `ScopeFacade.setValue`.
+ *   - Terminates on CYCLIC values (9.18.1): a state value must survive
+ *     `structuredClone`, and `structuredClone` preserves cycles — so a
+ *     self-referencing value is a legal value, not an out-of-contract one. A
+ *     pair of objects already under comparison is treated as equal (the
+ *     structural answer, lodash `isEqual` semantics); acyclic inputs see no
+ *     change. Dev mode still warns about cycles at write time
+ *     (`ScopeFacade.setValue`) because they surprise narrative and JSON.
  */
 export declare function deepEqual(a: any, b: any): boolean;
 /**
@@ -95,6 +97,14 @@ export declare function deepEqual(a: any, b: any): boolean;
  *   impossible to distinguish from a bug.
  * - Objects: recursive merge
  * - Primitives: source wins
+ *
+ * Terminates on a CYCLIC `src` (9.18.1, same law as {@link deepEqual}: a
+ * state value survives `structuredClone`, which preserves cycles). A `src`
+ * object re-entered while it is still being merged higher up the stack hands
+ * back the output being built for it, so the merged value mirrors the cycle
+ * instead of unrolling it forever. Only the ancestors on the stack are
+ * guarded — a shared (acyclic) `src` reference met again at a different
+ * `dst` merges against THAT `dst`, exactly as before.
  */
 export declare function deepSmartMerge(dst: any, src: any): any;
 /**

package/dist/esm/lib/memory/utils.js

@@ -145,13 +145,18 @@ export function normalisePath(path) {
  *   - Primitive comparisons (the bulk of state) are O(1) via the `===` /
  *     `Object.is` fast paths; only nested objects/arrays incur a walk, bounded
  *     by the value's own size.
- *   - Assumes ACYCLIC, JSON-shaped values — the same contract the memory layer
- *     already relies on (committed state is `structuredClone`d and must be
- *     JSON-serialisable for checkpoints). A cyclic value is out of contract
- *     here exactly as it is for checkpointing; dev mode flags cycles at write
- *     time via `ScopeFacade.setValue`.
+ *   - Terminates on CYCLIC values (9.18.1): a state value must survive
+ *     `structuredClone`, and `structuredClone` preserves cycles — so a
+ *     self-referencing value is a legal value, not an out-of-contract one. A
+ *     pair of objects already under comparison is treated as equal (the
+ *     structural answer, lodash `isEqual` semantics); acyclic inputs see no
+ *     change. Dev mode still warns about cycles at write time
+ *     (`ScopeFacade.setValue`) because they surprise narrative and JSON.
  */
 export function deepEqual(a, b) {
+    return equalPairs(a, b, undefined);
+}
+function equalPairs(a, b, seen) {
     if (a === b)
         return true; // same reference or identical primitive
     if (typeof a !== typeof b)
@@ -163,11 +168,19 @@ export function deepEqual(a, b) {
     const aIsArray = Array.isArray(a);
     if (aIsArray !== Array.isArray(b))
         return false; // array vs plain object
+    // Cycle guard — a pair we are already inside is equal by assumption.
+    seen ??= new WeakMap();
+    let partners = seen.get(a);
+    if (partners?.has(b))
+        return true;
+    if (!partners)
+        seen.set(a, (partners = new WeakSet()));
+    partners.add(b);
     if (aIsArray) {
         if (a.length !== b.length)
             return false;
         for (let i = 0; i < a.length; i++) {
-            if (!deepEqual(a[i], b[i]))
+            if (!equalPairs(a[i], b[i], seen))
                 return false;
         }
         return true;
@@ -179,7 +192,7 @@ export function deepEqual(a, b) {
     for (const key of aKeys) {
         if (!Object.prototype.hasOwnProperty.call(b, key))
             return false;
-        if (!deepEqual(a[key], b[key]))
+        if (!equalPairs(a[key], b[key], seen))
             return false;
     }
     return true;
@@ -193,8 +206,19 @@ export function deepEqual(a, b) {
  *   impossible to distinguish from a bug.
  * - Objects: recursive merge
  * - Primitives: source wins
+ *
+ * Terminates on a CYCLIC `src` (9.18.1, same law as {@link deepEqual}: a
+ * state value survives `structuredClone`, which preserves cycles). A `src`
+ * object re-entered while it is still being merged higher up the stack hands
+ * back the output being built for it, so the merged value mirrors the cycle
+ * instead of unrolling it forever. Only the ancestors on the stack are
+ * guarded — a shared (acyclic) `src` reference met again at a different
+ * `dst` merges against THAT `dst`, exactly as before.
  */
 export function deepSmartMerge(dst, src) {
+    return mergeGuarded(dst, src, undefined);
+}
+function mergeGuarded(dst, src, inFlight) {
     if (src === null || typeof src !== 'object')
         return src;
     if (Array.isArray(src)) {
@@ -204,11 +228,15 @@ export function deepSmartMerge(dst, src) {
             return [...new Set([...dst, ...src])];
         return [...src];
     }
+    if (inFlight?.has(src))
+        return inFlight.get(src); // cycle — re-enter the value being built
     const out = { ...(dst && typeof dst === 'object' ? dst : {}) };
+    (inFlight ??= new WeakMap()).set(src, out);
     // Object.keys() is own-enumerable-only by spec — no DENIED check needed here.
     for (const k of Object.keys(src)) {
-        out[k] = deepSmartMerge(out[k], src[k]);
+        out[k] = mergeGuarded(out[k], src[k], inFlight);
     }
+    inFlight.delete(src);
     return out;
 }
 /**
@@ -256,4 +284,4 @@ export function applySmartMerge(base, updates, overwrite, trace) {
     }
     return out;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../src/lib/memory/utils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * utils.ts — Helper functions for nested object manipulation\n *\n * Provides consistent path traversal and value manipulation for the memory system.\n * Zero external dependencies.\n */\n\nimport { nativeDelete, nativeGet as _get, nativeHas as _has, nativeSet as _set } from './pathOps.js';\nimport type { MemoryPatch, TraceEntry } from './types.js';\n\n/** ASCII Unit-Separator — cannot appear in JS identifiers, invisible in logs. */\nexport const DELIM = '\\u001F';\n\ntype NestedObject = { [key: string]: any };\n\n/**\n * Resolves run-namespaced and global paths.\n * Each flowchart execution (run) stores data under `runs/{id}/` to prevent collisions.\n */\nexport function getRunAndGlobalPaths(runId?: string, path: (string | number)[] = []) {\n  return {\n    runPath: runId ? ['runs', runId, ...path] : undefined,\n    globalPath: [...path],\n  };\n}\n\n/**\n * Sets a value at a nested path, creating intermediate objects as needed.\n */\nexport function setNestedValue<T>(\n  obj: NestedObject,\n  runId: string,\n  _path: string[],\n  field: string,\n  value: T,\n  defaultValues?: unknown,\n): NestedObject {\n  const { runPath, globalPath } = getRunAndGlobalPaths(runId, _path);\n  const path = runPath || globalPath;\n  const pathCopy = [...path];\n  let current: NestedObject = obj;\n  while (pathCopy.length > 0) {\n    const key = pathCopy.shift() as string;\n    if (!Object.prototype.hasOwnProperty.call(current, key)) {\n      current[key] = key === runId && defaultValues ? defaultValues : {};\n    }\n    current = current[key];\n  }\n  current[field] = value;\n  return obj;\n}\n\n/**\n * Deep-merges a value into the object at the specified path.\n * - Arrays: concatenate\n * - Objects: shallow merge at each level\n * - Primitives: replace\n */\nexport function updateNestedValue<T>(\n  obj: any,\n  runId: string | undefined,\n  _path: (string | number)[],\n  field: string | number,\n  value: T,\n  defaultValues?: unknown,\n): any {\n  const { runPath, globalPath } = getRunAndGlobalPaths(runId, _path);\n  const path = runPath || globalPath;\n  const pathCopy = [...path];\n  let current: NestedObject = obj;\n  while (pathCopy.length > 0) {\n    const key = pathCopy.shift() as string;\n    if (!Object.prototype.hasOwnProperty.call(current, key)) {\n      current[key] = key === runId && defaultValues ? defaultValues : {};\n    }\n    current = current[key];\n  }\n  updateValue(current, field, value);\n  return obj;\n}\n\n/**\n * In-place value update with merge semantics.\n * - Arrays (non-empty): concatenate onto existing\n * - Arrays (empty):     direct replace — writing `[]` clears the field\n * - Objects (non-empty): shallow merge (spread)\n * - Objects (empty):    direct replace — writing `{}` clears the field\n * - Primitives: direct assignment\n *\n * Note on empty arrays: both `value && Array.isArray(value)` and\n * `Array.isArray(value)` evaluate the same for arrays — `[]` is truthy in\n * JavaScript, so the `&&` guard was never the issue. The actual bug was the\n * concat path: `[...cur, ...[]]` silently returned `cur` unchanged when `value`\n * was `[]`, making `updateValue(obj, 'tags', [])` a no-op instead of a clear.\n * The fix is the explicit `value.length === 0` early-return branch.\n */\nexport function updateValue(object: any, key: string | number, value: any): void {\n  if (Array.isArray(value)) {\n    if (value.length === 0) {\n      object[key] = value; // clear: [] replaces whatever was there\n    } else {\n      const cur = object[key] as any;\n      object[key] = cur === undefined ? value : [...cur, ...value];\n    }\n  } else if (value && typeof value === 'object' && Object.keys(value).length) {\n    const cur = object[key] as any;\n    object[key] = cur === undefined ? value : { ...cur, ...value };\n  } else {\n    object[key] = value;\n  }\n}\n\n/**\n * Gets a value at a nested path with prototype-pollution protection.\n */\nexport function getNestedValue(root: any, path: (string | number)[], field?: string | number): any {\n  const node = path && path.length > 0 ? _get(root, path) : root;\n  if (field === undefined || node === undefined) return node;\n  if (node !== null && typeof node === 'object' && Object.prototype.hasOwnProperty.call(node, field)) {\n    return node[field];\n  }\n  return undefined;\n}\n\n/**\n * Redacts sensitive values in a patch for logging/debugging.\n */\nexport function redactPatch(patch: MemoryPatch, redactedSet: Set<string>): MemoryPatch {\n  const out = structuredClone(patch);\n  for (const flat of redactedSet) {\n    const pathArr = flat.split(DELIM);\n    if (_has(out, pathArr)) {\n      const curr = _get(out, pathArr);\n      if (typeof curr !== 'undefined') {\n        _set(out, pathArr, 'REDACTED');\n      }\n    }\n  }\n  return out;\n}\n\n/**\n * Normalises an array path into a stable string key using DELIM.\n */\nexport function normalisePath(path: (string | number)[]): string {\n  return path.map(String).join(DELIM);\n}\n\n/**\n * Structural deep equality for committed-state values.\n *\n * Used by {@link TransactionBuffer} to decide whether a stage actually CHANGED\n * a path or merely re-wrote / reverted it to the value it already held (a\n * \"no-op write\"). Committed state is JSON-shaped — it must survive\n * `structuredClone` — so this only needs to handle the shapes that can reach a\n * commit: primitives, arrays, and plain objects.\n *\n * Semantics:\n *   - reference / identical-primitive short-circuits first (cheap fast path)\n *   - `NaN` equals `NaN` (primitive compare falls back to `Object.is`)\n *   - arrays: equal length AND deep-equal element-wise (order-sensitive)\n *   - objects: identical own-key set AND deep-equal per key\n *   - mismatched kinds (array vs object, object vs null) → not equal\n *\n * Cost & safety:\n *   - Allocates NOTHING but transient `Object.keys` arrays — no clones. It is\n *     strictly cheaper than the `structuredClone` the commit already performs.\n *   - Primitive comparisons (the bulk of state) are O(1) via the `===` /\n *     `Object.is` fast paths; only nested objects/arrays incur a walk, bounded\n *     by the value's own size.\n *   - Assumes ACYCLIC, JSON-shaped values — the same contract the memory layer\n *     already relies on (committed state is `structuredClone`d and must be\n *     JSON-serialisable for checkpoints). A cyclic value is out of contract\n *     here exactly as it is for checkpointing; dev mode flags cycles at write\n *     time via `ScopeFacade.setValue`.\n */\nexport function deepEqual(a: any, b: any): boolean {\n  if (a === b) return true; // same reference or identical primitive\n  if (typeof a !== typeof b) return false;\n  if (a === null || b === null) return a === b; // one is null, the other isn't\n  if (typeof a !== 'object') return Object.is(a, b); // NaN-safe primitive compare\n\n  const aIsArray = Array.isArray(a);\n  if (aIsArray !== Array.isArray(b)) return false; // array vs plain object\n\n  if (aIsArray) {\n    if (a.length !== b.length) return false;\n    for (let i = 0; i < a.length; i++) {\n      if (!deepEqual(a[i], b[i])) return false;\n    }\n    return true;\n  }\n\n  const aKeys = Object.keys(a);\n  const bKeys = Object.keys(b);\n  if (aKeys.length !== bKeys.length) return false;\n  for (const key of aKeys) {\n    if (!Object.prototype.hasOwnProperty.call(b, key)) return false;\n    if (!deepEqual(a[key], b[key])) return false;\n  }\n  return true;\n}\n\n/**\n * Deep union merge helper.\n * - Arrays (non-empty): union without duplicates (encounter order preserved)\n * - Arrays (empty):     replace — src `[]` clears the destination array.\n *   Rationale: writing `scope.tags = []` means \"clear tags\", not \"append nothing\".\n *   Without this rule, an empty-array write silently becomes a no-op which is\n *   impossible to distinguish from a bug.\n * - Objects: recursive merge\n * - Primitives: source wins\n */\nexport function deepSmartMerge(dst: any, src: any): any {\n  if (src === null || typeof src !== 'object') return src;\n\n  if (Array.isArray(src)) {\n    if (src.length === 0) return []; // empty src = clear, not no-op\n    if (Array.isArray(dst)) return [...new Set([...dst, ...src])];\n    return [...src];\n  }\n\n  const out: any = { ...(dst && typeof dst === 'object' ? dst : {}) };\n  // Object.keys() is own-enumerable-only by spec — no DENIED check needed here.\n  for (const k of Object.keys(src)) {\n    out[k] = deepSmartMerge(out[k], src[k]);\n  }\n  return out;\n}\n\n/**\n * Applies a commit bundle to a base state by replaying operations in order.\n * Guarantees \"last writer wins\" semantics.\n *\n * The single replay primitive — three consumers inherit every verb from it:\n * live state (`SharedMemory.applyPatch`), time travel\n * (`EventLog.materialise`), and the redacted mirror\n * (`StageContext.commit`'s second `applyPatch`).\n *\n * Verb arms:\n *   - `'set'`    — overwrite with `overwrite[path]` (the full final value).\n *   - `'merge'`  — `deepSmartMerge` the accumulated `updates[path]` delta in.\n *   - `'append'` — (#13c-B delta mode) `overwrite[path]` holds ONLY the tail;\n *     reconstruct by concatenating it onto the current array. When the\n *     current value or the recorded tail is not an array (out-of-order\n *     replay base, or a REDACTED tail — `redactPatch` replaces matched\n *     payloads with the `'REDACTED'` string), degrade to a direct set of the\n *     recorded value — the same terminal value a redacted/corrupt `'set'`\n *     produces.\n *   - `'delete'` — (#13c-B delta mode) remove the key (`nativeDelete`,\n *     prototype-pollution-safe). The path stays enumerated in `overwrite`\n *     (value `undefined`) for key-set consumers; replay ignores that value.\n */\nexport function applySmartMerge(base: any, updates: MemoryPatch, overwrite: MemoryPatch, trace: TraceEntry[]): any {\n  const out = structuredClone(base);\n  for (const { path, verb } of trace) {\n    const segs = path.split(DELIM);\n    if (verb === 'set') {\n      _set(out, segs, structuredClone(_get(overwrite, segs)));\n    } else if (verb === 'append') {\n      const tail = structuredClone(_get(overwrite, segs));\n      const current = _get(out, segs);\n      _set(out, segs, Array.isArray(current) && Array.isArray(tail) ? [...current, ...tail] : tail);\n    } else if (verb === 'delete') {\n      nativeDelete(out, segs);\n    } else {\n      const current = _get(out, segs) ?? {};\n      _set(out, segs, deepSmartMerge(current, _get(updates, segs)));\n    }\n  }\n  return out;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../src/lib/memory/utils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * utils.ts — Helper functions for nested object manipulation\n *\n * Provides consistent path traversal and value manipulation for the memory system.\n * Zero external dependencies.\n */\n\nimport { nativeDelete, nativeGet as _get, nativeHas as _has, nativeSet as _set } from './pathOps.js';\nimport type { MemoryPatch, TraceEntry } from './types.js';\n\n/** ASCII Unit-Separator — cannot appear in JS identifiers, invisible in logs. */\nexport const DELIM = '\\u001F';\n\ntype NestedObject = { [key: string]: any };\n\n/**\n * Resolves run-namespaced and global paths.\n * Each flowchart execution (run) stores data under `runs/{id}/` to prevent collisions.\n */\nexport function getRunAndGlobalPaths(runId?: string, path: (string | number)[] = []) {\n  return {\n    runPath: runId ? ['runs', runId, ...path] : undefined,\n    globalPath: [...path],\n  };\n}\n\n/**\n * Sets a value at a nested path, creating intermediate objects as needed.\n */\nexport function setNestedValue<T>(\n  obj: NestedObject,\n  runId: string,\n  _path: string[],\n  field: string,\n  value: T,\n  defaultValues?: unknown,\n): NestedObject {\n  const { runPath, globalPath } = getRunAndGlobalPaths(runId, _path);\n  const path = runPath || globalPath;\n  const pathCopy = [...path];\n  let current: NestedObject = obj;\n  while (pathCopy.length > 0) {\n    const key = pathCopy.shift() as string;\n    if (!Object.prototype.hasOwnProperty.call(current, key)) {\n      current[key] = key === runId && defaultValues ? defaultValues : {};\n    }\n    current = current[key];\n  }\n  current[field] = value;\n  return obj;\n}\n\n/**\n * Deep-merges a value into the object at the specified path.\n * - Arrays: concatenate\n * - Objects: shallow merge at each level\n * - Primitives: replace\n */\nexport function updateNestedValue<T>(\n  obj: any,\n  runId: string | undefined,\n  _path: (string | number)[],\n  field: string | number,\n  value: T,\n  defaultValues?: unknown,\n): any {\n  const { runPath, globalPath } = getRunAndGlobalPaths(runId, _path);\n  const path = runPath || globalPath;\n  const pathCopy = [...path];\n  let current: NestedObject = obj;\n  while (pathCopy.length > 0) {\n    const key = pathCopy.shift() as string;\n    if (!Object.prototype.hasOwnProperty.call(current, key)) {\n      current[key] = key === runId && defaultValues ? defaultValues : {};\n    }\n    current = current[key];\n  }\n  updateValue(current, field, value);\n  return obj;\n}\n\n/**\n * In-place value update with merge semantics.\n * - Arrays (non-empty): concatenate onto existing\n * - Arrays (empty):     direct replace — writing `[]` clears the field\n * - Objects (non-empty): shallow merge (spread)\n * - Objects (empty):    direct replace — writing `{}` clears the field\n * - Primitives: direct assignment\n *\n * Note on empty arrays: both `value && Array.isArray(value)` and\n * `Array.isArray(value)` evaluate the same for arrays — `[]` is truthy in\n * JavaScript, so the `&&` guard was never the issue. The actual bug was the\n * concat path: `[...cur, ...[]]` silently returned `cur` unchanged when `value`\n * was `[]`, making `updateValue(obj, 'tags', [])` a no-op instead of a clear.\n * The fix is the explicit `value.length === 0` early-return branch.\n */\nexport function updateValue(object: any, key: string | number, value: any): void {\n  if (Array.isArray(value)) {\n    if (value.length === 0) {\n      object[key] = value; // clear: [] replaces whatever was there\n    } else {\n      const cur = object[key] as any;\n      object[key] = cur === undefined ? value : [...cur, ...value];\n    }\n  } else if (value && typeof value === 'object' && Object.keys(value).length) {\n    const cur = object[key] as any;\n    object[key] = cur === undefined ? value : { ...cur, ...value };\n  } else {\n    object[key] = value;\n  }\n}\n\n/**\n * Gets a value at a nested path with prototype-pollution protection.\n */\nexport function getNestedValue(root: any, path: (string | number)[], field?: string | number): any {\n  const node = path && path.length > 0 ? _get(root, path) : root;\n  if (field === undefined || node === undefined) return node;\n  if (node !== null && typeof node === 'object' && Object.prototype.hasOwnProperty.call(node, field)) {\n    return node[field];\n  }\n  return undefined;\n}\n\n/**\n * Redacts sensitive values in a patch for logging/debugging.\n */\nexport function redactPatch(patch: MemoryPatch, redactedSet: Set<string>): MemoryPatch {\n  const out = structuredClone(patch);\n  for (const flat of redactedSet) {\n    const pathArr = flat.split(DELIM);\n    if (_has(out, pathArr)) {\n      const curr = _get(out, pathArr);\n      if (typeof curr !== 'undefined') {\n        _set(out, pathArr, 'REDACTED');\n      }\n    }\n  }\n  return out;\n}\n\n/**\n * Normalises an array path into a stable string key using DELIM.\n */\nexport function normalisePath(path: (string | number)[]): string {\n  return path.map(String).join(DELIM);\n}\n\n/**\n * Structural deep equality for committed-state values.\n *\n * Used by {@link TransactionBuffer} to decide whether a stage actually CHANGED\n * a path or merely re-wrote / reverted it to the value it already held (a\n * \"no-op write\"). Committed state is JSON-shaped — it must survive\n * `structuredClone` — so this only needs to handle the shapes that can reach a\n * commit: primitives, arrays, and plain objects.\n *\n * Semantics:\n *   - reference / identical-primitive short-circuits first (cheap fast path)\n *   - `NaN` equals `NaN` (primitive compare falls back to `Object.is`)\n *   - arrays: equal length AND deep-equal element-wise (order-sensitive)\n *   - objects: identical own-key set AND deep-equal per key\n *   - mismatched kinds (array vs object, object vs null) → not equal\n *\n * Cost & safety:\n *   - Allocates NOTHING but transient `Object.keys` arrays — no clones. It is\n *     strictly cheaper than the `structuredClone` the commit already performs.\n *   - Primitive comparisons (the bulk of state) are O(1) via the `===` /\n *     `Object.is` fast paths; only nested objects/arrays incur a walk, bounded\n *     by the value's own size.\n *   - Terminates on CYCLIC values (9.18.1): a state value must survive\n *     `structuredClone`, and `structuredClone` preserves cycles — so a\n *     self-referencing value is a legal value, not an out-of-contract one. A\n *     pair of objects already under comparison is treated as equal (the\n *     structural answer, lodash `isEqual` semantics); acyclic inputs see no\n *     change. Dev mode still warns about cycles at write time\n *     (`ScopeFacade.setValue`) because they surprise narrative and JSON.\n */\nexport function deepEqual(a: any, b: any): boolean {\n  return equalPairs(a, b, undefined);\n}\n\n/**\n * Object pairs met so far, keyed `a → the b's it has been paired with`. Created\n * lazily by the first object pair, so primitive compares allocate nothing.\n * Never pruned: every `false` returns straight up to the caller (each recursive\n * call short-circuits on it), so nothing is looked up after a mismatch — a\n * stored pair is either still under comparison or already known equal.\n */\ntype SeenPairs = WeakMap<object, WeakSet<object>>;\n\nfunction equalPairs(a: any, b: any, seen: SeenPairs | undefined): boolean {\n  if (a === b) return true; // same reference or identical primitive\n  if (typeof a !== typeof b) return false;\n  if (a === null || b === null) return a === b; // one is null, the other isn't\n  if (typeof a !== 'object') return Object.is(a, b); // NaN-safe primitive compare\n\n  const aIsArray = Array.isArray(a);\n  if (aIsArray !== Array.isArray(b)) return false; // array vs plain object\n\n  // Cycle guard — a pair we are already inside is equal by assumption.\n  seen ??= new WeakMap();\n  let partners = seen.get(a);\n  if (partners?.has(b)) return true;\n  if (!partners) seen.set(a, (partners = new WeakSet()));\n  partners.add(b);\n\n  if (aIsArray) {\n    if (a.length !== b.length) return false;\n    for (let i = 0; i < a.length; i++) {\n      if (!equalPairs(a[i], b[i], seen)) return false;\n    }\n    return true;\n  }\n\n  const aKeys = Object.keys(a);\n  const bKeys = Object.keys(b);\n  if (aKeys.length !== bKeys.length) return false;\n  for (const key of aKeys) {\n    if (!Object.prototype.hasOwnProperty.call(b, key)) return false;\n    if (!equalPairs(a[key], b[key], seen)) return false;\n  }\n  return true;\n}\n\n/**\n * Deep union merge helper.\n * - Arrays (non-empty): union without duplicates (encounter order preserved)\n * - Arrays (empty):     replace — src `[]` clears the destination array.\n *   Rationale: writing `scope.tags = []` means \"clear tags\", not \"append nothing\".\n *   Without this rule, an empty-array write silently becomes a no-op which is\n *   impossible to distinguish from a bug.\n * - Objects: recursive merge\n * - Primitives: source wins\n *\n * Terminates on a CYCLIC `src` (9.18.1, same law as {@link deepEqual}: a\n * state value survives `structuredClone`, which preserves cycles). A `src`\n * object re-entered while it is still being merged higher up the stack hands\n * back the output being built for it, so the merged value mirrors the cycle\n * instead of unrolling it forever. Only the ancestors on the stack are\n * guarded — a shared (acyclic) `src` reference met again at a different\n * `dst` merges against THAT `dst`, exactly as before.\n */\nexport function deepSmartMerge(dst: any, src: any): any {\n  return mergeGuarded(dst, src, undefined);\n}\n\nfunction mergeGuarded(dst: any, src: any, inFlight: WeakMap<object, any> | undefined): any {\n  if (src === null || typeof src !== 'object') return src;\n\n  if (Array.isArray(src)) {\n    if (src.length === 0) return []; // empty src = clear, not no-op\n    if (Array.isArray(dst)) return [...new Set([...dst, ...src])];\n    return [...src];\n  }\n\n  if (inFlight?.has(src)) return inFlight.get(src); // cycle — re-enter the value being built\n\n  const out: any = { ...(dst && typeof dst === 'object' ? dst : {}) };\n  (inFlight ??= new WeakMap()).set(src, out);\n  // Object.keys() is own-enumerable-only by spec — no DENIED check needed here.\n  for (const k of Object.keys(src)) {\n    out[k] = mergeGuarded(out[k], src[k], inFlight);\n  }\n  inFlight.delete(src);\n  return out;\n}\n\n/**\n * Applies a commit bundle to a base state by replaying operations in order.\n * Guarantees \"last writer wins\" semantics.\n *\n * The single replay primitive — three consumers inherit every verb from it:\n * live state (`SharedMemory.applyPatch`), time travel\n * (`EventLog.materialise`), and the redacted mirror\n * (`StageContext.commit`'s second `applyPatch`).\n *\n * Verb arms:\n *   - `'set'`    — overwrite with `overwrite[path]` (the full final value).\n *   - `'merge'`  — `deepSmartMerge` the accumulated `updates[path]` delta in.\n *   - `'append'` — (#13c-B delta mode) `overwrite[path]` holds ONLY the tail;\n *     reconstruct by concatenating it onto the current array. When the\n *     current value or the recorded tail is not an array (out-of-order\n *     replay base, or a REDACTED tail — `redactPatch` replaces matched\n *     payloads with the `'REDACTED'` string), degrade to a direct set of the\n *     recorded value — the same terminal value a redacted/corrupt `'set'`\n *     produces.\n *   - `'delete'` — (#13c-B delta mode) remove the key (`nativeDelete`,\n *     prototype-pollution-safe). The path stays enumerated in `overwrite`\n *     (value `undefined`) for key-set consumers; replay ignores that value.\n */\nexport function applySmartMerge(base: any, updates: MemoryPatch, overwrite: MemoryPatch, trace: TraceEntry[]): any {\n  const out = structuredClone(base);\n  for (const { path, verb } of trace) {\n    const segs = path.split(DELIM);\n    if (verb === 'set') {\n      _set(out, segs, structuredClone(_get(overwrite, segs)));\n    } else if (verb === 'append') {\n      const tail = structuredClone(_get(overwrite, segs));\n      const current = _get(out, segs);\n      _set(out, segs, Array.isArray(current) && Array.isArray(tail) ? [...current, ...tail] : tail);\n    } else if (verb === 'delete') {\n      nativeDelete(out, segs);\n    } else {\n      const current = _get(out, segs) ?? {};\n      _set(out, segs, deepSmartMerge(current, _get(updates, segs)));\n    }\n  }\n  return out;\n}\n"]}

package/dist/esm/lib/time-travel/axis.d.ts

@@ -0,0 +1,119 @@
+/**
+ * axis.ts — the shape of an axis, and the one safe way to narrow it.
+ *
+ * WHY THIS FILE EXISTS. `commitStops` returns `Stop[]`, and every strategy
+ * that COMPOSES it (keep the stages my domain recognises, drop the rest) rests
+ * on a shape the type never stated: `[start, …stages, end]` for a non-empty
+ * log, empty for an empty one. Each composer therefore wrote its own runtime
+ * guard against its own reading of the contract, plus a mocked-substrate test
+ * to prove the guard fires. That is one invariant, discovered three times, and
+ * the library that owns the invariant should be the one that states it.
+ *
+ * {@link splitAxis} states it. {@link filterStops} then does the whole
+ * composition — check the shape, keep what the caller keeps, RE-PARTITION the
+ * log so the dropped stages' commits are still folded somewhere, and mark the
+ * `'start'` bookend as carrying a prologue — because getting the
+ * re-partitioning right by hand is the other thing every composer had to
+ * rediscover.
+ */
+import type { AxisSplit, Stop } from './types.js';
+/**
+ * Split a strategy's stops into `{ start, stages, end }`, or say why it cannot.
+ *
+ * THE INVARIANT, stated once: for a non-EMPTY log, `commitStops` returns at
+ * least the two bookends, `'start'` first and `'end'` last, with one stop per
+ * executed stage in execution order between them. For an EMPTY log it returns
+ * `[]` — no bookends around nothing, because a cursor with nowhere to stand
+ * should say `reason: 'empty'` rather than offer two positions that are the
+ * same position.
+ *
+ * The two refusals are different facts and must not be collapsed: `'empty'`
+ * means the run committed nothing, `'not-bookended'` means a strategy broke
+ * the contract. A composer that treats them alike reports a broken strategy as
+ * an empty run.
+ *
+ * @example
+ * ```typescript
+ * import { commitStops, splitAxis } from 'footprintjs/trace';
+ *
+ * const axis = splitAxis(commitStops(snapshot.commitLog, snapshot.executionTree));
+ * if (axis.ok) {
+ *   axis.start.commitIdx;          // -1 — the fold base
+ *   axis.stages.map((s) => s.label);
+ *   axis.end.lastCommitIdx;        // the last bundle in the log
+ * } else {
+ *   axis.reason;                   // 'empty' | 'not-bookended'
+ * }
+ * ```
+ */
+export declare function splitAxis<TMeta = unknown>(stops: readonly Stop<TMeta>[]): AxisSplit<TMeta>;
+/**
+ * What {@link filterStops} does with one stop: drop it, keep it, or keep it
+ * carrying the strategy's own label and vocabulary.
+ *
+ * `false` / `null` / `undefined` drop. `true` keeps it unchanged. An object
+ * keeps it and overrides `label` and/or sets `meta` — the strategy's own
+ * classification, travelling ON the stop instead of being re-derived from
+ * `runtimeStageId` at every read.
+ */
+export type StopFilter<TMeta> = boolean | null | undefined | {
+    readonly label?: string;
+    readonly meta?: TMeta;
+};
+/**
+ * Build a FILTERING strategy's axis out of another strategy's stops.
+ *
+ * The rule, in one sentence: keep the stages `keep` recognises, and give the
+ * survivors the log back.
+ *
+ * **Meta is the decision's, never inherited.** The input may already be a
+ * filtered axis carrying another strategy's `meta`; a `true` (or a meta-less
+ * object) keeps the stop and DROPS that meta, so a `Stop<TMeta>` never carries
+ * a value of some other type under `TMeta`. The bookends carry none either.
+ *
+ * **The survivors re-partition the log.** A dropped stage's commits still
+ * happened, so they fold into the stop that PRECEDES them: every kept stop's
+ * `lastCommitIdx` runs to just before the next kept stop begins. Nothing is
+ * orphaned and `stateAt(stop)` stays "the state that existed when the next
+ * kept stage started".
+ *
+ * **What that costs `'start'`, said out loud.** The commits before the first
+ * survivor have nowhere else to go, so `'start'` absorbs them: its fold is the
+ * run's base PLUS that prologue — the state the first stop READ, not the raw
+ * base. The returned start therefore carries `prologue: true` whenever it
+ * actually absorbed a stage, and a renderer that means "before anything ran"
+ * checks `kind === 'start' && !prologue`. That flag is the whole reason this
+ * helper exists rather than a `.filter()` call.
+ *
+ * **A log with nothing kept** yields the two bookends and nothing between
+ * them: `'start'` folds the whole log, `'end'` folds the whole log, and
+ * `jumpTo` on any stage id refuses with `reason: 'miss'`. An axis with nowhere
+ * meaningful to stand — which is the truthful shape for a run this strategy
+ * recognises nothing in, and NOT the `[]` that says the log was empty.
+ *
+ * @throws when `stops` is non-empty but not bookended — see {@link splitAxis}.
+ *   Only a strategy can cause that; a run cannot, so it is a contract error
+ *   and not a condition to fold into the data.
+ *
+ * @example
+ * ```typescript
+ * import { commitStops, filterStops } from 'footprintjs/trace';
+ * import type { Stop, TimeTravelStrategy } from 'footprintjs/trace';
+ *
+ * type Milestone = { kind: 'llm-turn' | 'tool-call'; label: string };
+ * declare function milestoneFor(runtimeStageId: string): Milestone | null;
+ *
+ * const milestoneStops: TimeTravelStrategy<Milestone> = {
+ *   stopsFor: (log, tree) =>
+ *     filterStops<Milestone>(commitStops(log, tree), (stop) => {
+ *       const m = milestoneFor(stop.runtimeStageId);
+ *       return m ? { label: m.label, meta: m } : null;
+ *     }),
+ * };
+ *
+ * const cursor = timeTravel(snapshot, { strategy: milestoneStops });
+ * cursor.at()?.meta?.kind;        // 'llm-turn' — no re-derivation
+ * cursor.stops[0].prologue;       // true when stages ran before the first turn
+ * ```
+ */
+export declare function filterStops<TMeta = unknown>(stops: readonly Stop<unknown>[], keep: (stop: Stop<unknown>) => StopFilter<TMeta>): Stop<TMeta>[];

package/dist/esm/lib/time-travel/axis.js

@@ -0,0 +1,179 @@
+/**
+ * axis.ts — the shape of an axis, and the one safe way to narrow it.
+ *
+ * WHY THIS FILE EXISTS. `commitStops` returns `Stop[]`, and every strategy
+ * that COMPOSES it (keep the stages my domain recognises, drop the rest) rests
+ * on a shape the type never stated: `[start, …stages, end]` for a non-empty
+ * log, empty for an empty one. Each composer therefore wrote its own runtime
+ * guard against its own reading of the contract, plus a mocked-substrate test
+ * to prove the guard fires. That is one invariant, discovered three times, and
+ * the library that owns the invariant should be the one that states it.
+ *
+ * {@link splitAxis} states it. {@link filterStops} then does the whole
+ * composition — check the shape, keep what the caller keeps, RE-PARTITION the
+ * log so the dropped stages' commits are still folded somewhere, and mark the
+ * `'start'` bookend as carrying a prologue — because getting the
+ * re-partitioning right by hand is the other thing every composer had to
+ * rediscover.
+ */
+/**
+ * Split a strategy's stops into `{ start, stages, end }`, or say why it cannot.
+ *
+ * THE INVARIANT, stated once: for a non-EMPTY log, `commitStops` returns at
+ * least the two bookends, `'start'` first and `'end'` last, with one stop per
+ * executed stage in execution order between them. For an EMPTY log it returns
+ * `[]` — no bookends around nothing, because a cursor with nowhere to stand
+ * should say `reason: 'empty'` rather than offer two positions that are the
+ * same position.
+ *
+ * The two refusals are different facts and must not be collapsed: `'empty'`
+ * means the run committed nothing, `'not-bookended'` means a strategy broke
+ * the contract. A composer that treats them alike reports a broken strategy as
+ * an empty run.
+ *
+ * @example
+ * ```typescript
+ * import { commitStops, splitAxis } from 'footprintjs/trace';
+ *
+ * const axis = splitAxis(commitStops(snapshot.commitLog, snapshot.executionTree));
+ * if (axis.ok) {
+ *   axis.start.commitIdx;          // -1 — the fold base
+ *   axis.stages.map((s) => s.label);
+ *   axis.end.lastCommitIdx;        // the last bundle in the log
+ * } else {
+ *   axis.reason;                   // 'empty' | 'not-bookended'
+ * }
+ * ```
+ */
+export function splitAxis(stops) {
+    const kinds = Object.freeze(stops.map((stop) => stop.kind));
+    if (stops.length === 0)
+        return { ok: false, reason: 'empty', kinds };
+    const start = stops[0];
+    const end = stops[stops.length - 1];
+    if (start.kind !== 'start' || end.kind !== 'end' || stops.length < 2) {
+        return { ok: false, reason: 'not-bookended', kinds };
+    }
+    return { ok: true, start, stages: Object.freeze(stops.slice(1, -1)), end };
+}
+/**
+ * `stop` retyped to the OUTPUT vocabulary, with any meta it already carried
+ * left behind. The input axis may itself be a filtered one (a Beat axis being
+ * narrowed into a Tag axis), and a `true` decision keeps the STOP, not the
+ * other strategy's classification: a `Stop<Tag>` whose `meta` is a Beat would
+ * be a lie the type could not catch. Only the decision may supply a meta.
+ */
+function retyped(stop) {
+    if (stop.meta === undefined)
+        return stop;
+    const out = {};
+    const fields = stop;
+    for (const key of Object.keys(fields))
+        if (key !== 'meta')
+            out[key] = fields[key];
+    return out;
+}
+/**
+ * Build a FILTERING strategy's axis out of another strategy's stops.
+ *
+ * The rule, in one sentence: keep the stages `keep` recognises, and give the
+ * survivors the log back.
+ *
+ * **Meta is the decision's, never inherited.** The input may already be a
+ * filtered axis carrying another strategy's `meta`; a `true` (or a meta-less
+ * object) keeps the stop and DROPS that meta, so a `Stop<TMeta>` never carries
+ * a value of some other type under `TMeta`. The bookends carry none either.
+ *
+ * **The survivors re-partition the log.** A dropped stage's commits still
+ * happened, so they fold into the stop that PRECEDES them: every kept stop's
+ * `lastCommitIdx` runs to just before the next kept stop begins. Nothing is
+ * orphaned and `stateAt(stop)` stays "the state that existed when the next
+ * kept stage started".
+ *
+ * **What that costs `'start'`, said out loud.** The commits before the first
+ * survivor have nowhere else to go, so `'start'` absorbs them: its fold is the
+ * run's base PLUS that prologue — the state the first stop READ, not the raw
+ * base. The returned start therefore carries `prologue: true` whenever it
+ * actually absorbed a stage, and a renderer that means "before anything ran"
+ * checks `kind === 'start' && !prologue`. That flag is the whole reason this
+ * helper exists rather than a `.filter()` call.
+ *
+ * **A log with nothing kept** yields the two bookends and nothing between
+ * them: `'start'` folds the whole log, `'end'` folds the whole log, and
+ * `jumpTo` on any stage id refuses with `reason: 'miss'`. An axis with nowhere
+ * meaningful to stand — which is the truthful shape for a run this strategy
+ * recognises nothing in, and NOT the `[]` that says the log was empty.
+ *
+ * @throws when `stops` is non-empty but not bookended — see {@link splitAxis}.
+ *   Only a strategy can cause that; a run cannot, so it is a contract error
+ *   and not a condition to fold into the data.
+ *
+ * @example
+ * ```typescript
+ * import { commitStops, filterStops } from 'footprintjs/trace';
+ * import type { Stop, TimeTravelStrategy } from 'footprintjs/trace';
+ *
+ * type Milestone = { kind: 'llm-turn' | 'tool-call'; label: string };
+ * declare function milestoneFor(runtimeStageId: string): Milestone | null;
+ *
+ * const milestoneStops: TimeTravelStrategy<Milestone> = {
+ *   stopsFor: (log, tree) =>
+ *     filterStops<Milestone>(commitStops(log, tree), (stop) => {
+ *       const m = milestoneFor(stop.runtimeStageId);
+ *       return m ? { label: m.label, meta: m } : null;
+ *     }),
+ * };
+ *
+ * const cursor = timeTravel(snapshot, { strategy: milestoneStops });
+ * cursor.at()?.meta?.kind;        // 'llm-turn' — no re-derivation
+ * cursor.stops[0].prologue;       // true when stages ran before the first turn
+ * ```
+ */
+export function filterStops(stops, keep) {
+    const axis = splitAxis(stops);
+    if (!axis.ok) {
+        if (axis.reason === 'empty')
+            return [];
+        throw new Error('filterStops: expected a bookended axis — [start, …stages, end] — got kinds ' +
+            `[${axis.kinds.join(', ')}]. Only a strategy can produce that shape; a run cannot.`);
+    }
+    const kept = [];
+    for (const stop of axis.stages) {
+        const decision = keep(stop);
+        if (!decision)
+            continue;
+        if (decision === true)
+            kept.push({ stop });
+        else
+            kept.push({ stop, label: decision.label, meta: decision.meta });
+    }
+    // The log's last index, taken from the `'end'` bookend rather than a length:
+    // `end` is the one stop guaranteed to fold the whole log, and this function
+    // is never handed the log itself.
+    const lastIdx = axis.end.lastCommitIdx;
+    const first = kept[0];
+    const out = [
+        {
+            ...retyped(axis.start),
+            step: 0,
+            lastCommitIdx: first ? first.stop.commitIdx - 1 : lastIdx,
+            // Only when a STAGE was actually absorbed. An axis that kept everything
+            // has the same start it always had, and says nothing it need not say.
+            ...(first && first.stop.step > 1 ? { prologue: true } : {}),
+            ...(!first && axis.stages.length > 0 ? { prologue: true } : {}),
+        },
+    ];
+    for (const [i, row] of kept.entries()) {
+        const next = kept[i + 1];
+        out.push({
+            ...retyped(row.stop),
+            step: out.length,
+            lastCommitIdx: next ? next.stop.commitIdx - 1 : lastIdx,
+            ...(row.label !== undefined ? { label: row.label } : {}),
+            ...(row.meta !== undefined ? { meta: row.meta } : {}),
+        });
+    }
+    out.push({ ...retyped(axis.end), step: out.length });
+    return out;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"axis.js","sourceRoot":"","sources":["../../../../src/lib/time-travel/axis.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * axis.ts — the shape of an axis, and the one safe way to narrow it.\n *\n * WHY THIS FILE EXISTS. `commitStops` returns `Stop[]`, and every strategy\n * that COMPOSES it (keep the stages my domain recognises, drop the rest) rests\n * on a shape the type never stated: `[start, …stages, end]` for a non-empty\n * log, empty for an empty one. Each composer therefore wrote its own runtime\n * guard against its own reading of the contract, plus a mocked-substrate test\n * to prove the guard fires. That is one invariant, discovered three times, and\n * the library that owns the invariant should be the one that states it.\n *\n * {@link splitAxis} states it. {@link filterStops} then does the whole\n * composition — check the shape, keep what the caller keeps, RE-PARTITION the\n * log so the dropped stages' commits are still folded somewhere, and mark the\n * `'start'` bookend as carrying a prologue — because getting the\n * re-partitioning right by hand is the other thing every composer had to\n * rediscover.\n */\n\nimport type { AxisSplit, Stop, StopKind } from './types.js';\n\n/**\n * Split a strategy's stops into `{ start, stages, end }`, or say why it cannot.\n *\n * THE INVARIANT, stated once: for a non-EMPTY log, `commitStops` returns at\n * least the two bookends, `'start'` first and `'end'` last, with one stop per\n * executed stage in execution order between them. For an EMPTY log it returns\n * `[]` — no bookends around nothing, because a cursor with nowhere to stand\n * should say `reason: 'empty'` rather than offer two positions that are the\n * same position.\n *\n * The two refusals are different facts and must not be collapsed: `'empty'`\n * means the run committed nothing, `'not-bookended'` means a strategy broke\n * the contract. A composer that treats them alike reports a broken strategy as\n * an empty run.\n *\n * @example\n * ```typescript\n * import { commitStops, splitAxis } from 'footprintjs/trace';\n *\n * const axis = splitAxis(commitStops(snapshot.commitLog, snapshot.executionTree));\n * if (axis.ok) {\n *   axis.start.commitIdx;          // -1 — the fold base\n *   axis.stages.map((s) => s.label);\n *   axis.end.lastCommitIdx;        // the last bundle in the log\n * } else {\n *   axis.reason;                   // 'empty' | 'not-bookended'\n * }\n * ```\n */\nexport function splitAxis<TMeta = unknown>(stops: readonly Stop<TMeta>[]): AxisSplit<TMeta> {\n  const kinds: readonly StopKind[] = Object.freeze(stops.map((stop) => stop.kind));\n  if (stops.length === 0) return { ok: false, reason: 'empty', kinds };\n  const start = stops[0];\n  const end = stops[stops.length - 1];\n  if (start.kind !== 'start' || end.kind !== 'end' || stops.length < 2) {\n    return { ok: false, reason: 'not-bookended', kinds };\n  }\n  return { ok: true, start, stages: Object.freeze(stops.slice(1, -1)), end };\n}\n\n/**\n * What {@link filterStops} does with one stop: drop it, keep it, or keep it\n * carrying the strategy's own label and vocabulary.\n *\n * `false` / `null` / `undefined` drop. `true` keeps it unchanged. An object\n * keeps it and overrides `label` and/or sets `meta` — the strategy's own\n * classification, travelling ON the stop instead of being re-derived from\n * `runtimeStageId` at every read.\n */\nexport type StopFilter<TMeta> = boolean | null | undefined | { readonly label?: string; readonly meta?: TMeta };\n\n/**\n * `stop` retyped to the OUTPUT vocabulary, with any meta it already carried\n * left behind. The input axis may itself be a filtered one (a Beat axis being\n * narrowed into a Tag axis), and a `true` decision keeps the STOP, not the\n * other strategy's classification: a `Stop<Tag>` whose `meta` is a Beat would\n * be a lie the type could not catch. Only the decision may supply a meta.\n */\nfunction retyped<TMeta>(stop: Stop<unknown>): Stop<TMeta> {\n  if (stop.meta === undefined) return stop as Stop<TMeta>;\n  const out: Record<string, unknown> = {};\n  const fields = stop as unknown as Record<string, unknown>;\n  for (const key of Object.keys(fields)) if (key !== 'meta') out[key] = fields[key];\n  return out as unknown as Stop<TMeta>;\n}\n\n/**\n * Build a FILTERING strategy's axis out of another strategy's stops.\n *\n * The rule, in one sentence: keep the stages `keep` recognises, and give the\n * survivors the log back.\n *\n * **Meta is the decision's, never inherited.** The input may already be a\n * filtered axis carrying another strategy's `meta`; a `true` (or a meta-less\n * object) keeps the stop and DROPS that meta, so a `Stop<TMeta>` never carries\n * a value of some other type under `TMeta`. The bookends carry none either.\n *\n * **The survivors re-partition the log.** A dropped stage's commits still\n * happened, so they fold into the stop that PRECEDES them: every kept stop's\n * `lastCommitIdx` runs to just before the next kept stop begins. Nothing is\n * orphaned and `stateAt(stop)` stays \"the state that existed when the next\n * kept stage started\".\n *\n * **What that costs `'start'`, said out loud.** The commits before the first\n * survivor have nowhere else to go, so `'start'` absorbs them: its fold is the\n * run's base PLUS that prologue — the state the first stop READ, not the raw\n * base. The returned start therefore carries `prologue: true` whenever it\n * actually absorbed a stage, and a renderer that means \"before anything ran\"\n * checks `kind === 'start' && !prologue`. That flag is the whole reason this\n * helper exists rather than a `.filter()` call.\n *\n * **A log with nothing kept** yields the two bookends and nothing between\n * them: `'start'` folds the whole log, `'end'` folds the whole log, and\n * `jumpTo` on any stage id refuses with `reason: 'miss'`. An axis with nowhere\n * meaningful to stand — which is the truthful shape for a run this strategy\n * recognises nothing in, and NOT the `[]` that says the log was empty.\n *\n * @throws when `stops` is non-empty but not bookended — see {@link splitAxis}.\n *   Only a strategy can cause that; a run cannot, so it is a contract error\n *   and not a condition to fold into the data.\n *\n * @example\n * ```typescript\n * import { commitStops, filterStops } from 'footprintjs/trace';\n * import type { Stop, TimeTravelStrategy } from 'footprintjs/trace';\n *\n * type Milestone = { kind: 'llm-turn' | 'tool-call'; label: string };\n * declare function milestoneFor(runtimeStageId: string): Milestone | null;\n *\n * const milestoneStops: TimeTravelStrategy<Milestone> = {\n *   stopsFor: (log, tree) =>\n *     filterStops<Milestone>(commitStops(log, tree), (stop) => {\n *       const m = milestoneFor(stop.runtimeStageId);\n *       return m ? { label: m.label, meta: m } : null;\n *     }),\n * };\n *\n * const cursor = timeTravel(snapshot, { strategy: milestoneStops });\n * cursor.at()?.meta?.kind;        // 'llm-turn' — no re-derivation\n * cursor.stops[0].prologue;       // true when stages ran before the first turn\n * ```\n */\nexport function filterStops<TMeta = unknown>(\n  stops: readonly Stop<unknown>[],\n  keep: (stop: Stop<unknown>) => StopFilter<TMeta>,\n): Stop<TMeta>[] {\n  const axis = splitAxis(stops);\n  if (!axis.ok) {\n    if (axis.reason === 'empty') return [];\n    throw new Error(\n      'filterStops: expected a bookended axis — [start, …stages, end] — got kinds ' +\n        `[${axis.kinds.join(', ')}]. Only a strategy can produce that shape; a run cannot.`,\n    );\n  }\n\n  const kept: { stop: Stop<unknown>; label?: string; meta?: TMeta }[] = [];\n  for (const stop of axis.stages) {\n    const decision = keep(stop);\n    if (!decision) continue;\n    if (decision === true) kept.push({ stop });\n    else kept.push({ stop, label: decision.label, meta: decision.meta });\n  }\n\n  // The log's last index, taken from the `'end'` bookend rather than a length:\n  // `end` is the one stop guaranteed to fold the whole log, and this function\n  // is never handed the log itself.\n  const lastIdx = axis.end.lastCommitIdx;\n  const first = kept[0];\n  const out: Stop<TMeta>[] = [\n    {\n      ...retyped<TMeta>(axis.start),\n      step: 0,\n      lastCommitIdx: first ? first.stop.commitIdx - 1 : lastIdx,\n      // Only when a STAGE was actually absorbed. An axis that kept everything\n      // has the same start it always had, and says nothing it need not say.\n      ...(first && first.stop.step > 1 ? { prologue: true as const } : {}),\n      ...(!first && axis.stages.length > 0 ? { prologue: true as const } : {}),\n    },\n  ];\n\n  for (const [i, row] of kept.entries()) {\n    const next = kept[i + 1];\n    out.push({\n      ...retyped<TMeta>(row.stop),\n      step: out.length,\n      lastCommitIdx: next ? next.stop.commitIdx - 1 : lastIdx,\n      ...(row.label !== undefined ? { label: row.label } : {}),\n      ...(row.meta !== undefined ? { meta: row.meta } : {}),\n    });\n  }\n\n  out.push({ ...retyped<TMeta>(axis.end), step: out.length });\n  return out;\n}\n"]}