footprintjs 9.9.0 → 9.10.0

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

@@ -0,0 +1,40 @@
+/**
+ * slice/serialize.ts — JSON-safe and LLM-safe projections of a slice.
+ *
+ * WHY (the failure this prevents): `VariableSlice.root` is an in-memory DAG.
+ * Nodes are SHARED — a diamond ancestor is one object reached through many
+ * paths, and each node appears in both `parents` and `parentEdges[].parent`.
+ * `JSON.stringify` knows nothing about sharing: it re-serializes every shared
+ * subtree per path, which explodes combinatorially on diamond-heavy slices.
+ * The two consumers that would naively stringify are exactly the ones this
+ * library exists for — wire transfer (persist / send a slice) and LLM tools
+ * (bounded context). Each gets a purpose-built projection:
+ *
+ * - {@link sliceToJSON}   — flat, id-referenced, LINEAR in node count.
+ * - {@link formatSlice}   — one bounded human/LLM-readable string that also
+ *   renders the honesty envelope (missing reason, reads coverage, truncation)
+ *   a raw `formatCausalChain` doesn't know about.
+ */
+import type { SliceJSON, VariableSlice } from './types.js';
+/**
+ * Flat, JSON-safe projection: every DAG node exactly once (keyed by
+ * runtimeStageId), edges as id references. Linear in node count — safe to
+ * persist, send, or feed to structured consumers. Lossless for everything
+ * except the in-memory object graph itself (rebuild adjacency from `edges`).
+ */
+export declare function sliceToJSON(slice: VariableSlice): SliceJSON;
+/**
+ * One bounded string for LLM triage tools (the `traceToolpack` consumption
+ * pattern: tools return plain strings, never recursive objects). Wraps
+ * `formatCausalChain` (which is budget-bounded by causalChain's
+ * maxDepth/maxNodes and renders shared nodes once as `↳ … (see above)`),
+ * and adds the honesty envelope the raw chain doesn't carry:
+ *
+ * - missing slices render their reason ("value came from initial state /
+ *   frozen args / a closure — the commit log cannot see those"),
+ * - a reads-less provider (`readTracking: 'off'` signature) renders an
+ *   explicit "⚠ reads were not recorded" instead of silently showing an
+ *   anchor with no dependencies,
+ * - truncation footers pass through from formatCausalChain.
+ */
+export declare function formatSlice(slice: VariableSlice): string;

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

