agentfootprint-lens 0.48.0 → 0.50.0

package/README.md

@@ -940,7 +940,9 @@ not answer, since it takes an exact stop.
 ## The Served tab
 
 **At every LLM call, exactly what the model was served — provable from the log.**
-The Why Lens's right rail has a second tab, **Served**, mounted for every run.
+The Why Lens's right rail has a second tab, **Served**, mounted for every run —
+including for a host that supplies `slots.detail`, whose own pane is the tab
+beside it (0.50.0).
 Stand on an LLM turn and it shows the request that call went out with: the system
 prompt (piece by piece), the messages as sent, the tools as sent, the dials, the
 cache breakpoints — and beside every field, what the record can PROVE about it.
@@ -1059,12 +1061,57 @@ on every epoch, no receipt was minted, and the tab says so with the library's
 `no-receipt-on-chart` gap and `cause: 'no-receipt-committed'` — every row
 **Reconstructed**, never a fabricated **Verified**.
 
+### The Served graph (0.49.0)
+
+A list is right for checking one row and wrong for seeing that the system string
+was assembled from a base plus one skill body plus two injections while three
+tools were withheld. That is one picture, and since 0.49.0 the Served tab has a
+**List ⇄ Graph** toggle (the list stays the default) that draws it: **HELD** —
+what the record holds at this stop, from the fold — then **SERVED** — what
+crossed into the call, one edge per system piece, message, request-only line and
+tool, each carrying its badge and, against the previous epoch, whether it
+*entered*, *left* or is *unchanged* — then **WITHHELD**: held and not sent. The
+withheld band is the reason to build it. The model never learns what it was
+denied; the operator should — the withheld tool list, the attention drops, the
+skills a role hid (read from the fold, since a receipt carries no authority
+names), a redacted fold, and every gap the view declares, each with the
+library's own sentence. Same cursor, same row, same badges: a Damaged row draws
+Damaged here too, and a field a gap covers draws the gap rather than an empty
+node.
+
+| graph | what it draws | the question it answers |
+|---|---|---|
+| **skill graph** (`<SkillGraph>`) | the skills, their steps and their edges | where a run MAY go, and where it went |
+| **data graph** (*Where from*) | a value's writers, back through the commit log | where THIS value came from |
+| **Served graph** (Served tab · Graph) | one call: held · served · withheld | what this ONE CALL was made of, and what we held back |
+
+```ts
+import { foldFactsAt, servedGraphAt, servedRowAt, verify } from 'agentfootprint-lens/core';
+
+const cursor = { runtimeStageId: 'call-llm#18', commitIdx: 15 };
+const row = servedRowAt(snapshot, cursor)!;
+const graph = servedGraphAt({
+  row,
+  fold: foldFactsAt(snapshot, cursor),
+  checks: verify(row.view, row.receipt, row.receipt?.basis.runId ?? '', row.receiptCause),
+});
+graph.served.map((s) => `${s.slot} ${s.rebuilt}`);                 // ['system-prompt 3', …]
+graph.edges.filter((e) => e.state === 'entered').map((e) => e.origin);  // ['instructions']
+graph.withheld.filter((w) => w.from === 'fold').map((w) => w.name);     // ['payroll']
+```
+
+`<ServedGraph graph>` is exported for shells that build the input themselves.
+**Deliberately absent:** an edge from a served piece back to the STAGE that
+wrote it. It needs a commit-log walk keyed by piece text or slot — the part most
+likely to rot — and the question above is answered without it.
+
 ---
 
 ## Bookmarks, and scrubbing by declared tag
 
 **The reader's marks, kept beside the recording — and the author's tags, as a
-ruler.** Since 0.48.0 the Why Lens's right rail has a third tab, **Bookmarks**,
+ruler.** Since 0.48.0 the Why Lens's right rail has a third tab, **Bookmarks**
+(a fourth when a host fills `slots.detail`),
 and the grouped ruler carries a **Tags** strip.
 
 ### Why
@@ -1178,9 +1225,17 @@ unavailable*, and nothing else changes. The peer ranges are untouched.
 
 ## Rendering your own detail pane
 
