footprintjs 9.17.0 → 9.18.0

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/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"]}

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

@@ -0,0 +1,77 @@
+/**
+ * bundles.ts — reading a log whose rows are not typed yet.
+ *
+ * WHY THIS FILE EXISTS. A LIVE snapshot hands time travel real
+ * {@link CommitBundle}s. A STORED recording hands it parsed JSON, and a
+ * careful consumer will not claim that what came back off disk is a
+ * `CommitBundle` — so it either casts (a lie with a comment on it) or cannot
+ * call the library at all. Since 9.18.0 the source takes `readonly unknown[]`
+ * and the narrowing happens here, per row, at the one place that actually
+ * reads one.
+ *
+ * A row that is not a bundle becomes a GAP rather than an exception: it KEEPS
+ * ITS INDEX — so every `commitIdx` in the axis still addresses the same
+ * position — contributes no state, gets no stop, and is reported with its
+ * index and a reason. One corrupt row in a stored recording loses that row,
+ * not the recording.
+ */
+import type { CommitBundle, StageSnapshot } from '../memory/types.js';
+import type { LogGap } from './types.js';
+/** A plain object — not null, not an array, not a primitive. */
+export declare function isPlainish(value: unknown): value is Record<string, unknown>;
+/**
+ * Read a source's `executionTree` as a {@link StageSnapshot}, or as absent.
+ *
+ * The tree is only ever WALKED for mount ids (`subflowId` + `runtimeStageId`
+ * on each node), so the honest narrowing a reader can do is "a plain object";
+ * anything else — a stored field that came back as a string, a number, an
+ * array — is read as no tree at all, which sends `commitStops` down the same
+ * shape-heuristic path a log handed over without its tree already takes.
+ */
+export declare function readTree(value: unknown): StageSnapshot | undefined;
+/**
+ * Why `row` cannot be read as a commit bundle, or `undefined` when it can.
+ *
+ * DELIBERATELY LENIENT — but exactly as lenient as the readers are. It checks
+ * what the fold, the axis and `changedSince` actually touch:
+ *
+ * - `runtimeStageId` must be a string — the axis keys on it.
+ * - `trace` must be an ARRAY, and it must be PRESENT. It is the one field
+ *   every reader WALKS (`applySmartMerge` iterates it verb by verb;
+ *   `changedSince` reads its paths), so a row without one is not a bundle the
+ *   fold can survive — it is the crash a gap exists to prevent. `CommitBundle`
+ *   declares it required, so no live log is affected.
+ * - `updates` / `overwrite`, when present, must be plain objects. They are
+ *   read only AT THE PATHS THE TRACE NAMES, so an absent one is harmless and
+ *   is tolerated, exactly as the fold tolerates an absent `redactedPaths`.
+ *
+ * Being stricter than that — demanding `stage`, `stageId`, `idx` — would
+ * reject hand-built logs that have folded correctly since 9.17.0, which is a
+ * compatibility break dressed up as validation.
+ */
+export declare function bundleRefusal(row: unknown): string | undefined;
+/** `true` when `row` can be read as a {@link CommitBundle}. */
+export declare function isCommitBundle(row: unknown): row is CommitBundle;
+/** A log read row by row: the bundles, index-aligned, plus what was refused. */
+export interface ReadLog {
+    /** Same length and order as the input; a refused row holds a GAP stand-in. */
+    readonly log: readonly CommitBundle[];
+    /** The refused rows, in index order. Empty when the log was clean. */
+    readonly gaps: readonly LogGap[];
+}
+/**
+ * Read an unvalidated array as a commit log.
+ *
+ * The clean case (a live snapshot, or a stored recording that round-tripped
+ * intact) returns the SAME array reference and no gaps: nothing is copied,
+ * nothing is allocated, and the fold behaves byte for byte as it did in
+ * 9.17.0. Only a log with a refused row is rebuilt, and only to keep the
+ * indices aligned.
+ *
+ * @example
+ * ```typescript
+ * const { log, gaps } = readLog(JSON.parse(stored).commitLog);
+ * gaps; // [{ index: 3, reason: 'not an object (null)' }]
+ * ```
+ */
+export declare function readLog(raw: readonly unknown[] | undefined): ReadLog;

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