@@ -0,0 +1,97 @@
+/**
+ * slice/serialize.ts — JSON-safe and LLM-safe projections of a slice.
+ *
+ * WHY (the failure this prevents): `VariableSlice.root` is an in-memory DAG.
+ * Nodes are SHARED — a diamond ancestor is one object reached through many
+ * paths, and each node appears in both `parents` and `parentEdges[].parent`.
+ * `JSON.stringify` knows nothing about sharing: it re-serializes every shared
+ * subtree per path, which explodes combinatorially on diamond-heavy slices.
+ * The two consumers that would naively stringify are exactly the ones this
+ * library exists for — wire transfer (persist / send a slice) and LLM tools
+ * (bounded context). Each gets a purpose-built projection:
+ *
+ * - {@link sliceToJSON}   — flat, id-referenced, LINEAR in node count.
+ * - {@link formatSlice}   — one bounded human/LLM-readable string that also
+ *   renders the honesty envelope (missing reason, reads coverage, truncation)
+ *   a raw `formatCausalChain` doesn't know about.
+ */
+import { flattenCausalDAG, formatCausalChain } from '../memory/backtrack.js';
+/**
+ * Flat, JSON-safe projection: every DAG node exactly once (keyed by
+ * runtimeStageId), edges as id references. Linear in node count — safe to
+ * persist, send, or feed to structured consumers. Lossless for everything
+ * except the in-memory object graph itself (rebuild adjacency from `edges`).
+ */
+export function sliceToJSON(slice) {
+    const out = {
+        key: slice.key,
+        ...(slice.before !== undefined && { before: slice.before }),
+        ...(slice.missing !== undefined && { missing: slice.missing }),
+        keysReadKind: slice.keysReadKind,
+        ...(slice.readsCoverage !== undefined && { readsCoverage: slice.readsCoverage }),
+    };
+    if (!slice.root)
+        return out;
+    out.writerId = slice.root.runtimeStageId;
+    const nodes = {};
+    const edges = [];
+    for (const node of flattenCausalDAG(slice.root)) {
+        nodes[node.runtimeStageId] = {
+            stageId: node.stageId,
+            stageName: node.stageName,
+            keysWritten: node.keysWritten,
+            depth: node.depth,
+            ...(node.incompleteSources !== undefined && { incompleteSources: node.incompleteSources }),
+        };
+        for (const edge of node.parentEdges) {
+            edges.push({
+                from: node.runtimeStageId,
+                to: edge.parent.runtimeStageId,
+                kind: edge.kind,
+                ...(edge.key !== undefined && { key: edge.key }),
+                weight: edge.weight,
+            });
+        }
+    }
+    out.nodes = nodes;
+    out.edges = edges;
+    if (slice.root.truncated)
+        out.truncated = slice.root.truncated;
+    return out;
+}
+/**
+ * One bounded string for LLM triage tools (the `traceToolpack` consumption
+ * pattern: tools return plain strings, never recursive objects). Wraps
+ * `formatCausalChain` (which is budget-bounded by causalChain's
+ * maxDepth/maxNodes and renders shared nodes once as `↳ … (see above)`),
+ * and adds the honesty envelope the raw chain doesn't carry:
+ *
+ * - missing slices render their reason ("value came from initial state /
+ *   frozen args / a closure — the commit log cannot see those"),
+ * - a reads-less provider (`readTracking: 'off'` signature) renders an
+ *   explicit "⚠ reads were not recorded" instead of silently showing an
+ *   anchor with no dependencies,
+ * - truncation footers pass through from formatCausalChain.
+ */
+export function formatSlice(slice) {
+    const lines = [];
+    const anchor = slice.before !== undefined ? ` (before commit ${slice.before})` : '';
+    lines.push(`SLICE for '${slice.key}'${anchor} — reads via: ${slice.keysReadKind}`);
+    if (slice.missing === 'empty-log') {
+        lines.push('no slice: the commit log is empty (nothing has executed).');
+        return lines.join('\n');
+    }
+    if (slice.missing === 'never-written') {
+        lines.push(`no slice: '${slice.key}' was never written in range — the value came from ` +
+            'initial state, frozen run input (args), or a closure; the commit log cannot see those.');
+        return lines.join('\n');
+    }
+    const cov = slice.readsCoverage;
+    if (cov && cov.steps > 1 && cov.stepsWithReads === 0) {
+        lines.push("⚠ reads were not recorded (readTracking may be 'off') — dependencies below are " + 'unknowable, NOT absent.');
+    }
+    if (slice.root)
+        lines.push(formatCausalChain(slice.root));
+    return lines.join('\n');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"serialize.js","sourceRoot":"","sources":["../../../../src/lib/slice/serialize.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * slice/serialize.ts — JSON-safe and LLM-safe projections of a slice.\n *\n * WHY (the failure this prevents): `VariableSlice.root` is an in-memory DAG.\n * Nodes are SHARED — a diamond ancestor is one object reached through many\n * paths, and each node appears in both `parents` and `parentEdges[].parent`.\n * `JSON.stringify` knows nothing about sharing: it re-serializes every shared\n * subtree per path, which explodes combinatorially on diamond-heavy slices.\n * The two consumers that would naively stringify are exactly the ones this\n * library exists for — wire transfer (persist / send a slice) and LLM tools\n * (bounded context). Each gets a purpose-built projection:\n *\n * - {@link sliceToJSON}   — flat, id-referenced, LINEAR in node count.\n * - {@link formatSlice}   — one bounded human/LLM-readable string that also\n *   renders the honesty envelope (missing reason, reads coverage, truncation)\n *   a raw `formatCausalChain` doesn't know about.\n */\n\nimport { flattenCausalDAG, formatCausalChain } from '../memory/backtrack.js';\nimport type { SliceJSON, VariableSlice } from './types.js';\n\n/**\n * Flat, JSON-safe projection: every DAG node exactly once (keyed by\n * runtimeStageId), edges as id references. Linear in node count — safe to\n * persist, send, or feed to structured consumers. Lossless for everything\n * except the in-memory object graph itself (rebuild adjacency from `edges`).\n */\nexport function sliceToJSON(slice: VariableSlice): SliceJSON {\n  const out: SliceJSON = {\n    key: slice.key,\n    ...(slice.before !== undefined && { before: slice.before }),\n    ...(slice.missing !== undefined && { missing: slice.missing }),\n    keysReadKind: slice.keysReadKind,\n    ...(slice.readsCoverage !== undefined && { readsCoverage: slice.readsCoverage }),\n  };\n  if (!slice.root) return out;\n\n  out.writerId = slice.root.runtimeStageId;\n  const nodes: NonNullable<SliceJSON['nodes']> = {};\n  const edges: NonNullable<SliceJSON['edges']> = [];\n  for (const node of flattenCausalDAG(slice.root)) {\n    nodes[node.runtimeStageId] = {\n      stageId: node.stageId,\n      stageName: node.stageName,\n      keysWritten: node.keysWritten,\n      depth: node.depth,\n      ...(node.incompleteSources !== undefined && { incompleteSources: node.incompleteSources }),\n    };\n    for (const edge of node.parentEdges) {\n      edges.push({\n        from: node.runtimeStageId,\n        to: edge.parent.runtimeStageId,\n        kind: edge.kind,\n        ...(edge.key !== undefined && { key: edge.key }),\n        weight: edge.weight,\n      });\n    }\n  }\n  out.nodes = nodes;\n  out.edges = edges;\n  if (slice.root.truncated) out.truncated = slice.root.truncated;\n  return out;\n}\n\n/**\n * One bounded string for LLM triage tools (the `traceToolpack` consumption\n * pattern: tools return plain strings, never recursive objects). Wraps\n * `formatCausalChain` (which is budget-bounded by causalChain's\n * maxDepth/maxNodes and renders shared nodes once as `↳ … (see above)`),\n * and adds the honesty envelope the raw chain doesn't carry:\n *\n * - missing slices render their reason (\"value came from initial state /\n *   frozen args / a closure — the commit log cannot see those\"),\n * - a reads-less provider (`readTracking: 'off'` signature) renders an\n *   explicit \"⚠ reads were not recorded\" instead of silently showing an\n *   anchor with no dependencies,\n * - truncation footers pass through from formatCausalChain.\n */\nexport function formatSlice(slice: VariableSlice): string {\n  const lines: string[] = [];\n  const anchor = slice.before !== undefined ? ` (before commit ${slice.before})` : '';\n  lines.push(`SLICE for '${slice.key}'${anchor} — reads via: ${slice.keysReadKind}`);\n\n  if (slice.missing === 'empty-log') {\n    lines.push('no slice: the commit log is empty (nothing has executed).');\n    return lines.join('\\n');\n  }\n  if (slice.missing === 'never-written') {\n    lines.push(\n      `no slice: '${slice.key}' was never written in range — the value came from ` +\n        'initial state, frozen run input (args), or a closure; the commit log cannot see those.',\n    );\n    return lines.join('\\n');\n  }\n\n  const cov = slice.readsCoverage;\n  if (cov && cov.steps > 1 && cov.stepsWithReads === 0) {\n    lines.push(\n      \"⚠ reads were not recorded (readTracking may be 'off') — dependencies below are \" + 'unknowable, NOT absent.',\n    );\n  }\n  if (slice.root) lines.push(formatCausalChain(slice.root));\n  return lines.join('\\n');\n}\n"]}

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

