footprintjs 9.12.0 → 9.13.0

package/dist/esm/lib/slice/forwardSliceForKey.d.ts

@@ -0,0 +1,84 @@
+/**
+ * slice/forwardSliceForKey.ts — the FORWARD half of variable-first slicing.
+ *
+ * `sliceForKey` answers "why is `key` what it is?" by walking backward from
+ * the value to its causes. This file answers the opposite question, which no
+ * query answered before: **"who READ this value, and what did it FEED?"**
+ * (the production shape: *who read `recipeId`, and what did it feed?* — one
+ * query, not a manual scan of a trace viewer).
+ *
+ * ## The algorithm: LIVE RANGES, not steps
+ *
+ * A backward slice hops writer→writer. Forward, the unit is a value's LIFE:
+ *
+ * 1. Anchor at a write of `key` — the SAME anchor idiom as `sliceForKey`
+ *    (the last writer, or the last writer before `before`).
+ * 2. That value lives until the key's NEXT write (`nextWriteIdx`). Every
+ *    stage that READ `key` inside that window saw THIS value — a `read`.
+ * 3. A reading stage that also WROTE something carried the value onward —
+ *    a `fed` edge to that write, which is itself the start of a new life.
+ * 4. Descend into fed lives breadth-first (visited-set guarded, budgeted).
+ *
+ * ### LAW — the live range is `(writeIdx, nextWriteIdx]`
+ *
+ * Open at the bottom, CLOSED at the top, and both ends follow from the
+ * engine's event order (`onRead` fires PRE-commit — see CLAUDE.md):
+ * - a read by the writing stage itself (`readIdx === writeIdx`) saw the
+ *   PREVIOUS value: read-modify-write reads belong to the previous life;
+ * - a read by the OVERWRITING stage (`readIdx === nextWriteIdx`) also fired
+ *   before its commit, so it still saw THIS value.
+ * A read after that commit attributes to the NEW write, never the old one.
+ * (Granularity limit, stated because it cannot be seen: a stage that writes
+ * `key` and then re-reads it within the SAME stage read its own value; at
+ * commit-index resolution that read is indistinguishable from the one that
+ * opened the stage.)
+ *
+ * ### LAW — a `fed` edge is EXACT only under recorded read provenance
+ *
+ * With `writeProvenance: 'reads-prefix'` on, the child write's
+ * `TraceEntry.readKeys` names the keys read before it: this key IN that list
+ * is an exact edge (`basis: 'per-write'`), and this key ABSENT from it is an
+ * exact *exclusion* — no edge at all. With the dial off there is no such
+ * evidence, only "the stage read this and wrote that": the edge is stamped
+ * `basis: 'stage'` and the slice carries a `'conservative-fed-edges'` note.
+ * A conservative edge is never presented as an exact one.
+ *
+ * Budgets mirror `causalChain`'s (maxDepth 20, maxNodes 100) and a cut is
+ * STATED — `root.truncated` plus a `'truncated'` note.
+ *
+ * DAG position: memory ← slice. Imports memory/ only (see README.md).
+ */
+import type { KeysReadLookup } from '../memory/backtrack.js';
+import type { CommitBundle } from '../memory/types.js';
+import type { ForwardSlice, KeysReadSource, StateKey } from './types.js';
+/** Options for {@link forwardSliceForKey} — anchoring plus walk budgets. */
+export interface ForwardSliceForKeyOptions {
+    /**
+     * Exclusive commit-array-index upper bound for the ANCHOR search: follow
+     * the value as it stood BEFORE this idx. Same contract as
+     * `sliceForKey`'s `before` / `findLastWriter`'s `beforeIdx`.
+     *
+     * It bounds the anchor ONLY — the walk then runs forward past it, because
+     * "what did the value at step 12 go on to feed?" is the whole question.
+     */
+    before?: number;
+    /** Maximum BFS depth in value-lives (default: 20 — causalChain's). */
+    maxDepth?: number;
+    /** Maximum total nodes (default: 100 — causalChain's). */
+    maxNodes?: number;
+}
+/**
+ * Forward slice for one state key: who read this value, and what did it feed?
+ *
+ * @param commitLog Ordered commit bundles — `getSnapshot().commitLog`.
+ * @param key A {@link StateKey}: the plain key string, or a path array
+ *   (normalised through the SAME `normaliseStateKey` the backward door uses,
+ *   so both doors accept identical inputs).
+ * @param keysRead A {@link KeysReadSource} strategy or a bare lookup — the
+ *   same reads providers `sliceForKey` takes. Reads are not in the commit
+ *   log; without a provider a forward walk can see nothing, which the
+ *   `'reads-not-recorded'` note says out loud.
+ * @returns Always a {@link ForwardSlice}. Absence is a RESULT with a reason
+ *   and, for an unknown key, a bounded list of the keys the log does know.
+ */
+export declare function forwardSliceForKey(commitLog: CommitBundle[], key: StateKey, keysRead: KeysReadSource | KeysReadLookup, options?: ForwardSliceForKeyOptions): ForwardSlice;

package/dist/esm/lib/slice/forwardSliceForKey.js