-`slots.detail` replaces the CONTENT of the shipped right column. The column
-itself — its width, its border, its collapse pill, its cursor — is unchanged.
-Omit `slots` and the built-in timeline renders exactly as before.
+**A slot fills a PANE, never the CHROME around it.** The right rail's tab strip,
+the one cursor and the collapse pill belong to the library, because chrome is how
+the library adds capability over time — a consumer that fills a slot must still
+receive every reading the rail gains later. That is why `slots.detail` is ONE TAB
+and not a takeover, and why `detailOnly` is an opt-out rather than the default.
+
+`slots.detail` renders the right column's FIRST tab. The column itself — its
+width, its border, its collapse pill, its cursor — is unchanged, and so is the
+strip: your pane is selected by default, with *What happened*, *Served* and
+*Bookmarks* one click away beside it. Omit `slots` and the built-in timeline
+renders exactly as before.
 
 ```tsx
 const Detail: React.FC<LensDetailSlotProps> = ({ step, cursorRuntimeStageId, node, onNavigate }) => (
@@ -1191,7 +1246,8 @@ const Detail: React.FC<LensDetailSlotProps> = ({ step, cursorRuntimeStageId, nod
   </div>
 );
 
-<Lens recorder={recorder} runner={runner} slots={{ detail: Detail }} />
+<Lens recorder={recorder} runner={runner} slots={{ detail: Detail, detailLabel: 'My bands' }} />
+// rail: [ My bands* | What happened | Served | Bookmarks ]
 ```
 
 The slot receives the cursor in every unit (`step`, `totalSteps`,
@@ -1200,6 +1256,23 @@ and the ones that ran inside its scope (`node`, `relatedNodes`), the `recorder`
 for anything else, and `onNavigate` — the same funnel every built-in mover uses,
 so your pane moves the ONE cursor rather than starting a second one.
 
+| key | what it does |
+|---|---|
+| `detail` | your pane, as the rail's first tab, selected by default |
+| `detailLabel` | what that tab is CALLED. Default `"Details"` — the library's generic word for someone else's pane. Name it and the strip reads in your reader's words. |
+| `detailOnly` | opt OUT of the strip: your pane takes the whole rail, as it did before 0.50.0. For a full-height custom layout that would read as a second chrome under the library's strip. The cost: nothing the rail gains later can reach you. |
+
+**Switching tabs moves nothing and remounts nothing.** The cursor stays where it
+was, and your pane is hidden rather than unmounted — a reader who glances at
+*Served* and comes back finds their bands open and their scroll where they left
+it.
+
+**The worked example (0.50.0).** An app supplies `detail` + `detailLabel` and
+changes nothing else: it sees its own pane first and selected, exactly as before,
+and it GAINS Served, the Served graph and Bookmarks on the version bump. Before
+0.50.0 that same app lost the entire rail — the tab strip included — and could
+not reach any of them.
+
 Keep the slots object stable across renders (module scope or `useMemo`), same as
 `<TraceExplorerShell slots>`.
 
@@ -1333,7 +1406,7 @@ graph in one call. Returns an unsubscribe. Call it once per run.
 | `step` | `number?` | Controlled cursor. **Omit it and the lens is self-driving, exactly as before.** Pass it and you own the position; out-of-range values are clamped and reported. See [Driving the cursor](#driving-the-cursor-from-your-app). |
 | `onStepChange` | `(step, at) => void?` | Fires on every cursor move — required for movement in controlled mode, an observation hook otherwise. `at` carries `runtimeStageId`, `commitIdx`, `label`, `kind` and `clamped`. |
 | `navigatorRef` | `Ref<LensNavigator>?` | Move the cursor to a stage **by its `runtimeStageId`**. `ref.current.navigateTo(id)` returns `{ ok: true, step, match, label }` or `{ ok: false, reason, message, nearest? }` — a miss never moves. See [Pointing at a step](#pointing-at-a-step-navigatorref). |
-| `slots` | `LensSlots?` | Slot overrides. `slots.detail` renders your content in the shipped right column. Omit for the built-in timeline. See [Rendering your own detail pane](#rendering-your-own-detail-pane). |
+| `slots` | `LensSlots?` | Slot overrides. `slots.detail` renders your content as the right rail's FIRST TAB (`slots.detailLabel` names it; `slots.detailOnly` takes the whole rail instead). The strip stays the library's. Omit for the built-in timeline. See [Rendering your own detail pane](#rendering-your-own-detail-pane). |
 
 ### `<LensFlow>` — the chart canvas on its own
 

package/dist/{Lens-_IjGLEGt.d.cts → Lens-DJJsMfud.d.cts}

@@ -634,16 +634,67 @@ interface LensProps {
  *
  * Same idea as `<TraceExplorerShell slots>`: keep the shipped layout and the
  * shipped cursor, replace what one pane renders.
+ *
+ * THE LAW: **a slot fills a PANE, never the CHROME around it.** The rail's tab
+ * strip, the one cursor and the collapse pill belong to the library, because
+ * chrome is how the library adds capability over time — a consumer that fills a
+ * slot must still receive every capability the rail gains later. That is why
+ * `detail` is ONE TAB and not a takeover, and why `detailOnly` is an opt-out
+ * rather than the default.
  */
 interface LensSlots {
     /**
-     * Override the RIGHT column — the "what happened" timeline. Your component
-     * renders inside the shipped column (its width, borders, collapse pill and
-     * scroll behaviour are unchanged); only the content is yours.
+     * Render the right column's FIRST TAB — your own pane, beside the library's.
+     *
+     * Your component renders inside the shipped column (its width, borders,
+     * collapse pill and scroll behaviour are unchanged) and inside the shipped
+     * rail: the tab strip stays, your pane becomes the first tab and is selected
+     * by default, and "What happened", "Served" and "Bookmarks" stay reachable
+     * beside it. Switching tabs never moves the cursor and never unmounts your
+     * pane — it keeps its own state.
+     *
+     * Before 0.50.0 a supplied slot replaced the whole rail, tab strip included,
+     * so a slot consumer could not reach anything the rail gained afterwards.
+     * That was the defect this shape fixes; `detailOnly` is the way back.
      *
      * Omit it and the built-in timeline renders exactly as before.
+     *
+     * ```tsx
+     * <Lens recorder={recorder} slots={{ detail: MyBands, detailLabel: 'Bands' }} />
+     * // rail: [ Bands* | What happened | Served | Bookmarks ]
+     * ```
      */
     readonly detail?: React__default.ComponentType<LensDetailSlotProps>;
+    /**
+     * What the `detail` tab is CALLED. Default: `"Details"`.
+     *
+     * WHY it exists: the tab strip names each reading in the reader's own words,
+     * and "Details" is the library's generic word for someone else's pane. An app
+     * whose pane is a stack of SEO bands should say so — the strip is read left to
+     * right and an unnamed tab makes the app's own reading the anonymous one.
+     *
+     * A plain string, rendered as the tab's text; it is the accessible name too.
+     * Ignored when no `detail` slot is supplied.
+     *
+     * ```tsx
+     * slots={{ detail: MyBands, detailLabel: 'SEO bands' }}
+     * ```
+     */
+    readonly detailLabel?: string;
+    /**
+     * OPT OUT of the tab strip: the `detail` slot takes the whole rail, as it did
+     * before 0.50.0. Default `false`.
+     *
+     * For the app with a full-height custom layout of its own — a pane that owns
+     * its scroll and its header and would read as a second chrome under the
+     * library's strip. The cost is stated plainly: nothing the rail gains later
+     * (Served, Bookmarks, whatever follows) can reach that consumer, and neither
+     * can the library's own timeline. Prefer the tabs; take this only when the
+     * layout genuinely demands it.
+     *
+     * Ignored when no `detail` slot is supplied.
+     */
+    readonly detailOnly?: boolean;
 }
 /**
  * What the `detail` slot receives — the cursor, in the units a detail pane

package/dist/{Lens-_hExvOXu.d.ts → Lens-okdu_w0H.d.ts}

@@ -634,16 +634,67 @@ interface LensProps {
  *
  * Same idea as `<TraceExplorerShell slots>`: keep the shipped layout and the
  * shipped cursor, replace what one pane renders.
+ *
+ * THE LAW: **a slot fills a PANE, never the CHROME around it.** The rail's tab
+ * strip, the one cursor and the collapse pill belong to the library, because
+ * chrome is how the library adds capability over time — a consumer that fills a
+ * slot must still receive every capability the rail gains later. That is why
+ * `detail` is ONE TAB and not a takeover, and why `detailOnly` is an opt-out
+ * rather than the default.
  */
 interface LensSlots {
     /**
-     * Override the RIGHT column — the "what happened" timeline. Your component
-     * renders inside the shipped column (its width, borders, collapse pill and
-     * scroll behaviour are unchanged); only the content is yours.
+     * Render the right column's FIRST TAB — your own pane, beside the library's.
+     *
+     * Your component renders inside the shipped column (its width, borders,
+     * collapse pill and scroll behaviour are unchanged) and inside the shipped
+     * rail: the tab strip stays, your pane becomes the first tab and is selected
+     * by default, and "What happened", "Served" and "Bookmarks" stay reachable
+     * beside it. Switching tabs never moves the cursor and never unmounts your
+     * pane — it keeps its own state.
+     *
+     * Before 0.50.0 a supplied slot replaced the whole rail, tab strip included,
+     * so a slot consumer could not reach anything the rail gained afterwards.
+     * That was the defect this shape fixes; `detailOnly` is the way back.
      *
      * Omit it and the built-in timeline renders exactly as before.
+     *
+     * ```tsx
+     * <Lens recorder={recorder} slots={{ detail: MyBands, detailLabel: 'Bands' }} />
+     * // rail: [ Bands* | What happened | Served | Bookmarks ]
+     * ```
      */
     readonly detail?: React__default.ComponentType<LensDetailSlotProps>;
+    /**
+     * What the `detail` tab is CALLED. Default: `"Details"`.
+     *
+     * WHY it exists: the tab strip names each reading in the reader's own words,
+     * and "Details" is the library's generic word for someone else's pane. An app
+     * whose pane is a stack of SEO bands should say so — the strip is read left to
+     * right and an unnamed tab makes the app's own reading the anonymous one.
+     *
+     * A plain string, rendered as the tab's text; it is the accessible name too.
+     * Ignored when no `detail` slot is supplied.
+     *
+     * ```tsx
+     * slots={{ detail: MyBands, detailLabel: 'SEO bands' }}
+     * ```
+     */
+    readonly detailLabel?: string;
+    /**
+     * OPT OUT of the tab strip: the `detail` slot takes the whole rail, as it did
+     * before 0.50.0. Default `false`.
+     *
+     * For the app with a full-height custom layout of its own — a pane that owns
+     * its scroll and its header and would read as a second chrome under the
+     * library's strip. The cost is stated plainly: nothing the rail gains later
+     * (Served, Bookmarks, whatever follows) can reach that consumer, and neither
+     * can the library's own timeline. Prefer the tabs; take this only when the
+     * layout genuinely demands it.
+     *
+     * Ignored when no `detail` slot is supplied.
+     */
+    readonly detailOnly?: boolean;
 }
 /**
  * What the `detail` slot receives — the cursor, in the units a detail pane

package/dist/{chunk-FZHRQNRS.js → chunk-AIZIILHJ.js}

@@ -3296,16 +3296,16 @@ function diffPromptsBounded(a, b, maxCells = DIFF_CELL_CAP) {
 }
 
 // src/core/served/sincePrevious.ts
-function unmatched(a, b) {
+function unmatchedIndexes(a, b) {
   const pool = /* @__PURE__ */ new Map();
   for (const item of b) pool.set(item, (pool.get(item) ?? 0) + 1);
-  let count = 0;
-  for (const item of a) {
+  const out = [];
+  for (const [i, item] of a.entries()) {
     const n = pool.get(item) ?? 0;
     if (n > 0) pool.set(item, n - 1);
-    else count += 1;
+    else out.push(i);
   }
-  return count;
+  return out;
 }
 function sincePrevious(current, previous) {
   const now = current.view;
@@ -3328,6 +3328,10 @@ function sincePrevious(current, previous) {
       if (a !== void 0 && b !== void 0 && a !== b) schemaChanged.push(name);
     }
   }
+  const piecesEntered = unmatchedIndexes(nowPieces, beforePieces);
+  const piecesLeft = unmatchedIndexes(beforePieces, nowPieces);
+  const messagesEntered = unmatchedIndexes(nowMessages, beforeMessages);
+  const messagesLeft = unmatchedIndexes(beforeMessages, nowMessages);
   const changed = now.system.text !== before.system.text;
   const diff = changed ? diffPromptsBounded(before.system.text, now.system.text) : Object.freeze([]);
   return Object.freeze({
@@ -3336,12 +3340,16 @@ function sincePrevious(current, previous) {
     system: Object.freeze({
       changed,
       ...diff !== void 0 ? { diff: Object.freeze([...diff]) } : {},
-      piecesEntered: unmatched(nowPieces, beforePieces),
-      piecesLeft: unmatched(beforePieces, nowPieces)
+      piecesEntered: piecesEntered.length,
+      piecesLeft: piecesLeft.length,
+      enteredIndexes: Object.freeze(piecesEntered),
+      leftPieces: Object.freeze(piecesLeft.map((i) => before.system.pieces[i]))
     }),
     messages: Object.freeze({
-      entered: unmatched(nowMessages, beforeMessages),
-      left: unmatched(beforeMessages, nowMessages)
+      entered: messagesEntered.length,
+      left: messagesLeft.length,
+      enteredIndexes: Object.freeze(messagesEntered),
+      leftEntries: Object.freeze(messagesLeft.map((i) => before.messages.asSent[i]))
     }),
     tools: Object.freeze({
       added: Object.freeze(added),
@@ -3404,6 +3412,295 @@ function foldFactsAt(recording, cursor) {
   });
 }
 
+// src/core/served/servedGraphAt.ts
+import {
+  SERVED_GAPS as SERVED_GAPS2,
+  UNGAPPED_FIELDS
+} from "agentfootprint";
+var SLOT_ORDER = Object.freeze({
+  "system-prompt": 0,
+  messages: 1,
+  tools: 2
+});
+var SERVED_SLOTS = Object.freeze(
+  Object.keys(SLOT_ORDER).sort((a, b) => SLOT_ORDER[a] - SLOT_ORDER[b])
+);
+var HELD_HONESTY_KEYS = Object.freeze([
+  "basis",
+  "redacted",
+  "skipped",
+  "foldError"
+]);
+var HELD_KEYS = Object.freeze([
+  ...FOLD_FACT_KEYS,
+  ...HELD_HONESTY_KEYS
+]);
+var RECONSTRUCTED = Object.freeze({ status: "reconstructed" });
+var NOT_ON_RECORD = Object.freeze({ status: "not-on-record" });
+function slotsOfFields(fields) {
+  const out = [];
+  for (const field of fields) {
+    const slot = field.startsWith("system.") ? "system-prompt" : field.startsWith("messages.") ? "messages" : field.startsWith("tools.") ? "tools" : void 0;
+    if (slot !== void 0 && !out.includes(slot)) out.push(slot);
+  }
+  return out;
+}
+function heldNodes(fold) {
+  const node = (key, value, status) => Object.freeze(value === void 0 ? { key, status } : { key, value, status });
+  const out = [];
+  for (const key of FOLD_FACT_KEYS) {
+    const value = fold[key];
+    out.push(value === void 0 ? node(key, void 0, "not-on-record") : node(key, value, "reconstructed"));
+  }
+  out.push(
+    fold.basis === void 0 ? node("basis", void 0, "not-on-record") : node("basis", fold.basis, "reconstructed")
+  );
+  out.push(node("redacted", fold.redacted, "reconstructed"));
+  if (fold.skipped !== void 0) out.push(node("skipped", fold.skipped, "damaged"));
+  if (fold.foldError !== void 0) out.push(node("foldError", fold.foldError, "damaged"));
+  return Object.freeze(out);
+}
+function servedEdges(input) {
+  const { row, checks, since } = input;
+  const view = row.view;
+  const edge = (e) => Object.freeze(e);
+  const out = [];
+  const compared = since !== void 0;
+  const enteredPieces = new Set(since?.system.enteredIndexes ?? []);
+  const enteredMessages = new Set(since?.messages.enteredIndexes ?? []);
+  const stateOf = (entered) => compared ? entered ? "entered" : "unchanged" : void 0;
+  const withState = (state) => state !== void 0 ? { state } : {};
+  view.system.pieces.forEach((piece, i) => {
+    out.push(
+      edge({
+        id: `piece:${i}`,
+        kind: "piece",
+        slot: piece.slot,
+        source: piece.source,
+        origin: piece.source,
+        text: piece.text,
+        check: checks.pieces[i] ?? RECONSTRUCTED,
+        ...withState(stateOf(enteredPieces.has(i)))
+      })
+    );
+  });
+  (since?.system.leftPieces ?? []).forEach((piece, i) => {
+    out.push(
+      edge({
+        id: `piece-left:${i}`,
+        kind: "piece",
+        slot: piece.slot,
+        source: piece.source,
+        origin: piece.source,
+        text: piece.text,
+        // Not on this request at all: there is no row here for a hash to check.
+        check: NOT_ON_RECORD,
+        state: "left"
+      })
+    );
+  });
+  view.messages.asSent.forEach((message, i) => {
+    const label = message.toolName ?? message.toolCallId;
+    out.push(
+      edge({
+        id: `message:${i}`,
+        kind: "message",
+        slot: "messages",
+        role: message.role,
+        origin: message.role,
+        ...label !== void 0 ? { label } : {},
+        text: message.content,
+        check: checks.messages[i] ?? RECONSTRUCTED,
+        ...withState(stateOf(enteredMessages.has(i)))
+      })
+    );
+  });
+  (since?.messages.leftEntries ?? []).forEach((message, i) => {
+    out.push(
+      edge({
+        id: `message-left:${i}`,
+        kind: "message",
+        slot: "messages",
+        role: message.role,
+        origin: message.role,
+        text: message.content,
+        check: NOT_ON_RECORD,
+        state: "left"
+      })
+    );
+  });
+  view.messages.requestOnly.forEach((line, i) => {
+    out.push(
+      edge({
+        id: `request-only:${i}`,
+        kind: "request-only",
+        slot: "messages",
+        role: line.role,
+        origin: line.role,
+        label: line.reason,
+        text: line.text,
+        check: checks.requestOnly[i] ?? RECONSTRUCTED
+      })
+    );
+  });
+  view.tools.names.forEach((name) => {
+    const schema = view.tools.schemas.find((s) => s.name === name);
+    const state = compared ? since !== void 0 && since.tools.added.includes(name) ? "entered" : "unchanged" : void 0;
+    out.push(
+      edge({
+        id: `tool:${name}`,
+        kind: "tool",
+        slot: "tools",
+        label: name,
+        // No rebuilt schema means no hash on this side; a NAME is never
+        // verified — the receipt carries names as plain strings.
+        check: schema !== void 0 ? checks.toolSchemas[name] ?? RECONSTRUCTED : RECONSTRUCTED,
+        ...view.tools.forced === name ? { forced: true } : {},
+        ...checks.onReceiptOnly.schemas.includes(name) ? { schemaOnReceiptOnly: true } : {},
+        ...since !== void 0 && since.tools.schemaChanged.includes(name) ? { schemaChanged: true } : {},
+        ...withState(state)
+      })
+    );
+  });
+  (since?.tools.removed ?? []).forEach((name) => {
+    out.push(
+      edge({
+        id: `tool-left:${name}`,
+        kind: "tool",
+        slot: "tools",
+        label: name,
+        check: NOT_ON_RECORD,
+        state: "left"
+      })
+    );
+  });
+  return Object.freeze(out);
+}
+function slotNodes(input, edges) {
+  const { row, checks } = input;
+  const view = row.view;
+  const receipt = row.receipt;
+  const gapsFor = (slot) => Object.freeze(view.gaps.filter((g) => slotsOfFields(g.fields).includes(slot)));
+  const rebuiltIn = (slot) => edges.filter((e) => e.slot === slot && e.state !== "left").length;
+  const onReceipt = {
+    "system-prompt": receipt?.system.pieces.length,
+    messages: receipt !== void 0 ? receipt.messages.entries.length + receipt.messages.requestOnly.length : void 0,
+    tools: checks.namesOnReceipt?.length
+  };
+  const check2 = {
+    "system-prompt": checks.system,
+    messages: void 0,
+    tools: checks.toolNames
+  };
+  const onReceiptOnly = {
+    "system-prompt": checks.onReceiptOnly.pieces,
+    messages: checks.onReceiptOnly.messages + checks.onReceiptOnly.requestOnly,
+    tools: checks.onReceiptOnly.toolNames.length
+  };
+  const rebuiltOnly = {
+    "system-prompt": checks.rebuiltOnly.pieces,
+    messages: checks.rebuiltOnly.messages + checks.rebuiltOnly.requestOnly,
+    tools: checks.rebuiltOnly.toolNames.length
+  };
+  return Object.freeze(
+    SERVED_SLOTS.map((slot) => {
+      const aggregate = check2[slot];
+      const count = onReceipt[slot];
+      return Object.freeze({
+        slot,
+        ...aggregate !== void 0 ? { check: aggregate } : {},
+        rebuilt: rebuiltIn(slot),
+        ...count !== void 0 ? { onReceipt: count } : {},
+        onReceiptOnly: onReceiptOnly[slot],
+        rebuiltOnly: rebuiltOnly[slot],
+        gaps: gapsFor(slot)
+      });
+    })
+  );
+}
+function withheldNodes(input) {
+  const { row, fold } = input;
+  const view = row.view;
+  const out = [];
+  if (view.tools.withheld !== void 0) {
+    out.push(
+      Object.freeze({
+        kind: "tool-withheld",
+        name: view.tools.withheld,
+        from: "view",
+        slot: "tools"
+      })
+    );
+  }
+  for (const id of fold.hiddenSkillIds ?? []) {
+    out.push(Object.freeze({ kind: "hidden-skill", name: id, from: "fold" }));
+  }
+  const drops = row.receipt?.omittedForAttention;
+  out.push(
+    Object.freeze(
+      drops !== void 0 ? {
+        kind: "attention-drop",
+        name: "omittedForAttention",
+        from: "receipt",
+        count: drops.count,
+        hashes: Object.freeze([...drops.hashes])
+      } : {
+        // Absent is not none: the library's own sentence for a field no gap
+        // explains, printed beside the Not-on-record badge.
+        kind: "attention-drop",
+        name: "omittedForAttention",
+        from: "receipt",
+        status: "not-on-record",
+        why: UNGAPPED_FIELDS.omittedForAttention
+      }
+    )
+  );
+  if (fold.redacted) {
+    out.push(Object.freeze({ kind: "redacted", name: "redacted", from: "fold" }));
+  }
+  for (const gap of view.gaps) {
+    const slots = slotsOfFields(gap.fields);
+    out.push(
+      Object.freeze({
+        kind: "gap",
+        name: gap.gap,
+        from: "view",
+        // One slot named: draw it there. Several, or none: the band itself.
+        ...slots.length === 1 ? { slot: slots[0] } : {},
+        why: SERVED_GAPS2[gap.gap].why,
+        fields: gap.fields,
+        ...gap.cause !== void 0 ? { cause: gap.cause } : {}
+      })
+    );
+  }
+  return Object.freeze(out);
+}
+function callNode(input, edges) {
+  const { row, checks } = input;
+  const basis = row.view.basis;
+  return Object.freeze({
+    epoch: row.epoch,
+    callRuntimeStageId: row.callRuntimeStageId,
+    commitIdx: row.commitIdx,
+    betweenCalls: row.betweenCalls,
+    ...row.previousEpoch !== void 0 ? { previousEpoch: row.previousEpoch } : {},
+    ...basis !== void 0 ? { basis } : {},
+    basisStatus: basis !== void 0 ? "reconstructed" : "not-on-record",
+    ...row.receiptCause !== void 0 ? { receiptCause: row.receiptCause } : {},
+    damaged: checks.damaged || edges.some((e) => e.check.status === "damaged")
+  });
+}
+function servedGraphAt(input) {
+  const edges = servedEdges(input);
+  return Object.freeze({
+    held: heldNodes(input.fold),
+    served: slotNodes(input, edges),
+    withheld: withheldNodes(input),
+    call: callNode(input, edges),
+    edges
+  });
+}
+
 // src/core/bookmarks/bookmarkKey.ts
 function fnv1a(s) {
   let h = 2166136261;
@@ -3783,6 +4080,10 @@ export {
   sincePrevious,
   FOLD_FACT_KEYS,
   foldFactsAt,
+  SERVED_SLOTS,
+  HELD_HONESTY_KEYS,
+  HELD_KEYS,
+  servedGraphAt,
   bookmarkKey,
   snapshotOfRunner,
   snapshotLogKey,
@@ -3799,4 +4100,4 @@ export {
   tagStopsFor,
   tagAxisPositions
 };
-//# sourceMappingURL=chunk-FZHRQNRS.js.map
+//# sourceMappingURL=chunk-AIZIILHJ.js.map