@@ -0,0 +1,47 @@
+/**
+ * slice/sliceForKey.ts — the variable-first backward slice query.
+ *
+ * "Why is `key` what it is?" — the ONE question every triage surface asks:
+ * a human clicking a key in explainable-ui, an LLM calling a `backtrack`
+ * tool mid-conversation, an offline autopsy agent over a stored run.
+ *
+ * WHY this is deliberately a composition and not a new algorithm:
+ * `findLastWriter` already answers "who made the value what it is" and
+ * `causalChain` already answers "what influenced that step" (thin backward
+ * slicing, Weiser 1984). What was missing is the shared CONTRACT — without
+ * it, every surface hand-rolls the anchor step differently and their answers
+ * disagree. The value of this function is that they can't.
+ */
+import { type CausalChainOptions, type KeysReadLookup } from '../memory/backtrack.js';
+import type { CommitBundle } from '../memory/types.js';
+import type { KeysReadSource, StateKey, VariableSlice } from './types.js';
+/**
+ * Normalise a consumer-facing {@link StateKey} to the engine's canonical
+ * string form (the `TraceEntry.path` space). Path arrays go through the same
+ * normaliser the engine writes with — the delimiter never leaks into the
+ * public contract.
+ */
+export declare function normaliseStateKey(key: StateKey): string;
+/** Options for {@link sliceForKey} — causalChain's options plus anchoring. */
+export interface SliceForKeyOptions extends CausalChainOptions {
+    /**
+     * Exclusive commit-array-index upper bound: slice the value as it stood
+     * BEFORE this idx (time-travel triage — "why was it X at step 12?").
+     * Same contract as `findLastWriter`'s `beforeIdx`. Omit for the current
+     * value. Chained-triage idiom: to slice at an {@link ElementBirth}, pass
+     * `before: birth.commitIdx + 1` (birth idx is inclusive, this bound is
+     * exclusive — the +1 makes the birth commit itself the anchor).
+     */
+    before?: number;
+}
+/**
+ * Backward slice for one state key: anchor at the key's last writer, then
+ * walk read→write (and optional control) dependencies transitively.
+ *
+ * Honest-absence contract: a missing slice is a RESULT, not an error —
+ * `missing: 'never-written'` tells a triage tool (or its LLM caller) that
+ * the value came from initial state / frozen args / a closure, which is
+ * itself diagnostic information. See {@link VariableSlice} — including its
+ * SERIALIZATION WARNING before you stringify the result.
+ */
+export declare function sliceForKey(commitLog: CommitBundle[], key: StateKey, keysRead: KeysReadSource | KeysReadLookup, options?: SliceForKeyOptions): VariableSlice;

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

