mixdog 1.4.1 → 1.4.2

package/src/standalone/session-service/session-calls/session-views.mjs

@@ -6,60 +6,26 @@ import { SESSION_READ_ACTION_SET } from '../../session-protocol.mjs';
 import { SESSION_ID_PATTERN } from '../agent-tree.mjs';
 import {
   loadLiveTranscriptHead,
+  readTranscriptHistory,
   readTranscriptRange,
   rebudgetTranscriptWindow,
+  requestedTranscriptHistory,
   requestedHeldTranscript,
   requestedTranscriptWindow,
   requestLiveTranscriptWindow,
+  restartTranscriptWindow,
+  transcriptAnswerBounds,
   transcriptPageBody,
+  transcriptWindowOversized,
 } from '../projection/transcript-window.mjs';
 
-export function createSessionViewCalls(ctx) {
-  const { log, readStoredSession, externalViewEntries, runSessionAction, sessionResult, advanceForCaller } = ctx;
-  const { currentSessionId, externalEntryForView, projectionResult, unchangedProjectionResult, sessionOwner } =
-    ctx.projection;
-  /** The owner a concurrent materialization may have produced while a disk
-   *  read was in flight: a daemon-owned runtime outranks an external view. */
-  const lateOwnerFor = (id) => sessionOwner(id) || externalEntryForView(id);
-  const {
-    subscriberToken,
-    addSubscriber,
-    trackPendingViewer,
-    dropPendingViewer,
-    adoptPendingViewers,
-    notePrependViewer,
-  } = ctx.viewers;
-  const { sessionBusy, retainUnwatched, releaseProjection, startEvictionSweep } = ctx.retention;
-  const {
-    assertAvailable,
-    createEntry,
-    getOrCreateSessionEntry,
-    entryForSession,
-    liveEntryForView,
-    bindExternalSessionView,
-    destroy,
-  } = ctx.entries;
-  const {
-    storedSessionProjection,
-    storedProjectionUnchanged,
-    requestedMessageSlice,
-    forgetStoredSession,
-    releaseStoredSession,
-  } = ctx.storedReader;
-
-  /** A read/subscribe names the transcript window its view wants (none: the
-   *  whole transcript). A window grown past what a resumed runtime holds is
-   *  completed from durable history, which a live session never keeps cached. */
-  async function applyTranscriptRequest(entry, params, sessionId) {
-    const request = requestedTranscriptWindow(params);
-    // A model-message read (messageStart) is not a view and leaves the window.
-    if (request || !Number.isInteger(params.messageStart)) requestLiveTranscriptWindow(entry, request);
-    // No baseline the next step can patch: this caller receives the window
-    // whole, so it goes out within its byte budget.
-    if (request && params.baseRevision !== entry.revision) rebudgetTranscriptWindow(entry);
-    if (await loadLiveTranscriptHead(entry, sessionId, readStoredSession)) forgetStoredSession(sessionId);
-    assertAvailable(entry);
-  }
+/** Creating (reserving) a session. */
+function createSessionCreation(ctx) {
+  const { log, sessionResult, advanceForCaller } = ctx;
+  const { currentSessionId } = ctx.projection;
+  const { addSubscriber, adoptPendingViewers } = ctx.viewers;
+  const { retainUnwatched } = ctx.retention;
+  const { assertAvailable, createEntry, getOrCreateSessionEntry, destroy } = ctx.entries;
 
   async function createReservedSession(params, viewer, reservedSessionId) {
     const entry = await createEntry({ ...params, sessionId: reservedSessionId }, viewer);
@@ -103,6 +69,138 @@ export function createSessionViewCalls(ctx) {
     return sessionResult(entry, step);
   }
 
+  return { createSession };
+}
+
+/** The transcript window a live view is answered through: requesting it,
+ *  bounding the answer, and attaching a subscriber to a live entry. */
+function createLiveTranscriptAnswers(ctx) {
+  const { readStoredSession, sessionResult, advanceForCaller } = ctx;
+  const { currentSessionId } = ctx.projection;
+  const { addSubscriber } = ctx.viewers;
+  const { assertAvailable } = ctx.entries;
+
+  /** A read/subscribe names the transcript window its view wants (none: the
+   *  whole transcript). A window grown past what a resumed runtime holds is
+   *  completed from durable history, sliced from the store's cached display
+   *  history of the record's content. */
+  async function applyTranscriptRequest(entry, params, sessionId) {
+    const request = requestedTranscriptWindow(params);
+    // A model-message read (messageStart) is not a view and leaves the window.
+    if (request || !Number.isInteger(params.messageStart)) requestLiveTranscriptWindow(entry, request);
+    // No baseline the next step can patch: this caller receives the window
+    // whole, so it goes out within its byte budget.
+    if (request && params.baseRevision !== entry.revision) rebudgetTranscriptWindow(entry);
+    await loadLiveTranscriptHead(entry, sessionId, readStoredSession);
+    assertAvailable(entry);
+  }
+
+  /** The caller's answer for `step`, reduced to a page when it proves the rows
+   *  it holds and they fit one answer. A window that would go out whole past
+   *  the request's bounds (transcriptAnswerBounds) does not: a caller already
+   *  at this revision needs no body; any other gets a bounded recovery
+   *  snapshot — the window restarts from a fresh tail, which the views
+   *  attached receive as a step too. */
+  function boundedSessionResult(entry, step, params, baseRevision, extra) {
+    const prepend = params.transcriptPrepend === true;
+    const bounds = transcriptAnswerBounds(requestedTranscriptWindow(params));
+    const result = transcriptPageBody(
+      sessionResult(entry, step, baseRevision, extra, { prepend }),
+      requestedHeldTranscript(params),
+      { byteBudget: bounds.byteBudget }
+    );
+    if (!transcriptWindowOversized(entry, result.full, bounds)) return result;
+    if (baseRevision === step.revision) {
+      const { full: _full, ...bodiless } = result;
+      return bodiless;
+    }
+    restartTranscriptWindow(entry, bounds.maxItems);
+    return sessionResult(entry, advanceForCaller(entry), baseRevision, extra, { prepend });
+  }
+
+  /** Publish BEFORE attaching: the views already there get the frame, the new
+   *  one gets the same revision once in its reply. */
+  const subscribeLive = async (entry, params, viewer, baseRevision) => {
+    await applyTranscriptRequest(entry, params, currentSessionId(entry) || String(params.sessionId || ''));
+    const prepend = params.transcriptPrepend === true;
+    let step = advanceForCaller(entry);
+    // Bounded like a read (boundedSessionResult), before attaching: the new
+    // view receives the restarted tail once, in its reply.
+    const bounds = transcriptAnswerBounds(requestedTranscriptWindow(params));
+    if (transcriptWindowOversized(entry, sessionResult(entry, step, baseRevision, {}, { prepend }).full, bounds)) {
+      restartTranscriptWindow(entry, bounds.maxItems);
+      step = advanceForCaller(entry);
+    }
+    addSubscriber(entry, viewer);
+    return sessionResult(entry, step, baseRevision, { subscribed: true }, { prepend });
+  };
+
+  return { applyTranscriptRequest, boundedSessionResult, subscribeLive };
+}
+
+/** Detaching a view from a live or cold session. */
+function createSessionUnsubscribe(ctx) {
+  const { log, externalViewEntries } = ctx;
+  const { externalEntryForView, sessionOwner } = ctx.projection;
+  const { subscriberToken, dropPendingViewer } = ctx.viewers;
+  const { sessionBusy, releaseProjection, startEvictionSweep } = ctx.retention;
+  const { destroy } = ctx.entries;
+  const { releaseStoredSession } = ctx.storedReader;
+
+  async function unsubscribeSession({ sessionId } = {}, viewer = null) {
+    const id = String(sessionId || '');
+    if (!id) throw new TypeError('sessionId is required');
+    const coldViewers = dropPendingViewer(id, viewer);
+    const owner = sessionOwner(id);
+    if (!owner) {
+      const external = externalEntryForView(id);
+      if (external) {
+        const token = subscriberToken(viewer);
+        if (token) external.subscribers?.delete(token);
+        if ((external.subscribers?.size || 0) === 0) externalViewEntries.delete(id);
+      }
+      // The last cold view left: its disk projection turns idle, kept within
+      // the store's idle budget so a revisit skips the parse.
+      if (!coldViewers) releaseStoredSession(id);
+      return { sessionId: id, unsubscribed: true };
+    }
+    const entry = owner;
+    const token = subscriberToken(viewer);
+    if (token) entry.subscribers?.delete(token);
+    if ((entry.subscribers?.size || 0) === 0) {
+      entry.transcriptView = null;
+      if (entry.reservedOnly && !sessionBusy(entry)) {
+        await destroy(entry, 'unclaimed session reservation', {
+          keepBackgroundWork: true,
+        });
+        return { sessionId: id, unsubscribed: true };
+      }
+      entry.retainedAt = Date.now();
+      releaseProjection(entry);
+      startEvictionSweep();
+    }
+    log(`session unsubscribed session=${id}${token ? ` client=${token}` : ''}`);
+    return { sessionId: id, unsubscribed: true };
+  }
+
+  return { unsubscribeSession };
+}
+
+export function createSessionViewCalls(ctx) {
+  const { readStoredSession, runSessionAction, advanceForCaller } = ctx;
+  const { externalEntryForView, projectionResult, unchangedProjectionResult, sessionOwner } = ctx.projection;
+  /** The owner a concurrent materialization may have produced while a disk
+   *  read was in flight: a daemon-owned runtime outranks an external view. */
+  const lateOwnerFor = (id) => sessionOwner(id) || externalEntryForView(id);
+  const { trackPendingViewer, dropPendingViewer, notePrependViewer } = ctx.viewers;
+  const { retainUnwatched } = ctx.retention;
+  const { assertAvailable, entryForSession, liveEntryForView, bindExternalSessionView } = ctx.entries;
+  const { storedSessionProjection, storedProjectionUnchanged, storedPageOnly, requestedMessageSlice } =
+    ctx.storedReader;
+  const { createSession } = createSessionCreation(ctx);
+  const { applyTranscriptRequest, boundedSessionResult, subscribeLive } = createLiveTranscriptAnswers(ctx);
+  const { unsubscribeSession } = createSessionUnsubscribe(ctx);
+
   async function liveSessionReadResult(entry, params, sessionId, baseRevision) {
     assertAvailable(entry);
     await applyTranscriptRequest(entry, params, sessionId);
@@ -110,11 +208,7 @@ export function createSessionViewCalls(ctx) {
     retainUnwatched(entry, 'headless session read');
     const messages = await requestedMessageSlice(params, sessionId);
     assertAvailable(entry);
-    const prepend = params.transcriptPrepend === true;
-    return transcriptPageBody(
-      sessionResult(entry, step, baseRevision, messages, { prepend }),
-      requestedHeldTranscript(params)
-    );
+    return boundedSessionResult(entry, step, params, baseRevision, messages);
   }
 
   /** The live entry a view can attach to: the owner, an external view, or a
@@ -146,6 +240,13 @@ export function createSessionViewCalls(ctx) {
       assertAvailable(live);
       return { range };
     }
+    const historyRequest = requestedTranscriptHistory(params);
+    if (historyRequest) {
+      // Read-only: no window, baseline or revision of any view moves.
+      const history = await readTranscriptHistory(live, id, readStoredSession, historyRequest);
+      assertAvailable(live);
+      return { history };
+    }
     if (live) {
       return liveSessionReadResult(live, params, id, baseRevision);
     }
@@ -162,7 +263,8 @@ export function createSessionViewCalls(ctx) {
         const lateOwner = lateOwnerFor(id);
         return lateOwner ? liveSessionReadResult(lateOwner, params, id, baseRevision) : held;
       }
-      const projection = await storedSessionProjection(id, openHints, window);
+      const heldRows = requestedHeldTranscript(params);
+      const projection = await storedSessionProjection(id, openHints, window, heldRows, baseProjectionStamp);
       assertAvailable();
       const lateOwner = lateOwnerFor(id);
       if (lateOwner) {
@@ -179,28 +281,18 @@ export function createSessionViewCalls(ctx) {
       });
       const messages = await requestedMessageSlice(params, id);
       assertAvailable();
-      return { ...transcriptPageBody(result, requestedHeldTranscript(params)), ...messages };
+      // The stored reader already proved (or disproved) the held rows, and
+      // its projection then carries only the page above them.
+      const page = storedPageOnly(projection)
+        ? transcriptPageBody(result, heldRows, { proven: true, byteBudget: window?.byteBudget, pageOnly: true })
+        : result;
+      return { ...page, ...messages };
     }
     // Embedders without a store reader keep the legacy load-on-read seam.
     const entry = await entryForSession(id, openHints || {});
     return liveSessionReadResult(entry, params, id, baseRevision);
   }
 
-  /** Publish BEFORE attaching: the views already there get the frame, the new
-   *  one gets the same revision once in its reply. */
-  const subscribeLive = async (entry, params, viewer, baseRevision) => {
-    await applyTranscriptRequest(entry, params, currentSessionId(entry) || String(params.sessionId || ''));
-    const step = advanceForCaller(entry);
-    addSubscriber(entry, viewer);
-    return sessionResult(
-      entry,
-      step,
-      baseRevision,
-      { subscribed: true },
-      { prepend: params.transcriptPrepend === true }
-    );
-  };
-
   async function subscribeSession(params = {}, viewer = null) {
     const { sessionId, open: openHints = {}, baseRevision = null } = params;
     assertAvailable();
@@ -236,41 +328,5 @@ export function createSessionViewCalls(ctx) {
     return subscribeLive(entry, params, viewer, baseRevision);
   }
 
-  async function unsubscribeSession({ sessionId } = {}, viewer = null) {
-    const id = String(sessionId || '');
-    if (!id) throw new TypeError('sessionId is required');
-    const coldViewers = dropPendingViewer(id, viewer);
-    const owner = sessionOwner(id);
-    if (!owner) {
-      const external = externalEntryForView(id);
-      if (external) {
-        const token = subscriberToken(viewer);
-        if (token) external.subscribers?.delete(token);
-        if ((external.subscribers?.size || 0) === 0) externalViewEntries.delete(id);
-      }
-      // The last cold view left: its disk projection turns idle, kept within
-      // the store's idle budget so a revisit skips the parse.
-      if (!coldViewers) releaseStoredSession(id);
-      return { sessionId: id, unsubscribed: true };
-    }
-    const entry = owner;
-    const token = subscriberToken(viewer);
-    if (token) entry.subscribers?.delete(token);
-    if ((entry.subscribers?.size || 0) === 0) {
-      entry.transcriptView = null;
-      if (entry.reservedOnly && !sessionBusy(entry)) {
-        await destroy(entry, 'unclaimed session reservation', {
-          keepBackgroundWork: true,
-        });
-        return { sessionId: id, unsubscribed: true };
-      }
-      entry.retainedAt = Date.now();
-      releaseProjection(entry);
-      startEvictionSweep();
-    }
-    log(`session unsubscribed session=${id}${token ? ` client=${token}` : ''}`);
-    return { sessionId: id, unsubscribed: true };
-  }
-
   return { createSession, readSession, subscribeSession, unsubscribeSession };
 }

package/src/standalone/session-service/stored-reader.mjs

@@ -1,9 +1,72 @@
 import { sanitizeForWire } from '../session-wire-values.mjs';
-import { budgetStoredWindow } from './projection/transcript-window.mjs';
+import {
+  clampStoredPage,
+  clampStoredWindow,
+  holdsTranscriptTail,
+  TRANSCRIPT_RESPONSE_MAX_ITEMS,
+} from './projection/transcript-window.mjs';
 
 const SLOW_STORED_PROJECTION_MS = 250;
 const PROJECTED_FILE_LIMIT = 256;
 
+// Every window of a stored session is a slice of the store's one cached
+// display history, so its rows are the same objects page after page: each
+// is sanitized once (keyed weakly — dropping the store's cache entry
+// releases the clones) and a page costs a slice, not a whole-window clone.
+const wireItems = new WeakMap();
+function wireItem(item) {
+  if (!item || typeof item !== 'object') return sanitizeForWire(item, 2) ?? null;
+  let wire = wireItems.get(item);
+  if (wire === undefined) {
+    wire = sanitizeForWire(item, 2) ?? null;
+    wireItems.set(item, wire);
+  }
+  return wire;
+}
+// The store returns one object per unchanged window, so a repeated read
+// reuses its wire clone (the 1s cold-view refresh would re-clone it).
+const wireSnapshots = new WeakMap();
+function wireSnapshot(snapshot) {
+  let wire = wireSnapshots.get(snapshot);
+  if (!wire) {
+    // The slice's own proof fields stay here.
+    const { items, heldProven: _heldProven, skippedFirstId: _skippedFirstId, ...fields } = snapshot;
+    wire = sanitizeForWire(fields);
+    if (Array.isArray(items)) wire = { ...wire, items: items.map(wireItem) };
+    wireSnapshots.set(snapshot, wire);
+  }
+  return wire;
+}
+
+// A slice's stamp is `<history stamp>/<slice>` (storedHistorySlice); an
+// answer cut from it is served as `<slice stamp>#<rows delivered>`.
+const historyOf = (stamp) => {
+  const window = stamp.includes('#') ? stamp.slice(0, stamp.lastIndexOf('#')) : stamp;
+  return window.includes('/') ? window.slice(0, window.lastIndexOf('/')) : window;
+};
+const deliveredOf = (stamp) => (stamp.includes('#') ? Number(stamp.slice(stamp.lastIndexOf('#') + 1)) : -1);
+/** The stamp an answer of `delivered` rows is served under. Every answer cut
+ *  from one display history is a tail of it, so the rows a caller received
+ *  are named by that history and their count, byte-budget cuts included.
+ *  A request that pages nothing is answered under the caller's own stamp
+ *  (unchanged) when the tail it received already covers this whole answer —
+ *  a host that paged deeper than this window keeps its rows on a refresh;
+ *  any answer that would reveal more is served. */
+function servedStamp(stamp, window, baseProjectionStamp, delivered) {
+  if (typeof stamp !== 'string' || !stamp.includes('/')) return stamp;
+  const own = `${stamp}#${delivered}`;
+  if (window?.paged || typeof baseProjectionStamp !== 'string') return own;
+  const covers = historyOf(baseProjectionStamp) === historyOf(own) && deliveredOf(baseProjectionStamp) >= delivered;
+  return covers ? baseProjectionStamp : own;
+}
+
+const itemLimitFor = (hints, window) => {
+  const requested = window ? window.limit : Number(hints?.resumeOptions?.transcriptItemLimit);
+  return Number.isFinite(requested) && requested > 0 ? requested : 512;
+};
+const projectedKey = (sessionId, hints, window) =>
+  `${sessionId}|${itemLimitFor(hints, window)}:${window?.byteBudget ?? ''}:${window?.pageBase ?? ''}:${window?.paged ? 'p' : ''}`;
+
 export function createStoredSessionReader({
   readStoredSession,
   readStoredGoal,
@@ -38,21 +101,9 @@ export function createStoredSessionReader({
   // that guarantee once several 512-item views exceed its byte budget: it
   // evicts each one just before its next refresh.
   const projectedFiles = new Map();
-  // The stored reader returns its cached projection object for unchanged
-  // content and callers never mutate it, so identity keys the wire clone. The
-  // 1s cold-view refresh otherwise re-sanitized the whole transcript per tick.
-  // Keyed weakly: dropping the store's cache entry releases the clone too.
-  const wireSnapshots = new WeakMap();
-  function wireSnapshot(snapshot, window) {
-    const budget = `${window?.byteBudget ?? ''}:${window?.pageBase ?? ''}`;
-    let cached = wireSnapshots.get(snapshot);
-    if (!cached || cached.budget !== budget) {
-      const wire = cached?.wire ?? sanitizeForWire(snapshot);
-      cached = { wire, budget, value: budgetStoredWindow(wire, window) };
-      wireSnapshots.set(snapshot, cached);
-    }
-    return cached.value;
-  }
+  /** Projections that carry only the page above their caller's proven rows
+   *  (storedPageOnly). */
+  const pageOnly = new WeakSet();
 
   /** Drop every cold projection the store retains for this session. */
   function forgetStoredProjection(sessionId) {
@@ -87,13 +138,6 @@ export function createStoredSessionReader({
     );
   }
 
-  const itemLimitFor = (hints, window) => {
-    const requested = window ? window.limit : Number(hints?.resumeOptions?.transcriptItemLimit);
-    return Number.isFinite(requested) && requested > 0 ? requested : 512;
-  };
-  const projectedKey = (sessionId, hints, window) =>
-    `${sessionId}|${itemLimitFor(hints, window)}:${window?.byteBudget ?? ''}:${window?.pageBase ?? ''}`;
-
   async function fileStampOf(sessionId) {
     if (typeof statStoredSession !== 'function') return null;
     let stamp;
@@ -125,32 +169,68 @@ export function createStoredSessionReader({
   }
 
   /** `window` (from requestedTranscriptWindow) selects a paged tail; without
-   *  one, the resume hint (default 512 items) keeps the legacy page. */
-  async function storedSessionProjection(sessionId, hints, window = null) {
+   *  one, the resume hint (default 512 items) keeps the legacy page. A window
+   *  answers within clampStoredWindow's bounds, above the rows `held`
+   *  (requestedHeldTranscript) when the caller proves it holds them. */
+  async function storedSessionProjection(sessionId, hints, window = null, held = null, baseProjectionStamp = null) {
     if (typeof readStoredSession !== 'function') return null;
     const key = projectedKey(sessionId, hints, window);
     // stat -> read -> stat: the projection is attributed to a file identity
     // only when no write can have landed while it was read.
     const fileStamp = await fileStampOf(sessionId);
-    let snapshot = null;
-    try {
-      snapshot = await readStoredSession(sessionId, {
-        transcriptItemLimit: itemLimitFor(hints, window),
-        trace: traceStoredProjectionRead,
-      });
-    } catch (err) {
-      log(`stored session projection failed session=${sessionId}: ${err?.message || err}`);
-      return null;
+    const read = async (options) => {
+      try {
+        const value = await readStoredSession(sessionId, { trace: traceStoredProjectionRead, ...options });
+        return value && typeof value === 'object' ? value : null;
+      } catch (err) {
+        log(`stored session projection failed session=${sessionId}: ${err?.message || err}`);
+        return undefined;
+      }
+    };
+    const limit = itemLimitFor(hints, window);
+    const pagedHeld = window?.paged ? held : null;
+    // A paged caller's held rows are proven where the history is (by the
+    // history stamp they were served under, or their digest), at any depth:
+    // only the page above them crosses, never the rows held. Unproven, a
+    // fresh tail of at most one answer's rows.
+    const snapshot = await read({
+      transcriptItemLimit: window?.paged && !pagedHeld ? Math.min(limit, TRANSCRIPT_RESPONSE_MAX_ITEMS) : limit,
+      ...(pagedHeld
+        ? {
+            transcriptHeld: pagedHeld,
+            transcriptBaseHistory: typeof baseProjectionStamp === 'string' ? historyOf(baseProjectionStamp) : null,
+            transcriptPage: { maxRows: TRANSCRIPT_RESPONSE_MAX_ITEMS, byteBudget: window.byteBudget },
+          }
+        : {}),
+      paging: Boolean(pagedHeld),
+    });
+    if (!snapshot) return null;
+    const whole = wireSnapshot(snapshot);
+    let paged = Boolean(pagedHeld) && snapshot.heldProven === true;
+    let wire;
+    if (pagedHeld && snapshot.heldProven === undefined && Array.isArray(whole.items)) {
+      // A reader that predates held rows answers the window itself: they are
+      // proven against it here, by digest.
+      const proven = holdsTranscriptTail(whole.items, pagedHeld);
+      wire = clampStoredWindow(whole, window, proven ? pagedHeld.count : 0);
+      if (proven) {
+        wire = { ...wire, items: wire.items.slice(0, wire.items.length - pagedHeld.count) };
+        paged = true;
+      }
+    } else {
+      wire = paged ? clampStoredPage(whole, window, pagedHeld.count) : clampStoredWindow(whole, window, 0);
     }
-    if (!snapshot || typeof snapshot !== 'object') return null;
+    const heldRows = paged ? pagedHeld.count : 0;
+    const delivered = (Array.isArray(wire.items) ? wire.items.length : 0) + heldRows;
+    const projectionStamp = servedStamp(snapshot.projectionStamp, window, baseProjectionStamp, delivered);
     projectedFiles.delete(key);
     if (
       fileStamp !== null &&
-      typeof snapshot.projectionStamp === 'string' &&
-      snapshot.projectionStamp &&
+      typeof projectionStamp === 'string' &&
+      projectionStamp &&
       (await fileStampOf(sessionId)) === fileStamp
     ) {
-      projectedFiles.set(key, { projectionStamp: snapshot.projectionStamp, fileStamp });
+      projectedFiles.set(key, { projectionStamp, fileStamp });
       if (projectedFiles.size > PROJECTED_FILE_LIMIT) projectedFiles.delete(projectedFiles.keys().next().value);
     }
     let goal;
@@ -162,9 +242,9 @@ export function createStoredSessionReader({
         goal = null;
       }
     }
-    const wire = wireSnapshot(snapshot, window);
-    return {
+    const projection = {
       ...wire,
+      ...(typeof projectionStamp === 'string' ? { projectionStamp } : {}),
       sessionId,
       ...(typeof readStoredGoal === 'function' ? { goal: sanitizeForWire(goal, 1) ?? null } : {}),
       ...(typeof readQuotaResume === 'function'
@@ -172,8 +252,14 @@ export function createStoredSessionReader({
         : {}),
       queued: Array.isArray(snapshot.queued) ? wire.queued : [],
     };
+    if (paged) pageOnly.add(projection);
+    return projection;
   }
 
+  /** Whether `projection` carries only the rows above its caller's proven
+   *  ones (the page itself), not those rows. */
+  const storedPageOnly = (projection) => Boolean(projection) && pageOnly.has(projection);
+
   async function requestedMessageSlice(params, sessionId) {
     if (!Number.isInteger(params?.messageStart)) return {};
     const start = Math.max(0, params.messageStart);
@@ -204,6 +290,7 @@ export function createStoredSessionReader({
   return {
     storedSessionProjection,
     storedProjectionUnchanged,
+    storedPageOnly,
     requestedMessageSlice,
     forgetStoredSession: forgetStoredProjection,
     releaseStoredSession: releaseStoredProjection,