@@ -0,0 +1,124 @@
+/**
+ * bundles.ts — reading a log whose rows are not typed yet.
+ *
+ * WHY THIS FILE EXISTS. A LIVE snapshot hands time travel real
+ * {@link CommitBundle}s. A STORED recording hands it parsed JSON, and a
+ * careful consumer will not claim that what came back off disk is a
+ * `CommitBundle` — so it either casts (a lie with a comment on it) or cannot
+ * call the library at all. Since 9.18.0 the source takes `readonly unknown[]`
+ * and the narrowing happens here, per row, at the one place that actually
+ * reads one.
+ *
+ * A row that is not a bundle becomes a GAP rather than an exception: it KEEPS
+ * ITS INDEX — so every `commitIdx` in the axis still addresses the same
+ * position — contributes no state, gets no stop, and is reported with its
+ * index and a reason. One corrupt row in a stored recording loses that row,
+ * not the recording.
+ */
+/**
+ * The stand-in a gap leaves at its index: a commit that belongs to no stage
+ * and carries nothing.
+ *
+ * It is NOT invented evidence — every field is the empty value, and an id-less
+ * bundle is a shape the log already has (a root-context commit made before any
+ * stage ran). `commitStops` gives it no stop for exactly that reason, the fold
+ * folds nothing from it, and `changedSince` reads no keys off it. What it does
+ * is hold the index, so the arithmetic downstream never has to know.
+ */
+const GAP_BUNDLE = Object.freeze({
+    stage: '',
+    stageId: '',
+    runtimeStageId: '',
+    trace: Object.freeze([]),
+    redactedPaths: Object.freeze([]),
+    overwrite: Object.freeze({}),
+    updates: Object.freeze({}),
+});
+/** A plain object — not null, not an array, not a primitive. */
+export function isPlainish(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Read a source's `executionTree` as a {@link StageSnapshot}, or as absent.
+ *
+ * The tree is only ever WALKED for mount ids (`subflowId` + `runtimeStageId`
+ * on each node), so the honest narrowing a reader can do is "a plain object";
+ * anything else — a stored field that came back as a string, a number, an
+ * array — is read as no tree at all, which sends `commitStops` down the same
+ * shape-heuristic path a log handed over without its tree already takes.
+ */
+export function readTree(value) {
+    return isPlainish(value) ? value : undefined;
+}
+/**
+ * Why `row` cannot be read as a commit bundle, or `undefined` when it can.
+ *
+ * DELIBERATELY LENIENT — but exactly as lenient as the readers are. It checks
+ * what the fold, the axis and `changedSince` actually touch:
+ *
+ * - `runtimeStageId` must be a string — the axis keys on it.
+ * - `trace` must be an ARRAY, and it must be PRESENT. It is the one field
+ *   every reader WALKS (`applySmartMerge` iterates it verb by verb;
+ *   `changedSince` reads its paths), so a row without one is not a bundle the
+ *   fold can survive — it is the crash a gap exists to prevent. `CommitBundle`
+ *   declares it required, so no live log is affected.
+ * - `updates` / `overwrite`, when present, must be plain objects. They are
+ *   read only AT THE PATHS THE TRACE NAMES, so an absent one is harmless and
+ *   is tolerated, exactly as the fold tolerates an absent `redactedPaths`.
+ *
+ * Being stricter than that — demanding `stage`, `stageId`, `idx` — would
+ * reject hand-built logs that have folded correctly since 9.17.0, which is a
+ * compatibility break dressed up as validation.
+ */
+export function bundleRefusal(row) {
+    if (!isPlainish(row)) {
+        return `not an object (${row === null ? 'null' : Array.isArray(row) ? 'array' : typeof row})`;
+    }
+    if (typeof row.runtimeStageId !== 'string') {
+        return `runtimeStageId is ${row.runtimeStageId === undefined ? 'missing' : `a ${typeof row.runtimeStageId}`}, not a string`;
+    }
+    if (!Array.isArray(row.trace)) {
+        return `trace is ${row.trace === undefined ? 'missing' : `a ${typeof row.trace}`}, not an array`;
+    }
+    if (row.updates !== undefined && !isPlainish(row.updates))
+        return 'updates is not a plain object';
+    if (row.overwrite !== undefined && !isPlainish(row.overwrite))
+        return 'overwrite is not a plain object';
+    return undefined;
+}
+/** `true` when `row` can be read as a {@link CommitBundle}. */
+export function isCommitBundle(row) {
+    return bundleRefusal(row) === undefined;
+}
+/** Nothing to read — shared, so the clean path allocates nothing extra. */
+const NO_GAPS = Object.freeze([]);
+/**
+ * Read an unvalidated array as a commit log.
+ *
+ * The clean case (a live snapshot, or a stored recording that round-tripped
+ * intact) returns the SAME array reference and no gaps: nothing is copied,
+ * nothing is allocated, and the fold behaves byte for byte as it did in
+ * 9.17.0. Only a log with a refused row is rebuilt, and only to keep the
+ * indices aligned.
+ *
+ * @example
+ * ```typescript
+ * const { log, gaps } = readLog(JSON.parse(stored).commitLog);
+ * gaps; // [{ index: 3, reason: 'not an object (null)' }]
+ * ```
+ */
+export function readLog(raw) {
+    if (!raw || raw.length === 0)
+        return { log: [], gaps: NO_GAPS };
+    let gaps;
+    for (let i = 0; i < raw.length; i++) {
+        const reason = bundleRefusal(raw[i]);
+        if (reason !== undefined)
+            (gaps ??= []).push({ index: i, reason });
+    }
+    if (!gaps)
+        return { log: raw, gaps: NO_GAPS };
+    const log = raw.map((row) => (isCommitBundle(row) ? row : GAP_BUNDLE));
+    return { log, gaps: Object.freeze(gaps) };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bundles.js","sourceRoot":"","sources":["../../../../src/lib/time-travel/bundles.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * bundles.ts — reading a log whose rows are not typed yet.\n *\n * WHY THIS FILE EXISTS. A LIVE snapshot hands time travel real\n * {@link CommitBundle}s. A STORED recording hands it parsed JSON, and a\n * careful consumer will not claim that what came back off disk is a\n * `CommitBundle` — so it either casts (a lie with a comment on it) or cannot\n * call the library at all. Since 9.18.0 the source takes `readonly unknown[]`\n * and the narrowing happens here, per row, at the one place that actually\n * reads one.\n *\n * A row that is not a bundle becomes a GAP rather than an exception: it KEEPS\n * ITS INDEX — so every `commitIdx` in the axis still addresses the same\n * position — contributes no state, gets no stop, and is reported with its\n * index and a reason. One corrupt row in a stored recording loses that row,\n * not the recording.\n */\n\nimport type { CommitBundle, StageSnapshot } from '../memory/types.js';\nimport type { LogGap } from './types.js';\n\n/**\n * The stand-in a gap leaves at its index: a commit that belongs to no stage\n * and carries nothing.\n *\n * It is NOT invented evidence — every field is the empty value, and an id-less\n * bundle is a shape the log already has (a root-context commit made before any\n * stage ran). `commitStops` gives it no stop for exactly that reason, the fold\n * folds nothing from it, and `changedSince` reads no keys off it. What it does\n * is hold the index, so the arithmetic downstream never has to know.\n */\nconst GAP_BUNDLE: CommitBundle = Object.freeze({\n  stage: '',\n  stageId: '',\n  runtimeStageId: '',\n  trace: Object.freeze([]) as unknown as CommitBundle['trace'],\n  redactedPaths: Object.freeze([]) as unknown as string[],\n  overwrite: Object.freeze({}),\n  updates: Object.freeze({}),\n});\n\n/** A plain object — not null, not an array, not a primitive. */\nexport function isPlainish(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\n/**\n * Read a source's `executionTree` as a {@link StageSnapshot}, or as absent.\n *\n * The tree is only ever WALKED for mount ids (`subflowId` + `runtimeStageId`\n * on each node), so the honest narrowing a reader can do is \"a plain object\";\n * anything else — a stored field that came back as a string, a number, an\n * array — is read as no tree at all, which sends `commitStops` down the same\n * shape-heuristic path a log handed over without its tree already takes.\n */\nexport function readTree(value: unknown): StageSnapshot | undefined {\n  return isPlainish(value) ? (value as unknown as StageSnapshot) : undefined;\n}\n\n/**\n * Why `row` cannot be read as a commit bundle, or `undefined` when it can.\n *\n * DELIBERATELY LENIENT — but exactly as lenient as the readers are. It checks\n * what the fold, the axis and `changedSince` actually touch:\n *\n * - `runtimeStageId` must be a string — the axis keys on it.\n * - `trace` must be an ARRAY, and it must be PRESENT. It is the one field\n *   every reader WALKS (`applySmartMerge` iterates it verb by verb;\n *   `changedSince` reads its paths), so a row without one is not a bundle the\n *   fold can survive — it is the crash a gap exists to prevent. `CommitBundle`\n *   declares it required, so no live log is affected.\n * - `updates` / `overwrite`, when present, must be plain objects. They are\n *   read only AT THE PATHS THE TRACE NAMES, so an absent one is harmless and\n *   is tolerated, exactly as the fold tolerates an absent `redactedPaths`.\n *\n * Being stricter than that — demanding `stage`, `stageId`, `idx` — would\n * reject hand-built logs that have folded correctly since 9.17.0, which is a\n * compatibility break dressed up as validation.\n */\nexport function bundleRefusal(row: unknown): string | undefined {\n  if (!isPlainish(row)) {\n    return `not an object (${row === null ? 'null' : Array.isArray(row) ? 'array' : typeof row})`;\n  }\n  if (typeof row.runtimeStageId !== 'string') {\n    return `runtimeStageId is ${\n      row.runtimeStageId === undefined ? 'missing' : `a ${typeof row.runtimeStageId}`\n    }, not a string`;\n  }\n  if (!Array.isArray(row.trace)) {\n    return `trace is ${row.trace === undefined ? 'missing' : `a ${typeof row.trace}`}, not an array`;\n  }\n  if (row.updates !== undefined && !isPlainish(row.updates)) return 'updates is not a plain object';\n  if (row.overwrite !== undefined && !isPlainish(row.overwrite)) return 'overwrite is not a plain object';\n  return undefined;\n}\n\n/** `true` when `row` can be read as a {@link CommitBundle}. */\nexport function isCommitBundle(row: unknown): row is CommitBundle {\n  return bundleRefusal(row) === undefined;\n}\n\n/** A log read row by row: the bundles, index-aligned, plus what was refused. */\nexport interface ReadLog {\n  /** Same length and order as the input; a refused row holds a GAP stand-in. */\n  readonly log: readonly CommitBundle[];\n  /** The refused rows, in index order. Empty when the log was clean. */\n  readonly gaps: readonly LogGap[];\n}\n\n/** Nothing to read — shared, so the clean path allocates nothing extra. */\nconst NO_GAPS: readonly LogGap[] = Object.freeze([]);\n\n/**\n * Read an unvalidated array as a commit log.\n *\n * The clean case (a live snapshot, or a stored recording that round-tripped\n * intact) returns the SAME array reference and no gaps: nothing is copied,\n * nothing is allocated, and the fold behaves byte for byte as it did in\n * 9.17.0. Only a log with a refused row is rebuilt, and only to keep the\n * indices aligned.\n *\n * @example\n * ```typescript\n * const { log, gaps } = readLog(JSON.parse(stored).commitLog);\n * gaps; // [{ index: 3, reason: 'not an object (null)' }]\n * ```\n */\nexport function readLog(raw: readonly unknown[] | undefined): ReadLog {\n  if (!raw || raw.length === 0) return { log: [], gaps: NO_GAPS };\n\n  let gaps: LogGap[] | undefined;\n  for (let i = 0; i < raw.length; i++) {\n    const reason = bundleRefusal(raw[i]);\n    if (reason !== undefined) (gaps ??= []).push({ index: i, reason });\n  }\n  if (!gaps) return { log: raw as readonly CommitBundle[], gaps: NO_GAPS };\n\n  const log = raw.map((row) => (isCommitBundle(row) ? row : GAP_BUNDLE));\n  return { log, gaps: Object.freeze(gaps) };\n}\n"]}