@@ -0,0 +1,72 @@
+/**
+ * slice/sliceForKey.ts — the variable-first backward slice query.
+ *
+ * "Why is `key` what it is?" — the ONE question every triage surface asks:
+ * a human clicking a key in explainable-ui, an LLM calling a `backtrack`
+ * tool mid-conversation, an offline autopsy agent over a stored run.
+ *
+ * WHY this is deliberately a composition and not a new algorithm:
+ * `findLastWriter` already answers "who made the value what it is" and
+ * `causalChain` already answers "what influenced that step" (thin backward
+ * slicing, Weiser 1984). What was missing is the shared CONTRACT — without
+ * it, every surface hand-rolls the anchor step differently and their answers
+ * disagree. The value of this function is that they can't.
+ */
+import { causalChain } from '../memory/backtrack.js';
+import { findLastWriter } from '../memory/commitLogUtils.js';
+import { normalisePath } from '../memory/utils.js';
+import { resolveKeysReadSource } from './keysReadSources.js';
+/**
+ * Normalise a consumer-facing {@link StateKey} to the engine's canonical
+ * string form (the `TraceEntry.path` space). Path arrays go through the same
+ * normaliser the engine writes with — the delimiter never leaks into the
+ * public contract.
+ */
+export function normaliseStateKey(key) {
+    return typeof key === 'string' ? key : normalisePath([...key]);
+}
+/**
+ * Backward slice for one state key: anchor at the key's last writer, then
+ * walk read→write (and optional control) dependencies transitively.
+ *
+ * Honest-absence contract: a missing slice is a RESULT, not an error —
+ * `missing: 'never-written'` tells a triage tool (or its LLM caller) that
+ * the value came from initial state / frozen args / a closure, which is
+ * itself diagnostic information. See {@link VariableSlice} — including its
+ * SERIALIZATION WARNING before you stringify the result.
+ */
+export function sliceForKey(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' };
+    const writer = findLastWriter(commitLog, normalisedKey, options?.before);
+    if (!writer)
+        return { ...base, missing: 'never-written' };
+    // INVARIANT: `writer` came FROM this commitLog, so its runtimeStageId is
+    // always present in causalChain's index — causalChain cannot return
+    // undefined here (it only does for ids absent from the log). The non-null
+    // assertion keeps the VariableSlice contract airtight: `missing` is the
+    // ONLY absent-root state. Options pass straight through (controlDeps /
+    // weigh / maxDepth / maxNodes keep their causalChain semantics).
+    //
+    // edgeAttribution defaults to 'per-write' HERE (unlike causalChain's
+    // 'stage' default): a variable-first slice knows exactly which written key
+    // anchors the question, and per-write attribution is strictly-safe — logs
+    // without `TraceEntry.readKeys` (the writeProvenance dial off) fall back
+    // to stage-level expansion per node, byte-identically. Consumers can force
+    // 'stage' via options.
+    const root = causalChain(commitLog, writer.runtimeStageId, source.lookup, {
+        ...options,
+        edgeAttribution: options?.edgeAttribution ?? 'per-write',
+        rootLinkKeys: options?.rootLinkKeys ?? [normalisedKey],
+    });
+    return { ...base, writer, root };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sliceForKey.js","sourceRoot":"","sources":["../../../../src/lib/slice/sliceForKey.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAgD,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACnG,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAE7D,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAG7D;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAAC,GAAa;IAC7C,OAAO,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;AACjE,CAAC;AAeD;;;;;;;;;GASG;AACH,MAAM,UAAU,WAAW,CACzB,SAAyB,EACzB,GAAa,EACb,QAAyC,EACzC,OAA4B;IAE5B,MAAM,MAAM,GAAG,qBAAqB,CAAC,QAAQ,CAAC,CAAC;IAC/C,MAAM,aAAa,GAAG,iBAAiB,CAAC,GAAG,CAAC,CAAC;IAC7C,MAAM,IAAI,GAA6E;QACrF,GAAG,EAAE,aAAa;QAClB,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,SAAS,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC;QAChE,YAAY,EAAE,MAAM,CAAC,IAAI;QACzB,GAAG,CAAC,MAAM,CAAC,QAAQ,KAAK,SAAS,IAAI,EAAE,aAAa,EAAE,MAAM,CAAC,QAAQ,EAAE,CAAC;KACzE,CAAC;IAEF,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,CAAC;IAErE,MAAM,MAAM,GAAG,cAAc,CAAC,SAAS,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;IACzE,IAAI,CAAC,MAAM;QAAE,OAAO,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,eAAe,EAAE,CAAC;IAE1D,yEAAyE;IACzE,oEAAoE;IACpE,0EAA0E;IAC1E,wEAAwE;IACxE,uEAAuE;IACvE,iEAAiE;IACjE,EAAE;IACF,qEAAqE;IACrE,2EAA2E;IAC3E,0EAA0E;IAC1E,yEAAyE;IACzE,2EAA2E;IAC3E,uBAAuB;IACvB,MAAM,IAAI,GAAG,WAAW,CAAC,SAAS,EAAE,MAAM,CAAC,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE;QACxE,GAAG,OAAO;QACV,eAAe,EAAE,OAAO,EAAE,eAAe,IAAI,WAAW;QACxD,YAAY,EAAE,OAAO,EAAE,YAAY,IAAI,CAAC,aAAa,CAAC;KACvD,CAAE,CAAC;IACJ,OAAO,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;AACnC,CAAC","sourcesContent":["/**\n * slice/sliceForKey.ts — the variable-first backward slice query.\n *\n * \"Why is `key` what it is?\" — the ONE question every triage surface asks:\n * a human clicking a key in explainable-ui, an LLM calling a `backtrack`\n * tool mid-conversation, an offline autopsy agent over a stored run.\n *\n * WHY this is deliberately a composition and not a new algorithm:\n * `findLastWriter` already answers \"who made the value what it is\" and\n * `causalChain` already answers \"what influenced that step\" (thin backward\n * slicing, Weiser 1984). What was missing is the shared CONTRACT — without\n * it, every surface hand-rolls the anchor step differently and their answers\n * disagree. The value of this function is that they can't.\n */\n\nimport { type CausalChainOptions, type KeysReadLookup, causalChain } from '../memory/backtrack.js';\nimport { findLastWriter } from '../memory/commitLogUtils.js';\nimport type { CommitBundle } from '../memory/types.js';\nimport { normalisePath } from '../memory/utils.js';\nimport { resolveKeysReadSource } from './keysReadSources.js';\nimport type { KeysReadSource, StateKey, VariableSlice } from './types.js';\n\n/**\n * Normalise a consumer-facing {@link StateKey} to the engine's canonical\n * string form (the `TraceEntry.path` space). Path arrays go through the same\n * normaliser the engine writes with — the delimiter never leaks into the\n * public contract.\n */\nexport function normaliseStateKey(key: StateKey): string {\n  return typeof key === 'string' ? key : normalisePath([...key]);\n}\n\n/** Options for {@link sliceForKey} — causalChain's options plus anchoring. */\nexport interface SliceForKeyOptions extends CausalChainOptions {\n  /**\n   * Exclusive commit-array-index upper bound: slice the value as it stood\n   * BEFORE this idx (time-travel triage — \"why was it X at step 12?\").\n   * Same contract as `findLastWriter`'s `beforeIdx`. Omit for the current\n   * value. Chained-triage idiom: to slice at an {@link ElementBirth}, pass\n   * `before: birth.commitIdx + 1` (birth idx is inclusive, this bound is\n   * exclusive — the +1 makes the birth commit itself the anchor).\n   */\n  before?: number;\n}\n\n/**\n * Backward slice for one state key: anchor at the key's last writer, then\n * walk read→write (and optional control) dependencies transitively.\n *\n * Honest-absence contract: a missing slice is a RESULT, not an error —\n * `missing: 'never-written'` tells a triage tool (or its LLM caller) that\n * the value came from initial state / frozen args / a closure, which is\n * itself diagnostic information. See {@link VariableSlice} — including its\n * SERIALIZATION WARNING before you stringify the result.\n */\nexport function sliceForKey(\n  commitLog: CommitBundle[],\n  key: StateKey,\n  keysRead: KeysReadSource | KeysReadLookup,\n  options?: SliceForKeyOptions,\n): VariableSlice {\n  const source = resolveKeysReadSource(keysRead);\n  const normalisedKey = normaliseStateKey(key);\n  const base: Pick<VariableSlice, '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' };\n\n  const writer = findLastWriter(commitLog, normalisedKey, options?.before);\n  if (!writer) return { ...base, missing: 'never-written' };\n\n  // INVARIANT: `writer` came FROM this commitLog, so its runtimeStageId is\n  // always present in causalChain's index — causalChain cannot return\n  // undefined here (it only does for ids absent from the log). The non-null\n  // assertion keeps the VariableSlice contract airtight: `missing` is the\n  // ONLY absent-root state. Options pass straight through (controlDeps /\n  // weigh / maxDepth / maxNodes keep their causalChain semantics).\n  //\n  // edgeAttribution defaults to 'per-write' HERE (unlike causalChain's\n  // 'stage' default): a variable-first slice knows exactly which written key\n  // anchors the question, and per-write attribution is strictly-safe — logs\n  // without `TraceEntry.readKeys` (the writeProvenance dial off) fall back\n  // to stage-level expansion per node, byte-identically. Consumers can force\n  // 'stage' via options.\n  const root = causalChain(commitLog, writer.runtimeStageId, source.lookup, {\n    ...options,\n    edgeAttribution: options?.edgeAttribution ?? 'per-write',\n    rootLinkKeys: options?.rootLinkKeys ?? [normalisedKey],\n  })!;\n  return { ...base, writer, root };\n}\n"]}

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

@@ -0,0 +1,240 @@
+/**
+ * slice/types.ts — data shapes of the variable-first slicing layer.
+ *
+ * WHY THIS LIBRARY EXISTS (context for future readers, human or LLM):
+ * `causalChain()` (memory/backtrack.ts) answers "what influenced this STEP?"
+ * — its address space is runtimeStageIds. But every triage consumer starts
+ * from a VARIABLE: a human clicks the key `creditTier` in a UI; an LLM tool
+ * call asks "where did history[7] come from?". This library is the address
+ * translation layer: variable in → slice out. It deliberately adds NO new
+ * capture and NO new graph algorithm — it composes the commit-log primitives
+ * (findLastWriter / causalChain / the per-key verb fold) so every surface
+ * (UI panel, LLM tool, offline autopsy agent) asks the question the same way
+ * and gets the same, honestly-labeled answer.
+ *
+ * DAG position: memory ← slice. This module may import ONLY from memory/.
+ * Recorders, engine, and runner must never be imported here — that is what
+ * keeps it a tiny, separately-evolvable library (see README.md).
+ */
+import type { CausalNode, KeysReadLookup } from '../memory/backtrack.js';
+import type { CommitBundle, TraceEntry, UntrackedSource } from '../memory/types.js';
+/**
+ * A state key as consumers know it: either the plain top-level key string, or
+ * a path array for nested keys (`['customer', 'address']`). Path arrays are
+ * normalised internally — the engine's path delimiter never appears in this
+ * public contract.
+ */
+export type StateKey = string | ReadonlyArray<string | number>;
+/**
+ * STRATEGY INTERFACE: where per-stage read keys come from. THE canonical
+ * strategy list lives here (implementations in keysReadSources.ts):
+ *
+ * Reads are deliberately NOT in the commit log (CommitBundle carries only the
+ * `untrackedSources` honesty flags), so a slice needs a reads provider. There
+ * are several legitimate providers with different trade-offs, and new ones
+ * will appear — hence an interface rather than a hardcoded path:
+ *
+ * - `keysReadFromExecutionTree` — post-hoc, ZERO setup: reads live in the
+ *   snapshot's `StageSnapshot.stageReads` whenever `readTracking` ≠ 'off'
+ *   (default 'full'; 'summary' still keeps the keys). Use when you have a
+ *   finished run's snapshot.
+ * - `keysReadFromMap` — a prebuilt Map/object, e.g. collected live from
+ *   `ScopeRecorder.onRead` events or deserialized from a stored trace.
+ * - a bare `KeysReadLookup` function — anything else (e.g. QualityRecorder:
+ *   `(id) => rec.getByKey(id)?.keysRead ?? []`). Wrapped as kind 'custom-fn'.
+ *
+ * `kind` is a debugging/honesty breadcrumb: `VariableSlice.keysReadKind`
+ * records which strategy produced the slice, so a surprising slice can be
+ * traced back to its reads provider.
+ */
+export interface KeysReadSource {
+    /** Discriminator surfaced on {@link VariableSlice.keysReadKind}. */
+    readonly kind: string;
+    /** The lookup `causalChain` will call per visited node. */
+    readonly lookup: KeysReadLookup;
+    /**
+     * OPTIONAL honesty telemetry a strategy can compute while it builds:
+     * how many execution steps it saw, and how many actually had read entries.
+     * `stepsWithReads === 0` over a multi-step run is the machine-detectable
+     * signature of `readTracking: 'off'` — WITHOUT this, a reads-less slice is
+     * indistinguishable from "genuinely no upstream dependencies", which is a
+     * lie a triage tool must never tell. Copied onto
+     * {@link VariableSlice.readsCoverage}.
+     */
+    readonly coverage?: ReadsCoverage;
+}
+/** See {@link KeysReadSource.coverage}. */
+export interface ReadsCoverage {
+    /** Execution steps the strategy saw (nodes with a runtimeStageId). */
+    readonly steps: number;
+    /** Of those, steps that had at least one recorded read key. */
+    readonly stepsWithReads: number;
+}
+/**
+ * Why a slice could not be produced. Honest absence is a first-class result:
+ * - `'empty-log'`     — there are no commits at all (run never executed, or
+ *   snapshot came from elsewhere).
+ * - `'never-written'` — no commit in range wrote `key`. The value (if any)
+ *   came from the run's INITIAL state, run `input` (frozen args channel), or
+ *   a closure — none of which the commit log can see. Same blind spot as
+ *   `findLastWriter`.
+ */
+export type MissingSliceReason = 'empty-log' | 'never-written';
+/**
+ * The result of a variable-first backward slice: "why is `key` what it is?".
+ *
+ * Anchoring rule: the slice is rooted at the LAST writer of `key` (before
+ * `before`, when given) — the commit that made the value what it currently
+ * is. Everything upstream of that writer is reached through the causal DAG.
+ *
+ * SERIALIZATION WARNING: `root` is an in-memory DAG — nodes appear in BOTH
+ * `parents` and `parentEdges[].parent`, and shared ancestors (diamonds) are
+ * the same object reached through many paths. `JSON.stringify(slice)`
+ * duplicates every shared subtree per path and explodes combinatorially.
+ * Never stringify it: use `sliceToJSON()` (flat, id-referenced, linear) for
+ * wire transfer or `formatSlice()` (bounded string) for LLM tools.
+ */
+export interface VariableSlice {
+    /** The state key that was asked about (normalised string form). */
+    key: string;
+    /**
+     * Exclusive commit-array-index upper bound the writer search was anchored
+     * at ("as it stood before this idx"). Undefined = the whole log (current
+     * value).
+     */
+    before?: number;
+    /** The commit that last wrote `key` — the slice anchor. Absent when missing. */
+    writer?: CommitBundle;
+    /**
+     * The backward causal DAG rooted at the writer (same `CausalNode` shape as
+     * `causalChain` — parentEdges carry keyed data/control edges, honesty via
+     * `incompleteSources`/`truncated`). Absent when missing. See the
+     * serialization warning on this interface before stringifying.
+     */
+    root?: CausalNode;
+    /** Present ONLY when `root` is absent — why there is no slice. */
+    missing?: MissingSliceReason;
+    /** Which {@link KeysReadSource} strategy resolved reads (honesty/debug). */
+    keysReadKind: string;
+    /**
+     * Honesty telemetry copied from the strategy when it provides one — see
+     * {@link KeysReadSource.coverage}. A root with no parents AND
+     * `stepsWithReads === 0` means "reads were not recorded", NOT "no
+     * dependencies"; triage tools must say so.
+     */
+    readsCoverage?: ReadsCoverage;
+}
+/**
+ * How an element's birth commit was determined — the honesty axis of
+ * append-fold provenance. Ordered strongest → weakest:
+ *
+ * - `'append-verb'`      — the engine RECORDED this tail append
+ *   (`commitValues: 'delta'`). Exact by construction.
+ * - `'prefix-inference'` — a full-value write preserved the previous array as
+ *   a strict prefix, so the new tail is attributed to this commit. Heuristic:
+ *   a writer that REPLACED the array with one that happens to share the old
+ *   prefix is indistinguishable from an append. Right in practice (push-style
+ *   growth), labeled honestly so consumers can tell.
+ * - `'whole-value'`      — the array was (re)placed wholesale; every
+ *   element's provenance resets to this commit. Exact but coarse.
+ */
+export type AttributionBasis = 'append-verb' | 'prefix-inference' | 'whole-value';
+/**
+ * The birth record of ONE array element: which commit (and therefore which
+ * stage execution) first put it there. This is what turns the agent
+ * mega-key problem ("everything depends on `history`") into element-level
+ * answers ("history[7] was appended by tool-calls#41 in iteration 3").
+ *
+ * @see elementProvenance — the query that returns this record.
+ */
+export interface ElementBirth {
+    /** Element index in the reconstructed array at query time. */
+    index: number;
+    /** Commit ARRAY position (the `CommitBundle.idx` space) of the birth. */
+    commitIdx: number;
+    /** Execution step that wrote it — joins to slices, recorders, UIs. */
+    runtimeStageId: string;
+    /** Stable stage identifier of the writer. */
+    stageId: string;
+    /** Human-readable stage name of the writer. */
+    stageName: string;
+    /** The trace verb of the birth commit's entry for this key. */
+    verb: TraceEntry['verb'];
+    /** How the attribution was determined — see {@link AttributionBasis}. */
+    basis: AttributionBasis;
+    /**
+     * The element's value as of the fold (detached clone). Redaction note:
+     * values are re-served exactly as the commit log stored them — a redacted
+     * key's `'[REDACTED]'` placeholder stays redacted; this layer never
+     * resurrects originals.
+     */
+    value: unknown;
+}
+/**
+ * Why element provenance could not be produced (mirrors
+ * {@link MissingSliceReason} — one honest-absence pattern module-wide):
+ * - `'empty-log'`     — no commits at all.
+ * - `'never-written'` — no commit in range touched the key.
+ * - `'not-an-array'`  — the key WAS written but its folded value is not an
+ *   array at the queried point: a scalar/object key, a deleted key, or a
+ *   merge that degraded it. Element provenance is an array concept — for
+ *   scalar keys the right query is `sliceForKey`.
+ */
+export type MissingProvenanceReason = 'empty-log' | 'never-written' | 'not-an-array';
+/**
+ * Element-level provenance for one array-valued key. Mirrors
+ * {@link VariableSlice}'s honest-absence shape: on success `atIdx`/`length`/
+ * `births` are set; otherwise `missing` says why (present ONLY when `births`
+ * is absent).
+ *
+ * @see arrayProvenance — the query that returns this.
+ * @see ElementBirth — one record per element, index-aligned.
+ */
+export interface ArrayProvenance {
+    /** The state key (normalised string form). */
+    key: string;
+    /** Inclusive commit array idx the fold ran to. Absent when missing. */
+    atIdx?: number;
+    /** Length of the reconstructed array (births.length === length). */
+    length?: number;
+    /** One birth per element, index-aligned with the reconstructed array. */
+    births?: ElementBirth[];
+    /** Present ONLY when `births` is absent — why there is no provenance. */
+    missing?: MissingProvenanceReason;
+}
+/**
+ * Flat, id-referenced, JSON-safe projection of a {@link VariableSlice} —
+ * linear in node count (each node serialized exactly once; edges reference
+ * ids). THE shape to persist, send over the wire, or hand to structured
+ * consumers. See the serialization warning on {@link VariableSlice}.
+ */
+export interface SliceJSON {
+    key: string;
+    before?: number;
+    missing?: MissingSliceReason;
+    keysReadKind: string;
+    readsCoverage?: ReadsCoverage;
+    /** runtimeStageId of the anchor writer. Absent when missing. */
+    writerId?: string;
+    /** Every DAG node exactly once, keyed by runtimeStageId. */
+    nodes?: Record<string, {
+        stageId: string;
+        stageName: string;
+        keysWritten: string[];
+        depth: number;
+        incompleteSources?: ReadonlyArray<UntrackedSource>;
+    }>;
+    /** Id-referenced edges: child (`from`) depends on parent (`to`). */
+    edges?: Array<{
+        from: string;
+        to: string;
+        kind: 'data' | 'control';
+        key?: string;
+        weight: number;
+    }>;
+    /** Copied from the root when a budget cut the slice. */
+    truncated?: {
+        byDepth: boolean;
+        byNodes: boolean;
+    };
+}

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

@@ -0,0 +1,20 @@
+/**
+ * slice/types.ts — data shapes of the variable-first slicing layer.
+ *
+ * WHY THIS LIBRARY EXISTS (context for future readers, human or LLM):
+ * `causalChain()` (memory/backtrack.ts) answers "what influenced this STEP?"
+ * — its address space is runtimeStageIds. But every triage consumer starts
+ * from a VARIABLE: a human clicks the key `creditTier` in a UI; an LLM tool
+ * call asks "where did history[7] come from?". This library is the address
+ * translation layer: variable in → slice out. It deliberately adds NO new
+ * capture and NO new graph algorithm — it composes the commit-log primitives
+ * (findLastWriter / causalChain / the per-key verb fold) so every surface
+ * (UI panel, LLM tool, offline autopsy agent) asks the question the same way
+ * and gets the same, honestly-labeled answer.
+ *
+ * DAG position: memory ← slice. This module may import ONLY from memory/.
+ * Recorders, engine, and runner must never be imported here — that is what
+ * keeps it a tiny, separately-evolvable library (see README.md).
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/lib/slice/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG","sourcesContent":["/**\n * slice/types.ts — data shapes of the variable-first slicing layer.\n *\n * WHY THIS LIBRARY EXISTS (context for future readers, human or LLM):\n * `causalChain()` (memory/backtrack.ts) answers \"what influenced this STEP?\"\n * — its address space is runtimeStageIds. But every triage consumer starts\n * from a VARIABLE: a human clicks the key `creditTier` in a UI; an LLM tool\n * call asks \"where did history[7] come from?\". This library is the address\n * translation layer: variable in → slice out. It deliberately adds NO new\n * capture and NO new graph algorithm — it composes the commit-log primitives\n * (findLastWriter / causalChain / the per-key verb fold) so every surface\n * (UI panel, LLM tool, offline autopsy agent) asks the question the same way\n * and gets the same, honestly-labeled answer.\n *\n * DAG position: memory ← slice. This module may import ONLY from memory/.\n * Recorders, engine, and runner must never be imported here — that is what\n * keeps it a tiny, separately-evolvable library (see README.md).\n */\n\nimport type { CausalNode, KeysReadLookup } from '../memory/backtrack.js';\nimport type { CommitBundle, TraceEntry, UntrackedSource } from '../memory/types.js';\n\n// ── Keys ───────────────────────────────────────────────────────────────────\n\n/**\n * A state key as consumers know it: either the plain top-level key string, or\n * a path array for nested keys (`['customer', 'address']`). Path arrays are\n * normalised internally — the engine's path delimiter never appears in this\n * public contract.\n */\nexport type StateKey = string | ReadonlyArray<string | number>;\n\n// ── KeysRead sourcing (strategy interface) ─────────────────────────────────\n\n/**\n * STRATEGY INTERFACE: where per-stage read keys come from. THE canonical\n * strategy list lives here (implementations in keysReadSources.ts):\n *\n * Reads are deliberately NOT in the commit log (CommitBundle carries only the\n * `untrackedSources` honesty flags), so a slice needs a reads provider. There\n * are several legitimate providers with different trade-offs, and new ones\n * will appear — hence an interface rather than a hardcoded path:\n *\n * - `keysReadFromExecutionTree` — post-hoc, ZERO setup: reads live in the\n *   snapshot's `StageSnapshot.stageReads` whenever `readTracking` ≠ 'off'\n *   (default 'full'; 'summary' still keeps the keys). Use when you have a\n *   finished run's snapshot.\n * - `keysReadFromMap` — a prebuilt Map/object, e.g. collected live from\n *   `ScopeRecorder.onRead` events or deserialized from a stored trace.\n * - a bare `KeysReadLookup` function — anything else (e.g. QualityRecorder:\n *   `(id) => rec.getByKey(id)?.keysRead ?? []`). Wrapped as kind 'custom-fn'.\n *\n * `kind` is a debugging/honesty breadcrumb: `VariableSlice.keysReadKind`\n * records which strategy produced the slice, so a surprising slice can be\n * traced back to its reads provider.\n */\nexport interface KeysReadSource {\n  /** Discriminator surfaced on {@link VariableSlice.keysReadKind}. */\n  readonly kind: string;\n  /** The lookup `causalChain` will call per visited node. */\n  readonly lookup: KeysReadLookup;\n  /**\n   * OPTIONAL honesty telemetry a strategy can compute while it builds:\n   * how many execution steps it saw, and how many actually had read entries.\n   * `stepsWithReads === 0` over a multi-step run is the machine-detectable\n   * signature of `readTracking: 'off'` — WITHOUT this, a reads-less slice is\n   * indistinguishable from \"genuinely no upstream dependencies\", which is a\n   * lie a triage tool must never tell. Copied onto\n   * {@link VariableSlice.readsCoverage}.\n   */\n  readonly coverage?: ReadsCoverage;\n}\n\n/** See {@link KeysReadSource.coverage}. */\nexport interface ReadsCoverage {\n  /** Execution steps the strategy saw (nodes with a runtimeStageId). */\n  readonly steps: number;\n  /** Of those, steps that had at least one recorded read key. */\n  readonly stepsWithReads: number;\n}\n\n// ── Variable slice ─────────────────────────────────────────────────────────\n\n/**\n * Why a slice could not be produced. Honest absence is a first-class result:\n * - `'empty-log'`     — there are no commits at all (run never executed, or\n *   snapshot came from elsewhere).\n * - `'never-written'` — no commit in range wrote `key`. The value (if any)\n *   came from the run's INITIAL state, run `input` (frozen args channel), or\n *   a closure — none of which the commit log can see. Same blind spot as\n *   `findLastWriter`.\n */\nexport type MissingSliceReason = 'empty-log' | 'never-written';\n\n/**\n * The result of a variable-first backward slice: \"why is `key` what it is?\".\n *\n * Anchoring rule: the slice is rooted at the LAST writer of `key` (before\n * `before`, when given) — the commit that made the value what it currently\n * is. Everything upstream of that writer is reached through the causal DAG.\n *\n * SERIALIZATION WARNING: `root` is an in-memory DAG — nodes appear in BOTH\n * `parents` and `parentEdges[].parent`, and shared ancestors (diamonds) are\n * the same object reached through many paths. `JSON.stringify(slice)`\n * duplicates every shared subtree per path and explodes combinatorially.\n * Never stringify it: use `sliceToJSON()` (flat, id-referenced, linear) for\n * wire transfer or `formatSlice()` (bounded string) for LLM tools.\n */\nexport interface VariableSlice {\n  /** The state key that was asked about (normalised string form). */\n  key: string;\n  /**\n   * Exclusive commit-array-index upper bound the writer search was anchored\n   * at (\"as it stood before this idx\"). Undefined = the whole log (current\n   * value).\n   */\n  before?: number;\n  /** The commit that last wrote `key` — the slice anchor. Absent when missing. */\n  writer?: CommitBundle;\n  /**\n   * The backward causal DAG rooted at the writer (same `CausalNode` shape as\n   * `causalChain` — parentEdges carry keyed data/control edges, honesty via\n   * `incompleteSources`/`truncated`). Absent when missing. See the\n   * serialization warning on this interface before stringifying.\n   */\n  root?: CausalNode;\n  /** Present ONLY when `root` is absent — why there is no slice. */\n  missing?: MissingSliceReason;\n  /** Which {@link KeysReadSource} strategy resolved reads (honesty/debug). */\n  keysReadKind: string;\n  /**\n   * Honesty telemetry copied from the strategy when it provides one — see\n   * {@link KeysReadSource.coverage}. A root with no parents AND\n   * `stepsWithReads === 0` means \"reads were not recorded\", NOT \"no\n   * dependencies\"; triage tools must say so.\n   */\n  readsCoverage?: ReadsCoverage;\n}\n\n// ── Element provenance (append-fold) ───────────────────────────────────────\n\n/**\n * How an element's birth commit was determined — the honesty axis of\n * append-fold provenance. Ordered strongest → weakest:\n *\n * - `'append-verb'`      — the engine RECORDED this tail append\n *   (`commitValues: 'delta'`). Exact by construction.\n * - `'prefix-inference'` — a full-value write preserved the previous array as\n *   a strict prefix, so the new tail is attributed to this commit. Heuristic:\n *   a writer that REPLACED the array with one that happens to share the old\n *   prefix is indistinguishable from an append. Right in practice (push-style\n *   growth), labeled honestly so consumers can tell.\n * - `'whole-value'`      — the array was (re)placed wholesale; every\n *   element's provenance resets to this commit. Exact but coarse.\n */\nexport type AttributionBasis = 'append-verb' | 'prefix-inference' | 'whole-value';\n\n/**\n * The birth record of ONE array element: which commit (and therefore which\n * stage execution) first put it there. This is what turns the agent\n * mega-key problem (\"everything depends on `history`\") into element-level\n * answers (\"history[7] was appended by tool-calls#41 in iteration 3\").\n *\n * @see elementProvenance — the query that returns this record.\n */\nexport interface ElementBirth {\n  /** Element index in the reconstructed array at query time. */\n  index: number;\n  /** Commit ARRAY position (the `CommitBundle.idx` space) of the birth. */\n  commitIdx: number;\n  /** Execution step that wrote it — joins to slices, recorders, UIs. */\n  runtimeStageId: string;\n  /** Stable stage identifier of the writer. */\n  stageId: string;\n  /** Human-readable stage name of the writer. */\n  stageName: string;\n  /** The trace verb of the birth commit's entry for this key. */\n  verb: TraceEntry['verb'];\n  /** How the attribution was determined — see {@link AttributionBasis}. */\n  basis: AttributionBasis;\n  /**\n   * The element's value as of the fold (detached clone). Redaction note:\n   * values are re-served exactly as the commit log stored them — a redacted\n   * key's `'[REDACTED]'` placeholder stays redacted; this layer never\n   * resurrects originals.\n   */\n  value: unknown;\n}\n\n/**\n * Why element provenance could not be produced (mirrors\n * {@link MissingSliceReason} — one honest-absence pattern module-wide):\n * - `'empty-log'`     — no commits at all.\n * - `'never-written'` — no commit in range touched the key.\n * - `'not-an-array'`  — the key WAS written but its folded value is not an\n *   array at the queried point: a scalar/object key, a deleted key, or a\n *   merge that degraded it. Element provenance is an array concept — for\n *   scalar keys the right query is `sliceForKey`.\n */\nexport type MissingProvenanceReason = 'empty-log' | 'never-written' | 'not-an-array';\n\n/**\n * Element-level provenance for one array-valued key. Mirrors\n * {@link VariableSlice}'s honest-absence shape: on success `atIdx`/`length`/\n * `births` are set; otherwise `missing` says why (present ONLY when `births`\n * is absent).\n *\n * @see arrayProvenance — the query that returns this.\n * @see ElementBirth — one record per element, index-aligned.\n */\nexport interface ArrayProvenance {\n  /** The state key (normalised string form). */\n  key: string;\n  /** Inclusive commit array idx the fold ran to. Absent when missing. */\n  atIdx?: number;\n  /** Length of the reconstructed array (births.length === length). */\n  length?: number;\n  /** One birth per element, index-aligned with the reconstructed array. */\n  births?: ElementBirth[];\n  /** Present ONLY when `births` is absent — why there is no provenance. */\n  missing?: MissingProvenanceReason;\n}\n\n// ── JSON-safe serialization (for wire transfer / LLM tools) ────────────────\n\n/**\n * Flat, id-referenced, JSON-safe projection of a {@link VariableSlice} —\n * linear in node count (each node serialized exactly once; edges reference\n * ids). THE shape to persist, send over the wire, or hand to structured\n * consumers. See the serialization warning on {@link VariableSlice}.\n */\nexport interface SliceJSON {\n  key: string;\n  before?: number;\n  missing?: MissingSliceReason;\n  keysReadKind: string;\n  readsCoverage?: ReadsCoverage;\n  /** runtimeStageId of the anchor writer. Absent when missing. */\n  writerId?: string;\n  /** Every DAG node exactly once, keyed by runtimeStageId. */\n  nodes?: Record<\n    string,\n    {\n      stageId: string;\n      stageName: string;\n      keysWritten: string[];\n      depth: number;\n      incompleteSources?: ReadonlyArray<UntrackedSource>;\n    }\n  >;\n  /** Id-referenced edges: child (`from`) depends on parent (`to`). */\n  edges?: Array<{ from: string; to: string; kind: 'data' | 'control'; key?: string; weight: number }>;\n  /** Copied from the root when a budget cut the slice. */\n  truncated?: { byDepth: boolean; byNodes: boolean };\n}\n"]}