@@ -0,0 +1,220 @@
+/**
+ * slice/forwardSliceForKey.ts — the FORWARD half of variable-first slicing.
+ *
+ * `sliceForKey` answers "why is `key` what it is?" by walking backward from
+ * the value to its causes. This file answers the opposite question, which no
+ * query answered before: **"who READ this value, and what did it FEED?"**
+ * (the production shape: *who read `recipeId`, and what did it feed?* — one
+ * query, not a manual scan of a trace viewer).
+ *
+ * ## The algorithm: LIVE RANGES, not steps
+ *
+ * A backward slice hops writer→writer. Forward, the unit is a value's LIFE:
+ *
+ * 1. Anchor at a write of `key` — the SAME anchor idiom as `sliceForKey`
+ *    (the last writer, or the last writer before `before`).
+ * 2. That value lives until the key's NEXT write (`nextWriteIdx`). Every
+ *    stage that READ `key` inside that window saw THIS value — a `read`.
+ * 3. A reading stage that also WROTE something carried the value onward —
+ *    a `fed` edge to that write, which is itself the start of a new life.
+ * 4. Descend into fed lives breadth-first (visited-set guarded, budgeted).
+ *
+ * ### LAW — the live range is `(writeIdx, nextWriteIdx]`
+ *
+ * Open at the bottom, CLOSED at the top, and both ends follow from the
+ * engine's event order (`onRead` fires PRE-commit — see CLAUDE.md):
+ * - a read by the writing stage itself (`readIdx === writeIdx`) saw the
+ *   PREVIOUS value: read-modify-write reads belong to the previous life;
+ * - a read by the OVERWRITING stage (`readIdx === nextWriteIdx`) also fired
+ *   before its commit, so it still saw THIS value.
+ * A read after that commit attributes to the NEW write, never the old one.
+ * (Granularity limit, stated because it cannot be seen: a stage that writes
+ * `key` and then re-reads it within the SAME stage read its own value; at
+ * commit-index resolution that read is indistinguishable from the one that
+ * opened the stage.)
+ *
+ * ### LAW — a `fed` edge is EXACT only under recorded read provenance
+ *
+ * With `writeProvenance: 'reads-prefix'` on, the child write's
+ * `TraceEntry.readKeys` names the keys read before it: this key IN that list
+ * is an exact edge (`basis: 'per-write'`), and this key ABSENT from it is an
+ * exact *exclusion* — no edge at all. With the dial off there is no such
+ * evidence, only "the stage read this and wrote that": the edge is stamped
+ * `basis: 'stage'` and the slice carries a `'conservative-fed-edges'` note.
+ * A conservative edge is never presented as an exact one.
+ *
+ * Budgets mirror `causalChain`'s (maxDepth 20, maxNodes 100) and a cut is
+ * STATED — `root.truncated` plus a `'truncated'` note.
+ *
+ * DAG position: memory ← slice. Imports memory/ only (see README.md).
+ */
+import { DELIM } from '../memory/utils.js';
+import { buildKeyIndex, conservativeEdgesNote, firstIndexAfter, hasRecordedReads, indicesInRange, lastIndexBefore, lastTraceEntry, preRunOriginNote, readsNotRecordedNote, truncatedNote, unknownKeyNote, writtenPaths, } from './keyIndex.js';
+import { resolveKeysReadSource } from './keysReadSources.js';
+import { normaliseStateKey } from './sliceForKey.js';
+/** Identity of one value life: (write position, key). Never parsed. */
+function nodeKey(commitIdx, key) {
+    return `${commitIdx ?? 'pre-run'}${DELIM}${key}`;
+}
+/**
+ * Build the node for ONE value life. `writeIdx === undefined` is the pre-run
+ * origin: the value was already there before the log's first write of the
+ * key, so the writer identity fields stay ABSENT rather than fabricated.
+ */
+function makeNode(commitLog, index, key, writeIdx, depth) {
+    const writes = index.writesByKey.get(key);
+    if (writeIdx === undefined) {
+        const firstWrite = writes?.[0];
+        return {
+            key,
+            origin: 'pre-run',
+            ...(firstWrite !== undefined && { nextWriteIdx: firstWrite }),
+            depth,
+            reads: [],
+            fedEdges: [],
+        };
+    }
+    const bundle = commitLog[writeIdx];
+    const entry = lastTraceEntry(bundle, key);
+    const next = firstIndexAfter(writes, writeIdx);
+    return {
+        key,
+        origin: 'write',
+        runtimeStageId: bundle.runtimeStageId,
+        stageId: bundle.stageId,
+        stageName: bundle.stage,
+        commitIdx: writeIdx,
+        ...(entry !== undefined && { verb: entry.verb }),
+        ...(next !== undefined && { nextWriteIdx: next }),
+        depth,
+        reads: [],
+        fedEdges: [],
+        // Untracked-read honesty rides through from the bundle exactly as
+        // causalChain stamps CausalNode.incompleteSources.
+        ...(bundle.untrackedSources !== undefined &&
+            bundle.untrackedSources.length > 0 && { incompleteSources: bundle.untrackedSources }),
+    };
+}
+/**
+ * Forward slice for one state key: who read this value, and what did it feed?
+ *
+ * @param commitLog Ordered commit bundles — `getSnapshot().commitLog`.
+ * @param key A {@link StateKey}: the plain key string, or a path array
+ *   (normalised through the SAME `normaliseStateKey` the backward door uses,
+ *   so both doors accept identical inputs).
+ * @param keysRead A {@link KeysReadSource} strategy or a bare lookup — the
+ *   same reads providers `sliceForKey` takes. Reads are not in the commit
+ *   log; without a provider a forward walk can see nothing, which the
+ *   `'reads-not-recorded'` note says out loud.
+ * @returns Always a {@link ForwardSlice}. Absence is a RESULT with a reason
+ *   and, for an unknown key, a bounded list of the keys the log does know.
+ */
+export function forwardSliceForKey(commitLog, key, keysRead, options) {
+    const source = resolveKeysReadSource(keysRead);
+    const normalisedKey = normaliseStateKey(key);
+    const base = {
+        key: normalisedKey,
+        ...(options?.before !== undefined && { before: options.before }),
+        keysReadKind: source.kind,
+        ...(source.coverage !== undefined && { readsCoverage: source.coverage }),
+    };
+    if (commitLog.length === 0)
+        return { ...base, missing: 'empty-log', notes: [] };
+    const index = buildKeyIndex(commitLog, source.lookup);
+    const readsRecorded = hasRecordedReads(index);
+    const notes = [];
+    // ── The typo guard, split by what the recording affords ────────────────
+    // Unknown key + reads ARE recorded → the log can see readers and this key
+    // has none: honest absence with a named reason, no fabricated life.
+    // Unknown key + NO reads recorded → a typo and a seeded-but-unread key are
+    // genuinely indistinguishable; the pre-run life below is the only honest
+    // answer, and it must carry BOTH notes so nobody reads it as "unread".
+    const known = index.knownKeys.has(normalisedKey);
+    if (!known) {
+        notes.push(unknownKeyNote(index, normalisedKey));
+        if (readsRecorded)
+            return { ...base, missing: 'never-written', notes };
+    }
+    if (!readsRecorded)
+        notes.push(readsNotRecordedNote());
+    const maxDepth = options?.maxDepth ?? 20;
+    const maxNodes = options?.maxNodes ?? 100;
+    const nodes = new Map();
+    let created = 0;
+    let truncatedByDepth = false;
+    let truncatedByNodes = false;
+    let anyConservative = false;
+    const anchorIdx = lastIndexBefore(index.writesByKey.get(normalisedKey), options?.before);
+    const root = makeNode(commitLog, index, normalisedKey, anchorIdx, 0);
+    nodes.set(nodeKey(anchorIdx, normalisedKey), root);
+    created = 1;
+    const queue = [root];
+    while (queue.length > 0) {
+        const node = queue.shift();
+        // Live range: open below the write, CLOSED at the next write (see LAW).
+        const from = node.commitIdx !== undefined ? node.commitIdx + 1 : 0;
+        const readers = indicesInRange(index.readsByKey.get(node.key), from, node.nextWriteIdx);
+        if (node.depth >= maxDepth) {
+            // Only a life that still HAD readers to expand counts as a cut.
+            if (readers.length > 0)
+                truncatedByDepth = true;
+            continue;
+        }
+        for (const readerIdx of readers) {
+            const bundle = commitLog[readerIdx];
+            node.reads.push({
+                runtimeStageId: bundle.runtimeStageId,
+                stageId: bundle.stageId,
+                stageName: bundle.stage,
+                commitIdx: readerIdx,
+            });
+            // The reader IS the writer of everything it committed — each written
+            // path is a candidate `fed` edge.
+            for (const path of writtenPaths(bundle)) {
+                const entry = lastTraceEntry(bundle, path);
+                let basis;
+                if (entry?.readKeys !== undefined) {
+                    // EXACT both ways: recorded provenance can include or EXCLUDE.
+                    if (!entry.readKeys.includes(node.key))
+                        continue;
+                    basis = 'per-write';
+                }
+                else {
+                    basis = 'stage';
+                    anyConservative = true;
+                }
+                const id = nodeKey(readerIdx, path);
+                let child = nodes.get(id);
+                if (!child) {
+                    if (created >= maxNodes) {
+                        truncatedByNodes = true;
+                        continue;
+                    }
+                    child = makeNode(commitLog, index, path, readerIdx, node.depth + 1);
+                    nodes.set(id, child);
+                    created++;
+                    queue.push(child);
+                }
+                // One edge per distinct child life (a stage reads a key once).
+                if (!node.fedEdges.some((e) => e.child === child))
+                    node.fedEdges.push({ child, basis });
+            }
+        }
+    }
+    // ── Honesty envelope, deterministic order ─────────────────────────────
+    if (root.origin === 'pre-run')
+        notes.push(preRunOriginNote(normalisedKey));
+    if (anyConservative)
+        notes.push(conservativeEdgesNote(normalisedKey));
+    if (truncatedByDepth || truncatedByNodes) {
+        root.truncated = { byDepth: truncatedByDepth, byNodes: truncatedByNodes };
+        notes.push(truncatedNote(truncatedByDepth, truncatedByNodes));
+    }
+    return {
+        ...base,
+        ...(anchorIdx !== undefined && { writer: commitLog[anchorIdx] }),
+        root,
+        notes,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"forwardSliceForKey.js","sourceRoot":"","sources":["../../../../src/lib/slice/forwardSliceForKey.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * slice/forwardSliceForKey.ts — the FORWARD half of variable-first slicing.\n *\n * `sliceForKey` answers \"why is `key` what it is?\" by walking backward from\n * the value to its causes. This file answers the opposite question, which no\n * query answered before: **\"who READ this value, and what did it FEED?\"**\n * (the production shape: *who read `recipeId`, and what did it feed?* — one\n * query, not a manual scan of a trace viewer).\n *\n * ## The algorithm: LIVE RANGES, not steps\n *\n * A backward slice hops writer→writer. Forward, the unit is a value's LIFE:\n *\n * 1. Anchor at a write of `key` — the SAME anchor idiom as `sliceForKey`\n *    (the last writer, or the last writer before `before`).\n * 2. That value lives until the key's NEXT write (`nextWriteIdx`). Every\n *    stage that READ `key` inside that window saw THIS value — a `read`.\n * 3. A reading stage that also WROTE something carried the value onward —\n *    a `fed` edge to that write, which is itself the start of a new life.\n * 4. Descend into fed lives breadth-first (visited-set guarded, budgeted).\n *\n * ### LAW — the live range is `(writeIdx, nextWriteIdx]`\n *\n * Open at the bottom, CLOSED at the top, and both ends follow from the\n * engine's event order (`onRead` fires PRE-commit — see CLAUDE.md):\n * - a read by the writing stage itself (`readIdx === writeIdx`) saw the\n *   PREVIOUS value: read-modify-write reads belong to the previous life;\n * - a read by the OVERWRITING stage (`readIdx === nextWriteIdx`) also fired\n *   before its commit, so it still saw THIS value.\n * A read after that commit attributes to the NEW write, never the old one.\n * (Granularity limit, stated because it cannot be seen: a stage that writes\n * `key` and then re-reads it within the SAME stage read its own value; at\n * commit-index resolution that read is indistinguishable from the one that\n * opened the stage.)\n *\n * ### LAW — a `fed` edge is EXACT only under recorded read provenance\n *\n * With `writeProvenance: 'reads-prefix'` on, the child write's\n * `TraceEntry.readKeys` names the keys read before it: this key IN that list\n * is an exact edge (`basis: 'per-write'`), and this key ABSENT from it is an\n * exact *exclusion* — no edge at all. With the dial off there is no such\n * evidence, only \"the stage read this and wrote that\": the edge is stamped\n * `basis: 'stage'` and the slice carries a `'conservative-fed-edges'` note.\n * A conservative edge is never presented as an exact one.\n *\n * Budgets mirror `causalChain`'s (maxDepth 20, maxNodes 100) and a cut is\n * STATED — `root.truncated` plus a `'truncated'` note.\n *\n * DAG position: memory ← slice. Imports memory/ only (see README.md).\n */\n\nimport type { KeysReadLookup } from '../memory/backtrack.js';\nimport type { CommitBundle } from '../memory/types.js';\nimport { DELIM } from '../memory/utils.js';\nimport {\n  type KeyIndex,\n  buildKeyIndex,\n  conservativeEdgesNote,\n  firstIndexAfter,\n  hasRecordedReads,\n  indicesInRange,\n  lastIndexBefore,\n  lastTraceEntry,\n  preRunOriginNote,\n  readsNotRecordedNote,\n  truncatedNote,\n  unknownKeyNote,\n  writtenPaths,\n} from './keyIndex.js';\nimport { resolveKeysReadSource } from './keysReadSources.js';\nimport { normaliseStateKey } from './sliceForKey.js';\nimport type { FedBasis, ForwardNode, ForwardSlice, HonestyNote, KeysReadSource, StateKey } from './types.js';\n\n/** Options for {@link forwardSliceForKey} — anchoring plus walk budgets. */\nexport interface ForwardSliceForKeyOptions {\n  /**\n   * Exclusive commit-array-index upper bound for the ANCHOR search: follow\n   * the value as it stood BEFORE this idx. Same contract as\n   * `sliceForKey`'s `before` / `findLastWriter`'s `beforeIdx`.\n   *\n   * It bounds the anchor ONLY — the walk then runs forward past it, because\n   * \"what did the value at step 12 go on to feed?\" is the whole question.\n   */\n  before?: number;\n  /** Maximum BFS depth in value-lives (default: 20 — causalChain's). */\n  maxDepth?: number;\n  /** Maximum total nodes (default: 100 — causalChain's). */\n  maxNodes?: number;\n}\n\n/** Identity of one value life: (write position, key). Never parsed. */\nfunction nodeKey(commitIdx: number | undefined, key: string): string {\n  return `${commitIdx ?? 'pre-run'}${DELIM}${key}`;\n}\n\n/**\n * Build the node for ONE value life. `writeIdx === undefined` is the pre-run\n * origin: the value was already there before the log's first write of the\n * key, so the writer identity fields stay ABSENT rather than fabricated.\n */\nfunction makeNode(\n  commitLog: CommitBundle[],\n  index: KeyIndex,\n  key: string,\n  writeIdx: number | undefined,\n  depth: number,\n): ForwardNode {\n  const writes = index.writesByKey.get(key);\n  if (writeIdx === undefined) {\n    const firstWrite = writes?.[0];\n    return {\n      key,\n      origin: 'pre-run',\n      ...(firstWrite !== undefined && { nextWriteIdx: firstWrite }),\n      depth,\n      reads: [],\n      fedEdges: [],\n    };\n  }\n  const bundle = commitLog[writeIdx];\n  const entry = lastTraceEntry(bundle, key);\n  const next = firstIndexAfter(writes, writeIdx);\n  return {\n    key,\n    origin: 'write',\n    runtimeStageId: bundle.runtimeStageId,\n    stageId: bundle.stageId,\n    stageName: bundle.stage,\n    commitIdx: writeIdx,\n    ...(entry !== undefined && { verb: entry.verb }),\n    ...(next !== undefined && { nextWriteIdx: next }),\n    depth,\n    reads: [],\n    fedEdges: [],\n    // Untracked-read honesty rides through from the bundle exactly as\n    // causalChain stamps CausalNode.incompleteSources.\n    ...(bundle.untrackedSources !== undefined &&\n      bundle.untrackedSources.length > 0 && { incompleteSources: bundle.untrackedSources }),\n  };\n}\n\n/**\n * Forward slice for one state key: who read this value, and what did it feed?\n *\n * @param commitLog Ordered commit bundles — `getSnapshot().commitLog`.\n * @param key A {@link StateKey}: the plain key string, or a path array\n *   (normalised through the SAME `normaliseStateKey` the backward door uses,\n *   so both doors accept identical inputs).\n * @param keysRead A {@link KeysReadSource} strategy or a bare lookup — the\n *   same reads providers `sliceForKey` takes. Reads are not in the commit\n *   log; without a provider a forward walk can see nothing, which the\n *   `'reads-not-recorded'` note says out loud.\n * @returns Always a {@link ForwardSlice}. Absence is a RESULT with a reason\n *   and, for an unknown key, a bounded list of the keys the log does know.\n */\nexport function forwardSliceForKey(\n  commitLog: CommitBundle[],\n  key: StateKey,\n  keysRead: KeysReadSource | KeysReadLookup,\n  options?: ForwardSliceForKeyOptions,\n): ForwardSlice {\n  const source = resolveKeysReadSource(keysRead);\n  const normalisedKey = normaliseStateKey(key);\n  const base: Pick<ForwardSlice, 'key' | 'before' | 'keysReadKind' | 'readsCoverage'> = {\n    key: normalisedKey,\n    ...(options?.before !== undefined && { before: options.before }),\n    keysReadKind: source.kind,\n    ...(source.coverage !== undefined && { readsCoverage: source.coverage }),\n  };\n\n  if (commitLog.length === 0) return { ...base, missing: 'empty-log', notes: [] };\n\n  const index = buildKeyIndex(commitLog, source.lookup);\n  const readsRecorded = hasRecordedReads(index);\n  const notes: HonestyNote[] = [];\n\n  // ── The typo guard, split by what the recording affords ────────────────\n  // Unknown key + reads ARE recorded → the log can see readers and this key\n  // has none: honest absence with a named reason, no fabricated life.\n  // Unknown key + NO reads recorded → a typo and a seeded-but-unread key are\n  // genuinely indistinguishable; the pre-run life below is the only honest\n  // answer, and it must carry BOTH notes so nobody reads it as \"unread\".\n  const known = index.knownKeys.has(normalisedKey);\n  if (!known) {\n    notes.push(unknownKeyNote(index, normalisedKey));\n    if (readsRecorded) return { ...base, missing: 'never-written', notes };\n  }\n  if (!readsRecorded) notes.push(readsNotRecordedNote());\n\n  const maxDepth = options?.maxDepth ?? 20;\n  const maxNodes = options?.maxNodes ?? 100;\n\n  const nodes = new Map<string, ForwardNode>();\n  let created = 0;\n  let truncatedByDepth = false;\n  let truncatedByNodes = false;\n  let anyConservative = false;\n\n  const anchorIdx = lastIndexBefore(index.writesByKey.get(normalisedKey), options?.before);\n  const root = makeNode(commitLog, index, normalisedKey, anchorIdx, 0);\n  nodes.set(nodeKey(anchorIdx, normalisedKey), root);\n  created = 1;\n\n  const queue: ForwardNode[] = [root];\n  while (queue.length > 0) {\n    const node = queue.shift()!;\n    // Live range: open below the write, CLOSED at the next write (see LAW).\n    const from = node.commitIdx !== undefined ? node.commitIdx + 1 : 0;\n    const readers = indicesInRange(index.readsByKey.get(node.key), from, node.nextWriteIdx);\n\n    if (node.depth >= maxDepth) {\n      // Only a life that still HAD readers to expand counts as a cut.\n      if (readers.length > 0) truncatedByDepth = true;\n      continue;\n    }\n\n    for (const readerIdx of readers) {\n      const bundle = commitLog[readerIdx];\n      node.reads.push({\n        runtimeStageId: bundle.runtimeStageId,\n        stageId: bundle.stageId,\n        stageName: bundle.stage,\n        commitIdx: readerIdx,\n      });\n\n      // The reader IS the writer of everything it committed — each written\n      // path is a candidate `fed` edge.\n      for (const path of writtenPaths(bundle)) {\n        const entry = lastTraceEntry(bundle, path);\n        let basis: FedBasis;\n        if (entry?.readKeys !== undefined) {\n          // EXACT both ways: recorded provenance can include or EXCLUDE.\n          if (!entry.readKeys.includes(node.key)) continue;\n          basis = 'per-write';\n        } else {\n          basis = 'stage';\n          anyConservative = true;\n        }\n\n        const id = nodeKey(readerIdx, path);\n        let child = nodes.get(id);\n        if (!child) {\n          if (created >= maxNodes) {\n            truncatedByNodes = true;\n            continue;\n          }\n          child = makeNode(commitLog, index, path, readerIdx, node.depth + 1);\n          nodes.set(id, child);\n          created++;\n          queue.push(child);\n        }\n        // One edge per distinct child life (a stage reads a key once).\n        if (!node.fedEdges.some((e) => e.child === child)) node.fedEdges.push({ child, basis });\n      }\n    }\n  }\n\n  // ── Honesty envelope, deterministic order ─────────────────────────────\n  if (root.origin === 'pre-run') notes.push(preRunOriginNote(normalisedKey));\n  if (anyConservative) notes.push(conservativeEdgesNote(normalisedKey));\n  if (truncatedByDepth || truncatedByNodes) {\n    root.truncated = { byDepth: truncatedByDepth, byNodes: truncatedByNodes };\n    notes.push(truncatedNote(truncatedByDepth, truncatedByNodes));\n  }\n\n  return {\n    ...base,\n    ...(anchorIdx !== undefined && { writer: commitLog[anchorIdx] }),\n    root,\n    notes,\n  };\n}\n"]}

package/dist/esm/lib/slice/index.d.ts

@@ -1,16 +1,25 @@
 /**
- * slice/ — variable-first backward slicing (the triage query layer).
+ * slice/ — variable-first slicing, both directions (the triage query layer).
  *
- * One question, one contract, every surface: "why is this VARIABLE what it
- * is?" — asked identically by UI panels (explainable-ui / lens), LLM triage
- * tools (trace toolpacks), and offline autopsy agents. See README.md for the
- * algorithms (thin-slice composition, append-fold provenance), the honesty
- * model, serialization rules, and the evolution path.
+ * One variable, one contract, every surface — asked identically by UI panels
+ * (explainable-ui / lens), LLM triage tools (trace toolpacks), and offline
+ * autopsy agents:
+ *
+ * - BACKWARD — "why is this VARIABLE what it is?" (`sliceForKey`,
+ *   `arrayProvenance` / `elementProvenance`).
+ * - FORWARD — "who READ it, and what did it FEED?" (`forwardSliceForKey`),
+ *   plus the flat chronological view (`keyTimeline`).
+ *
+ * See README.md for the algorithms (thin-slice composition, append-fold
+ * provenance, live-range walking), the honesty model, serialization rules,
+ * and the evolution path.
  *
  * DAG position: memory ← slice (leaf-adjacent; imports memory/ only).
  */
 export { arrayProvenance, elementProvenance } from './elementProvenance.js';
+export { type ForwardSliceForKeyOptions, forwardSliceForKey } from './forwardSliceForKey.js';
 export { keysReadFromExecutionTree, keysReadFromMap, resolveKeysReadSource } from './keysReadSources.js';
-export { formatSlice, sliceToJSON } from './serialize.js';
+export { type KeyTimelineOptions, keyTimeline } from './keyTimeline.js';
+export { formatForwardSlice, formatSlice, formatTimeline, forwardSliceToJSON, sliceToJSON } from './serialize.js';
 export { type SliceForKeyOptions, normaliseStateKey, sliceForKey } from './sliceForKey.js';
-export type { ArrayProvenance, AttributionBasis, ElementBirth, KeysReadSource, MissingProvenanceReason, MissingSliceReason, ReadsCoverage, SliceJSON, StateKey, VariableSlice, } from './types.js';
+export type { ArrayProvenance, AttributionBasis, ElementBirth, FedBasis, ForwardEdge, ForwardNode, ForwardRead, ForwardSlice, ForwardSliceJSON, HonestyNote, HonestyNoteCode, KeyMoment, KeysReadSource, KeyTimeline, MissingProvenanceReason, MissingSliceReason, ReadsCoverage, SliceJSON, StateKey, VariableSlice, } from './types.js';

package/dist/esm/lib/slice/index.js

@@ -1,16 +1,25 @@
 /**
- * slice/ — variable-first backward slicing (the triage query layer).
+ * slice/ — variable-first slicing, both directions (the triage query layer).
  *
- * One question, one contract, every surface: "why is this VARIABLE what it
- * is?" — asked identically by UI panels (explainable-ui / lens), LLM triage
- * tools (trace toolpacks), and offline autopsy agents. See README.md for the
- * algorithms (thin-slice composition, append-fold provenance), the honesty
- * model, serialization rules, and the evolution path.
+ * One variable, one contract, every surface — asked identically by UI panels
+ * (explainable-ui / lens), LLM triage tools (trace toolpacks), and offline
+ * autopsy agents:
+ *
+ * - BACKWARD — "why is this VARIABLE what it is?" (`sliceForKey`,
+ *   `arrayProvenance` / `elementProvenance`).
+ * - FORWARD — "who READ it, and what did it FEED?" (`forwardSliceForKey`),
+ *   plus the flat chronological view (`keyTimeline`).
+ *
+ * See README.md for the algorithms (thin-slice composition, append-fold
+ * provenance, live-range walking), the honesty model, serialization rules,
+ * and the evolution path.
  *
  * DAG position: memory ← slice (leaf-adjacent; imports memory/ only).
  */
 export { arrayProvenance, elementProvenance } from './elementProvenance.js';
+export { forwardSliceForKey } from './forwardSliceForKey.js';
 export { keysReadFromExecutionTree, keysReadFromMap, resolveKeysReadSource } from './keysReadSources.js';
-export { formatSlice, sliceToJSON } from './serialize.js';
+export { keyTimeline } from './keyTimeline.js';
+export { formatForwardSlice, formatSlice, formatTimeline, forwardSliceToJSON, sliceToJSON } from './serialize.js';
 export { normaliseStateKey, sliceForKey } from './sliceForKey.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3NsaWNlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7O0dBVUc7QUFFSCxPQUFPLEVBQUUsZUFBZSxFQUFFLGlCQUFpQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDNUUsT0FBTyxFQUFFLHlCQUF5QixFQUFFLGVBQWUsRUFBRSxxQkFBcUIsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ3pHLE9BQU8sRUFBRSxXQUFXLEVBQUUsV0FBVyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDMUQsT0FBTyxFQUEyQixpQkFBaUIsRUFBRSxXQUFXLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogc2xpY2UvIOKAlCB2YXJpYWJsZS1maXJzdCBiYWNrd2FyZCBzbGljaW5nICh0aGUgdHJpYWdlIHF1ZXJ5IGxheWVyKS5cbiAqXG4gKiBPbmUgcXVlc3Rpb24sIG9uZSBjb250cmFjdCwgZXZlcnkgc3VyZmFjZTogXCJ3aHkgaXMgdGhpcyBWQVJJQUJMRSB3aGF0IGl0XG4gKiBpcz9cIiDigJQgYXNrZWQgaWRlbnRpY2FsbHkgYnkgVUkgcGFuZWxzIChleHBsYWluYWJsZS11aSAvIGxlbnMpLCBMTE0gdHJpYWdlXG4gKiB0b29scyAodHJhY2UgdG9vbHBhY2tzKSwgYW5kIG9mZmxpbmUgYXV0b3BzeSBhZ2VudHMuIFNlZSBSRUFETUUubWQgZm9yIHRoZVxuICogYWxnb3JpdGhtcyAodGhpbi1zbGljZSBjb21wb3NpdGlvbiwgYXBwZW5kLWZvbGQgcHJvdmVuYW5jZSksIHRoZSBob25lc3R5XG4gKiBtb2RlbCwgc2VyaWFsaXphdGlvbiBydWxlcywgYW5kIHRoZSBldm9sdXRpb24gcGF0aC5cbiAqXG4gKiBEQUcgcG9zaXRpb246IG1lbW9yeSDihpAgc2xpY2UgKGxlYWYtYWRqYWNlbnQ7IGltcG9ydHMgbWVtb3J5LyBvbmx5KS5cbiAqL1xuXG5leHBvcnQgeyBhcnJheVByb3ZlbmFuY2UsIGVsZW1lbnRQcm92ZW5hbmNlIH0gZnJvbSAnLi9lbGVtZW50UHJvdmVuYW5jZS5qcyc7XG5leHBvcnQgeyBrZXlzUmVhZEZyb21FeGVjdXRpb25UcmVlLCBrZXlzUmVhZEZyb21NYXAsIHJlc29sdmVLZXlzUmVhZFNvdXJjZSB9IGZyb20gJy4va2V5c1JlYWRTb3VyY2VzLmpzJztcbmV4cG9ydCB7IGZvcm1hdFNsaWNlLCBzbGljZVRvSlNPTiB9IGZyb20gJy4vc2VyaWFsaXplLmpzJztcbmV4cG9ydCB7IHR5cGUgU2xpY2VGb3JLZXlPcHRpb25zLCBub3JtYWxpc2VTdGF0ZUtleSwgc2xpY2VGb3JLZXkgfSBmcm9tICcuL3NsaWNlRm9yS2V5LmpzJztcbmV4cG9ydCB0eXBlIHtcbiAgQXJyYXlQcm92ZW5hbmNlLFxuICBBdHRyaWJ1dGlvbkJhc2lzLFxuICBFbGVtZW50QmlydGgsXG4gIEtleXNSZWFkU291cmNlLFxuICBNaXNzaW5nUHJvdmVuYW5jZVJlYXNvbixcbiAgTWlzc2luZ1NsaWNlUmVhc29uLFxuICBSZWFkc0NvdmVyYWdlLFxuICBTbGljZUpTT04sXG4gIFN0YXRlS2V5LFxuICBWYXJpYWJsZVNsaWNlLFxufSBmcm9tICcuL3R5cGVzLmpzJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/slice/keyIndex.d.ts

@@ -0,0 +1,95 @@
+/**
+ * slice/keyIndex.ts — the one pass over the log both FORWARD queries share.
+ *
+ * WHY it exists: a backward slice only ever asks "who wrote key k before
+ * idx i" — `findLastWriter` answers that with a backward scan. A forward
+ * query asks the opposite, and the opposite is not symmetric: reads are NOT
+ * in the commit log, and `KeysReadSource` is a LOOKUP (runtimeStageId →
+ * keys), not an enumerable collection. So "who read k" cannot be looked up —
+ * it has to be inverted.
+ *
+ * THE INVERSION (and the law it rests on): the engine commits exactly ONE
+ * bundle per executed stage, so the commit log IS the list of execution
+ * steps. Calling the reads lookup once per bundle turns the strategy into a
+ * key → [commit indices that read it] index — and gives every read moment a
+ * commit position, the join key the whole library is addressed by.
+ *
+ * Consequence worth stating (documented, not silently absorbed): a reads
+ * provider naming a step that has no commit in THIS log contributes nothing.
+ * That is the same log↔reads pairing law the backward side has — a subflow
+ * runs in an isolated runtime, so its log and its tree must come from the
+ * same scope (see README.md § Subflow boundaries).
+ *
+ * Cost: one lookup call per bundle, once per query — O(N + total read keys).
+ * Both forward queries then run off sorted index arrays.
+ *
+ * DAG position: internal to slice/ (not exported from the barrel).
+ */
+import type { KeysReadLookup } from '../memory/backtrack.js';
+import type { CommitBundle, TraceEntry } from '../memory/types.js';
+import type { HonestyNote } from './types.js';
+/** How many known keys an unknown-key refusal lists before it says "+N more". */
+export declare const KNOWN_KEYS_LISTED = 10;
+/** The inverted view of one commit log + its reads provider. */
+export interface KeyIndex {
+    /** key → commit ARRAY positions that WROTE it, ascending. */
+    writesByKey: Map<string, number[]>;
+    /** key → commit ARRAY positions whose stage READ it, ascending. */
+    readsByKey: Map<string, number[]>;
+    /** Every key this log knows: written ∪ recorded-read. */
+    knownKeys: Set<string>;
+}
+/**
+ * Build the index. Indices go in ascending order by construction (we iterate
+ * the log forwards), which is what lets every range query below be a pair of
+ * binary searches instead of a scan.
+ */
+export declare function buildKeyIndex(commitLog: CommitBundle[], lookup: KeysReadLookup): KeyIndex;
+/**
+ * LAW — an unknown key is NAMED as unknown; it never renders as "no history".
+ *
+ * The failure this prevents: `forwardSliceForKey(log, 'recipId')` (typo) must
+ * not come back looking like a real variable that nothing happened to. The
+ * answer says so out loud AND lists the keys the log does know — bounded, so
+ * a 400-key agent state is a hint, not a wall.
+ *
+ * Why a NOTE and not a throw: the module's absence convention is a RESULT,
+ * not an exception (`VariableSlice.missing`) — one absence vocabulary across
+ * both doors. The loudness comes from the note + `missing: 'never-written'`,
+ * not from a stack trace a triage tool would have to catch.
+ */
+export declare function unknownKeyNote(index: KeyIndex, key: string): HonestyNote;
+/**
+ * Does this log carry ANY recorded read? The provider-agnostic version of
+ * `ReadsCoverage.stepsWithReads > 0` (map / custom-fn strategies carry no
+ * coverage), and the switch that decides whether "nobody read it" is a
+ * FINDING or a BLIND SPOT.
+ */
+export declare function hasRecordedReads(index: KeyIndex): boolean;
+/**
+ * Ascending indices in the INCLUSIVE range [from, to]. `to === undefined`
+ * means "to the end of the log".
+ */
+export declare function indicesInRange(sorted: number[] | undefined, from: number, to?: number): number[];
+/** The largest index in the ascending array that is < `before`, or undefined. */
+export declare function lastIndexBefore(sorted: number[] | undefined, before?: number): number | undefined;
+/** The smallest index in the ascending array that is > `after`, or undefined. */
+export declare function firstIndexAfter(sorted: number[] | undefined, after: number): number | undefined;
+/**
+ * The LAST trace entry for `path` in a bundle — the one that decides both the
+ * committed verb and (under the writeProvenance dial) the widest read prefix.
+ * Full mode can record several ops on one path in one commit; read prefixes
+ * only grow during a stage, so the last entry is the honest one to attribute
+ * with.
+ */
+export declare function lastTraceEntry(bundle: CommitBundle, path: string): TraceEntry | undefined;
+/** The `readTracking: 'off'` signature — see the HonestyNoteCode docs. */
+export declare function readsNotRecordedNote(): HonestyNote;
+/** The value predates every write this log can see. */
+export declare function preRunOriginNote(key: string): HonestyNote;
+/** At least one fed edge rests on stage-level co-occurrence only. */
+export declare function conservativeEdgesNote(key: string): HonestyNote;
+/** A budget cut the walk — stated, never silent. */
+export declare function truncatedNote(byDepth: boolean, byNodes: boolean): HonestyNote;
+/** Distinct written paths of a bundle, in first-touch order. */
+export declare function writtenPaths(bundle: CommitBundle): string[];