@panphora/clayjs 1.13.0 → 1.14.0

package/src/live/fast-lane.js

@@ -4,7 +4,8 @@
 // the same frames through a transport:
 //   start({ open, close, frame, state, writer }) -> stop function
 //   send(clientId, { name, n, ops, epoch }) -> Promise<{ status, body, retryAfter }>
-//   fetchState(clientId) -> Promise<{ epoch, seq, writer, stores } | { status } | null>
+//   fetchState(clientId, since, { signal }) -> Promise<{ epoch, seq, writer, stores } | { status } | null>
+//     answered within STATE_TIMEOUT_MS or abandoned: its signal aborts and the read is made again
 // A new room (a new epoch) holds some of this tab's frames still in flight; see
 // sortAwaiting for how each is sorted.
 //
@@ -13,12 +14,17 @@
 // the room's log rebuilds the value; -1: rewrite now). Both are numbers in the
 // current epoch, taken from the room and never carried across epochs.
 
-import { applyOps, cloneJson } from "./ops.js";
+import { unionRanges, contains, frameSet, hasNumber } from "./provenance.js";
 
 export const MIN_GAP_MS = 40;
 export const MAX_OPS = 128;
 export const RETRY_MS = 500;
-export const FRAME_BYTES = 15 * 1024;
+export const STATE_TIMEOUT_MS = 10_000;
+export const FRAME_BYTES = 63 * 1024;
+// What a host still on the old 16 KB body cap takes: a multi-op frame it
+// answers 413 is packed again at this size for the rest of the session.
+export const OLD_FRAME_BYTES = 15 * 1024;
+const PAGE_STORE = /^page(\.[0-9]+)?$/;
 const BUFFER_MAX = 512;
 const RETRY_MAX_MS = 8000;
 const REVOKED = new Set([401, 403]);
@@ -42,6 +48,12 @@ const unhandled = (status) => status === 429 || status === 503;
  * @param {(name: string) => boolean} [options.held] - a save still on the wire carries some of
  *   this store's pending ops in file mode: nothing of the store is framed until release(name),
  *   so those ops are framed in order if the save does not land, and never if it does
+ * @param {(name: string) => number[]} [options.heldIds] - the ids of those ops: a room state
+ *   cannot say whether they are in its value, so it is not applied to the store until the
+ *   room's receipts hold their frames or hold(name, ids) lets go of them
+ * @param {(name: string, ids: number[]) => boolean} [options.hold] - true to keep waiting for
+ *   the save's answer; false when the ops left pending (the caller gave up on them)
+ * @param {(name: string) => void} [options.taken] - the store took a room state
  * @param {() => void} [options.onStop] - the lane stopped for good
  */
 export function createFastLane({
@@ -54,6 +66,9 @@ export function createFastLane({
   onLanded = () => {},
   onCheckpoint = () => {},
   held = () => false,
+  heldIds = () => [],
+  hold = () => true,
+  taken = () => {},
   onStop = () => {},
   now = () => Date.now(),
   setTimer = setTimeout,
@@ -63,6 +78,9 @@ export function createFastLane({
   let connected = false;
   let synced = false;
   let epoch = null;
+  let receiptGeneration = null;
+  let pageGeneration = null;
+  let provenanceVersion = 0;
   let seq = 0;
   let writer = null;
   let roomNames = new Set();
@@ -75,7 +93,9 @@ export function createFastLane({
   let lastSentAt = -Infinity;
   let holdUntil = 0;
   let timer = null;
+  let readTimer = null;
   let retryDelay = RETRY_MS;
+  let frameBytes = FRAME_BYTES;
   let resyncDelay = RETRY_MS;
   // Bumped when the stream opens or closes, and when a state is taken: a state
   // request answered after either is obsolete.
@@ -85,13 +105,19 @@ export function createFastLane({
   let conn;
   let stateCount = 0;
   let fetchAgain = false;
+  let reads = 0;
+  // A store left the room, so frames went by that its value never took: state
+  // reads ask for every store whole, never for the moves since seq, until a
+  // state is applied.
+  let missed = false;
   let unsubscribe = null;
   // Per store: the next n, ops not yet in a frame, frames sent but not yet seen
   // back (each { n, ops, through, seq, sent, refused, uncertain }), and the
   // newest op id ever put in a frame.
   const lanes = new Map();
+  const abandoned = new Set();
 
-  const tell = (name, event) => entries.get(name)?.store.deliver?.({ code: null, n: null, seq: null, through: null, retryAfter: null, ...event });
+  const tell = (name, event) => entries.get(name)?.store.deliver?.({ code: null, n: null, seq: null, through: null, retryAfter: null, client: clientId, ...event });
 
   function laneOf(name) {
     let lane = lanes.get(name);
@@ -100,30 +126,49 @@ export function createFastLane({
   }
 
   // The store's ops still to frame: pending, past what was framed.
+  // The first frame that reaches an adoption's last op carries its marker.
+  function markAdopted(lane, frame) {
+    if (!lane.adopted || frame.through < lane.adopted.through) return;
+    frame.adopted = lane.adopted.rev;
+    lane.adopted = null;
+  }
+
   function unframed(name, lane) {
     const store = entries.get(name)?.store;
     if (!store) return [];
     return store.pendingEntries().filter((pending) => pending.id > lane.framed);
   }
 
+  // A frame none of whose ops is pending any more (a save at save speed took
+  // them, and the room merges that file) leaves the lane: never sent again.
+  function prune(name, lane) {
+    const store = entries.get(name)?.store;
+    if (!store) return;
+    const live = new Set(store.pendingEntries().map((pending) => pending.id));
+    lane.awaiting = lane.awaiting.filter((frame) => frame === flying || !frame.entries || frame.entries.some((e) => live.has(e.id)));
+  }
+
   // Never applied: every attempt was refused before the room handled it.
   const unapplied = (frame) => frame.refused === true && !frame.uncertain;
 
-  // Stop sending this store: it leaves the room. A frame the room may have
-  // applied is dropped from pending (never replayed over a file that may hold
-  // it); a frame refused unapplied, and ops never framed, stay pending for file
-  // mode. Refused frames come last: a refusal stops sending until the next state.
-  function leaveRoom(name, lane) {
+  // Stop sending this store: it leaves the room. Every op the room has not
+  // confirmed stays pending, so the next save writes it: an op never framed, a
+  // frame refused, a frame that landed but has not come back, and the frame on
+  // the wire, whose answer decides it (decide). The frames stay as records: a
+  // rejoin settles each by the room's answer or receipt, or sends it again.
+  // Leaving wakes the checkpoints (onApplied): what is pending now saves at
+  // save speed. kept: the room still holds the store, so its frames go by
+  // while this tab is out, and the rejoin reads it whole (missed). A store the
+  // room does not hold has no frames to miss.
+  function leaveRoom(name, lane, kept = true) {
     const store = entries.get(name)?.store;
-    let through = 0;
-    for (const frame of lane.awaiting) if (!unapplied(frame)) through = frame.through;
-    if (store && through) store.rebase(store.authoritative, { source: "state", through, cause: "leave" });
+    for (const frame of lane.awaiting) if (frame === flying) frame.undecided = true;
+    if (kept) missed = true;
+    lane.out = true;
     onLeave(name, { epoch, seq });
     lane.unsent = [];
-    lane.awaiting = [];
-    // What is left pending is framed afresh if the store comes back.
-    lane.framed = through;
     store?.setMode("file");
+    onApplied();
   }
 
   function schedule() {
@@ -140,30 +185,25 @@ export function createFastLane({
   // oldest unsent ops of one store; stores take turns.
   function nextFrame() {
     for (const [name, lane] of lanes) {
+      if (!roomNames.has(name) || held(name)) continue;
       const retry = lane.awaiting.find((frame) => !frame.sent);
       if (retry) return { name, lane, frame: retry };
     }
     for (const [name, lane] of lanes) {
       if (!lane.unsent.length || !roomNames.has(name) || held(name)) continue;
-      // Packed by bytes as well as count: the host refuses a body over 16 KB.
+      // Packed by bytes as well as count, so a host still on a 64 KB body cap
+      // takes every frame; one op larger than a frame goes in a frame of its own.
       let size = byteSize({ name, n: lane.n + 1, ops: [], epoch });
       let count = 0;
       while (count < lane.unsent.length && count < MAX_OPS) {
         const more = byteSize(lane.unsent[count].op) + 1;
-        if (size + more > FRAME_BYTES) break;
+        if (count && size + more > frameBytes) break;
         size += more;
         count++;
       }
-      if (count === 0) {
-        const [entry] = lane.unsent.splice(0, 1);
-        console.warn(`clay.live("${name}"): one update was larger than ${FRAME_BYTES} bytes, so it was undone`);
-        const store = entries.get(name)?.store;
-        store?.rebase(store.authoritative, { source: "state", through: entry.id, cause: "undone" });
-        tell(name, { phase: "undone", code: "op-too-large", through: entry.id });
-        continue;
-      }
       const take = lane.unsent.splice(0, count);
-      const frame = { n: ++lane.n, ops: take.map((entry) => entry.op), through: take[take.length - 1].id, seq: null, sent: false };
+      const frame = { n: ++lane.n, ops: take.map((entry) => entry.op), entries: take, first: take[0].id, through: take[take.length - 1].id, seq: null, sent: false, receiptGeneration, pageGeneration };
+      markAdopted(lane, frame);
       lane.framed = Math.max(lane.framed, frame.through);
       lane.awaiting.push(frame);
       return { name, lane, frame };
@@ -179,9 +219,11 @@ export function createFastLane({
     lanes.delete(name);
     lanes.set(name, lane);
     const sentEpoch = epoch;
+    frame.epoch = sentEpoch;
+    frame.client = clientId;
     frame.sentOn = connection;
     frame.sent = true;
-    tell(name, { phase: "sent", n: frame.n, through: frame.through });
+    tell(name, { phase: "sent", n: frame.n, first: frame.first, through: frame.through });
     // Refusal is evidence about earlier attempts only: this one may apply.
     frame.refused = false;
     inFlight = true;
@@ -189,7 +231,7 @@ export function createFastLane({
     lastSentAt = now();
     let result;
     try {
-      result = await transport.send(clientId, { name, n: frame.n, ops: frame.ops, epoch: sentEpoch, ...(conn !== undefined && { conn }) });
+      result = await transport.send(clientId, { name, n: frame.n, ops: frame.ops, epoch: sentEpoch, ...(conn !== undefined && { conn }), ...(frame.receiptGeneration !== null && { receiptGeneration: frame.receiptGeneration }), ...(frame.pageGeneration !== null && PAGE_STORE.test(name) && { pageGeneration: frame.pageGeneration }), ...(frame.adopted && { adopted: frame.adopted }) });
     } catch {
       result = null;
     }
@@ -212,6 +254,19 @@ export function createFastLane({
       frame.refused = true;
       frame.sent = false;
       frame.seq = null;
+      if (frame.epoch !== epoch) frame.receiptGeneration = receiptGeneration;
+      if (frame.epoch !== epoch) frame.pageGeneration = pageGeneration;
+      return;
+    }
+    // Its store left the room meanwhile: its ops stay pending for the save,
+    // and the frame waits for the rejoin, which settles it by its seq or the
+    // room's receipt.
+    if (!roomNames.has(name)) {
+      if (status >= 200 && status < 300 && Number.isInteger(body?.seq) && !body?.stale) frame.seq = body.seq;
+      else {
+        frame.uncertain = true;
+        frame.uncertainSince ??= frame.sentOn;
+      }
       return;
     }
     lane.awaiting.splice(lane.awaiting.indexOf(frame), 1);
@@ -223,6 +278,7 @@ export function createFastLane({
   // authoritative values now, whether its answer or its event said so.
   function settleAwaiting() {
     for (const [name, lane] of lanes) {
+      if (!roomNames.has(name)) continue;
       let through;
       while (lane.awaiting.length && lane.awaiting[0].seq !== null && lane.awaiting[0].seq <= seq) {
         through = lane.awaiting.shift().through;
@@ -303,24 +359,41 @@ export function createFastLane({
       console.warn(`clay.live("${name}"): the room has no such store, so it stays at save speed (${reason})`);
       frame.refused = true;
       roomNames.delete(name);
-      leaveRoom(name, lane);
+      leaveRoom(name, lane, false);
       return;
     }
     lane.awaiting.splice(lane.awaiting.indexOf(frame), 1);
+    // A host still on the old body cap: pack its ops again, smaller, and send
+    // them again. Only an op too large on its own is refused. That host's 413
+    // comes from its body parser, with no code; the room's own size refusal
+    // (a store or room cap, code "too-large") is a refusal like any other.
+    if (status === 413 && !body?.code && frame.entries?.length > 1 && frameBytes > OLD_FRAME_BYTES) {
+      frameBytes = OLD_FRAME_BYTES;
+      console.warn(`clay.live("${name}"): the host takes smaller updates, so they go in frames of ${frameBytes} bytes`);
+      lane.unsent.unshift(...frame.entries);
+      if (frame.adopted) lane.adopted = { rev: frame.adopted, through: frame.through };
+      // Unframed again: a new room's state frames them afresh (unframed()).
+      lane.framed = frame.first - 1;
+      return;
+    }
     const store = entries.get(name)?.store;
-    tell(name, { phase: "refused", code: body?.code ?? "refused", n: frame.n, through: frame.through });
+    const code = body?.code ?? (status === 413 && frame.entries?.length === 1 ? "too-large" : "refused");
+    tell(name, { phase: "refused", code, n: frame.n, from: frame.first, through: frame.through, ...(body?.code === "receipt-expired" && { ops: frame.ops }) });
     console.warn(`clay.live("${name}"): the host refused an update, so it was undone (${reason})`);
-    store?.rebase(store.authoritative, { source: "state", through: frame.through, cause: "refused" });
+    store?.rebase(store.authoritative, { source: "state", drop: frame.first === undefined ? undefined : [frame.first, frame.through], through: frame.first === undefined ? frame.through : undefined, cause: "refused" });
+    if (body?.code === "receipt-expired") resync();
   }
 
   function apply(frame) {
     seq = frame.seq;
     const store = entries.get(frame.name)?.store;
-    if (!store || !roomNames.has(frame.name)) return;
-    let next;
-    try {
-      next = applyOps(cloneJson(store.authoritative), frame.ops);
-    } catch {
+    if (!store || abandoned.has(frame.name)) return;
+    if (!roomNames.has(frame.name)) {
+      missed = true;
+      return;
+    }
+    const ops = store.checkOps(frame.ops);
+    if (!ops) {
       resync();
       return;
     }
@@ -335,7 +408,7 @@ export function createFastLane({
         lane.awaiting.splice(0, i + 1);
       }
     }
-    store.rebase(next, { source: own ? "state" : "remote", through, frame: { seq: frame.seq, from: frame.from, n: frame.n, ops: frame.ops } });
+    store.rebaseOps(ops, { source: own ? "state" : "remote", through, frame: { seq: frame.seq, from: frame.from, n: frame.n, ops: frame.ops } });
     entries.get(frame.name).last = frame.seq;
     onApplied();
     if (frame.checkpoint === true) onCheckpoint();
@@ -374,20 +447,37 @@ export function createFastLane({
   function sortAwaiting(awaiting, room) {
     const seen = room.seen ? (room.seen[clientId] ?? 0) : null;
     const resend = [];
-    let through = 0;
+    const dropIds = [];
     for (const frame of awaiting) {
-      if (seen !== null && frame.n <= seen) through = frame.through;
+      if ((seen !== null && frame.n <= seen) || hasNumber(room.saved, frame.n)) dropIds.push(...frame.entries.map((e) => e.id));
       else if (frame.sent && frame === flying) {
         // Still on the wire: its answer decides.
         frame.undecided = true;
         resend.push(frame);
       } else if (unapplied(frame)) resend.push(frame);
-      else through = frame.through;
+      else dropIds.push(...frame.entries.map((e) => e.id));
+    }
+    return { resend, dropIds };
+  }
+
+  function waiting(name, lane, room, fresh) {
+    const ids = heldIds(name);
+    if (!ids.length) return false;
+    if (!fresh) {
+      const covered = new Set();
+      for (const frame of lane.awaiting) {
+        if (hasNumber(room.saved, frame.n)) for (const op of frame.entries ?? []) covered.add(op.id);
+      }
+      if (ids.every((id) => covered.has(id))) return false;
     }
-    return { resend, through };
+    if (!hold(name, ids)) {
+      prune(name, lane);
+      return false;
+    }
+    return true;
   }
 
-  function applyState(state) {
+  function applyState(state, read = 0) {
     if (stopped || !state || typeof state.epoch !== "string") return;
     stateCount++;
     // Older than what this tab already applied: keep what it has.
@@ -396,44 +486,103 @@ export function createFastLane({
       return;
     }
     const fresh = state.epoch !== epoch;
+    provenanceVersion = Number.isInteger(state.provenanceVersion) ? state.provenanceVersion : 0;
+    receiptGeneration = Number.isSafeInteger(state.receiptGeneration) ? state.receiptGeneration : null;
+    const priorGeneration = pageGeneration;
+    pageGeneration = typeof state.pageTransition?.id === "string" ? state.pageTransition.id : null;
+    const replaced = pageGeneration !== priorGeneration;
     let joined = false;
+    // Every store is read whole here.
+    missed = false;
     epoch = state.epoch;
     seq = Number.isInteger(state.seq) ? state.seq : 0;
     writer = state.writer ?? null;
     if ("conn" in state) conn = state.conn;
     const stores = state.stores || {};
     roomNames = new Set(Object.keys(stores));
+    for (const name of abandoned) roomNames.delete(name);
+    let skipped = false;
+    let readDue = false;
     for (const [name, entry] of entries) {
+      if (abandoned.has(name)) continue;
       const room = stores[name];
       const lane = laneOf(name);
+      prune(name, lane);
+      const held = lane.room;
+      lane.room = !!room;
       if (!room) {
-        leaveRoom(name, lane);
+        // Not in the room (too large, too many stores, or opened after it):
+        // there are no frames of it to miss. Already out: its value still
+        // descends from where it left. A store the room held and has now
+        // dropped was replaced by a document without it, which a 404 to this
+        // tab's next frame would also say. A replacement always installs a new page
+        // transition; a store dropped for size leaves it, and leaves quietly.
+        if (!lane.out) {
+          if (held && replaced) tell(name, { phase: "left", code: "no-store" });
+          leaveRoom(name, lane, false);
+        }
+        // A read the barrier waited for says no room holds this store: the file is its authority.
+        if (lane.after !== undefined && read >= lane.after) {
+          lane.after = undefined;
+          lane.deferred = false;
+          taken(name);
+        }
+        continue;
+      }
+      const behind = lane.after !== undefined && read < lane.after;
+      if (behind || waiting(name, lane, room, fresh || lane.stale === true)) {
+        roomNames.delete(name);
+        lane.deferred = true;
+        if (fresh) lane.stale = true;
+        if (behind) readDue = true;
+        skipped = true;
         continue;
       }
+      const wholly = fresh || lane.stale === true;
+      lane.deferred = false;
+      lane.stale = false;
+      lane.after = undefined;
       const rejoined = entry.store.handle.status.mode === "file";
+      lane.out = false;
       entry.store.setMode("fast");
       entry.last = Number.isInteger(room.last) ? room.last : 0;
       entry.landed = Number.isInteger(room.landed) ? room.landed : 0;
-      if (fresh) {
-        const { resend, through } = sortAwaiting(lane.awaiting, room);
+      const expired = [];
+      if (!wholly && receiptGeneration !== null) {
+        const seen = room.seen?.[clientId];
+        lane.awaiting = lane.awaiting.filter((frame) => {
+          const known = hasNumber(room.saved, frame.n) || (seen !== undefined && frame.n <= seen) || (frame.seq !== null && frame.seq <= seq);
+          if (known || (frame.receiptGeneration ?? 0) === receiptGeneration) return true;
+          expired.push(...frame.entries.map((e) => e.id));
+          tell(name, { phase: "refused", code: "receipt-expired", n: frame.n, from: frame.first, through: frame.through, ops: frame.ops });
+          console.warn(`clay.live("${name}"): the room retired an update receipt, so the update was not replayed. Check the saved value before restoring it.`);
+          return false;
+        });
+      }
+      if (wholly) {
+        const { resend, dropIds } = sortAwaiting(lane.awaiting, room);
         for (const frame of resend) {
           if (frame.undecided) continue;
           frame.sent = false;
           frame.seq = null;
+          frame.receiptGeneration = receiptGeneration;
+          frame.pageGeneration = pageGeneration;
         }
         lane.awaiting = resend;
-        entry.store.rebase(room.value, { source: "state", through: through || undefined, room: { seq, fresh: true, moves: state.moves?.[name] ?? null, floor: Number.isInteger(room.floor) ? room.floor : null } });
+        entry.store.rebase(room.value, { source: "state", dropIds, room: { seq, fresh: true, moves: state.moves?.[name] ?? null, floor: Number.isInteger(room.floor) ? room.floor : null } });
         lane.unsent = unframed(name, lane);
       } else {
         const seen = room.seen ? room.seen[clientId] : undefined;
         const next = [];
-        let through;
+        const dropIds = [...expired];
         for (const frame of lane.awaiting) {
-          if (frame === flying) {
+          if (hasNumber(room.saved, frame.n)) {
+            dropIds.push(...frame.entries.map((e) => e.id));
+          } else if (frame === flying) {
             next.push(frame);
           } else if ((frame.seq !== null && frame.seq <= seq) || (seen !== undefined && frame.n <= seen)) {
             // In this state, by its answer or by the room's receipt.
-            through = frame.through;
+            dropIds.push(...frame.entries.map((e) => e.id));
           } else if (frame.seq !== null) {
             // Answered as applied after this state was read: its event is on its way.
             next.push(frame);
@@ -446,22 +595,25 @@ export function createFastLane({
             next.push(frame);
           } else {
             // Unanswered, and the stream reconnected since: its receipt may be gone.
-            through = frame.through;
+            dropIds.push(...frame.entries.map((e) => e.id));
           }
         }
         lane.awaiting = next;
-        entry.store.rebase(room.value, { source: "state", through, room: { seq, fresh: false, moves: state.moves?.[name] ?? null, floor: Number.isInteger(room.floor) ? room.floor : null } });
+        entry.store.rebase(room.value, { source: "state", dropIds, room: { seq, fresh: false, moves: state.moves?.[name] ?? null, floor: Number.isInteger(room.floor) ? room.floor : null } });
         // Back in the room after a spell at save speed: frame what was made meanwhile.
         if (rejoined) {
           lane.unsent = unframed(name, lane);
           joined = true;
         }
       }
+      taken(name);
     }
+    if (skipped) missed = true;
     if (fresh || joined) onEpoch(epoch);
     onApplied();
     onWriter();
     drain();
+    if (readDue) resync();
   }
 
   // Back in step: apply what arrived while the state was being read.
@@ -484,11 +636,21 @@ export function createFastLane({
     fetching = true;
     fetchAgain = false;
     synced = false;
-    const asked = { connection, stateCount };
+    const asked = { connection, stateCount, read: ++reads };
     let state = null;
+    const abort = typeof AbortController === "function" ? new AbortController() : null;
+    const expired = new Promise((resolve) => {
+      readTimer = setTimer(() => {
+        readTimer = null;
+        abort?.abort();
+        resolve(null);
+      }, STATE_TIMEOUT_MS);
+    });
     try {
-      state = await transport.fetchState(clientId, epoch !== null && seq > 0 ? { epoch, seq } : null);
+      state = await Promise.race([transport.fetchState(clientId, epoch !== null && seq > 0 && !missed ? { epoch, seq } : null, abort ? { signal: abort.signal } : {}), expired]);
     } catch {}
+    if (readTimer !== null) clearTimer(readTimer);
+    readTimer = null;
     fetching = false;
     if (stopped) return;
     if (asked.connection !== connection || fetchAgain) {
@@ -501,13 +663,37 @@ export function createFastLane({
     }
     if (state && typeof state.epoch === "string") {
       resyncDelay = RETRY_MS;
-      applyState(state);
+      applyState(state, asked.read);
       return;
     }
     if (state && STATE_GONE.has(state.status)) {
       stop();
       return;
     }
+    // The host has no room for this document now: it holds as much live data
+    // as it can (503 busy), or it is not answering (any other 503). Every
+    // store goes at save speed, with its own pending ops, so a save never
+    // writes the room's stale value. The lane asks again after Retry-After, a
+    // minute for busy, or its usual backoff.
+    if (state && state.status === 503) {
+      const busy = state.code === "busy";
+      for (const [name, entry] of entries) {
+        if (entry.store.handle.status.mode !== "fast") continue;
+        tell(name, { phase: "left", code: busy ? "busy" : "unavailable" });
+        console.warn(`clay.live("${name}"): the host has no room for this document now, so it stays at save speed for now`);
+        leaveRoom(name, laneOf(name));
+      }
+      roomNames = new Set();
+      if (!connected) return;
+      if (busy || state.retryAfter > 0) {
+        resyncDelay = RETRY_MS;
+        setTimer(resync, (state.retryAfter > 0 ? state.retryAfter : 60) * 1000);
+      } else {
+        setTimer(resync, resyncDelay);
+        resyncDelay = Math.min(resyncDelay * 2, RETRY_MAX_MS);
+      }
+      return;
+    }
     if (connected) {
       setTimer(resync, resyncDelay);
       resyncDelay = Math.min(resyncDelay * 2, RETRY_MAX_MS);
@@ -519,9 +705,12 @@ export function createFastLane({
     stopped = true;
     if (timer !== null) clearTimer(timer);
     timer = null;
+    if (readTimer !== null) clearTimer(readTimer);
+    readTimer = null;
     unsubscribe?.();
     for (const [name, entry] of entries) {
       const lane = lanes.get(name);
+      if (lane?.out) continue;
       if (lane) leaveRoom(name, lane);
       else {
         onLeave(name, { epoch, seq });
@@ -545,7 +734,12 @@ export function createFastLane({
       buffered = [];
     },
     frame: onFrame,
-    state: applyState,
+    // A broadcast state carries no moves. While a store is out, the rejoin
+    // goes through this tab's own read, which carries them.
+    state(state) {
+      if (missed && state && !("moves" in state)) resync();
+      else applyState(state);
+    },
     // The room's writer, and how far the file reaches when a save landed.
     writer(data) {
       if (!data || data.epoch !== epoch) return;
@@ -578,13 +772,103 @@ export function createFastLane({
       ops.forEach((op, i) => lane.unsent.push({ id: first + i, op }));
       schedule();
     },
+    // The store's ops through `through` merged the file article with revision
+    // rev into the page: the frame that carries them tells the room, so its
+    // checkpoint knows the room holds that edit. A frame already sent leaves it
+    // to the next one.
+    // The store's history is not the room's (its page was rebuilt while this tab was
+    // away): nothing of it is sent again, and the room's frames for it are ignored.
+    abandon(name) {
+      if (abandoned.has(name)) return;
+      abandoned.add(name);
+      roomNames.delete(name);
+      const lane = laneOf(name);
+      lane.awaiting = lane.awaiting.filter((frame) => frame === flying);
+      lane.unsent = [];
+      lane.adopted = null;
+    },
+    adopted(name, rev, through) {
+      if (stopped || !roomNames.has(name)) return;
+      const lane = laneOf(name);
+      const waiting = lane.awaiting.find((frame) => !frame.sent && frame.through >= through);
+      if (waiting) waiting.adopted = rev;
+      else lane.adopted = { rev, through };
+    },
     // The save that held this store ended: frame whatever is still pending past
-    // what was framed (an accepted save's ops have left pending).
-    release(name) {
-      if (stopped || epoch === null || !roomNames.has(name)) return;
-      laneOf(name).unsent = unframed(name, laneOf(name));
+    // what was framed (an accepted save's ops have left pending). A state it
+    // kept from the store, or a value the caller kept (read), is replaced by a
+    // read of the room, which frames what is pending when the store takes it.
+    release(name, { read = false } = {}) {
+      if (stopped) return;
+      const lane = laneOf(name);
+      // A read release arms the barrier even before the first epoch exists: the
+      // state that may apply has to be one read after this, and a lane that has
+      // not joined a room yet has nothing to fetch.
+      if (lane.deferred || read) {
+        lane.after = reads + 1;
+        if (epoch !== null && connected) resync();
+        return;
+      }
+      if (epoch === null) return;
+      if (!roomNames.has(name)) return;
+      prune(name, lane);
+      lane.unsent = unframed(name, lane);
       schedule();
     },
+    // Lifetime frame counter retained for the legacy fixture harness.
+    framed(name) {
+      return lanes.get(name)?.n ?? 0;
+    },
+    pendingFrames(name, at, { reserve = false } = {}) {
+      const lane = lanes.get(name);
+      if (reserve && lane && clientId && epoch === at?.epoch) {
+        const pending = unframed(name, lane);
+        while (pending.length) {
+          let size = byteSize({ name, n: lane.n + 1, ops: [], epoch });
+          let count = 0;
+          while (count < pending.length && count < MAX_OPS) {
+            const more = byteSize(pending[count].op) + 1;
+            if (count && size + more > frameBytes) break;
+            size += more;
+            count++;
+          }
+          const take = pending.splice(0, count);
+          const frame = { n: ++lane.n, ops: take.map((e) => e.op), entries: take,
+            first: take[0].id, through: take[take.length - 1].id, seq: null,
+            sent: false, refused: true, epoch, client: clientId, receiptGeneration, pageGeneration };
+          markAdopted(lane, frame);
+          lane.awaiting.push(frame);
+          lane.framed = frame.through;
+        }
+        lane.unsent = [];
+      }
+      const ids = new Set(entries.get(name)?.store.pendingEntries().map((e) => e.id) ?? []);
+      let frames = [];
+      let complete = true;
+      for (const frame of lane?.awaiting ?? []) {
+        const present = frame.entries.filter((e) => ids.has(e.id));
+        if (!present.length) continue;
+        if (present.length !== frame.entries.length || frame.epoch !== at?.epoch || !frame.client) {
+          complete = false;
+          continue;
+        }
+        frames = unionRanges(frames, [[frame.client, [[frame.n, frame.n]]]]);
+      }
+      return { frames, complete };
+    },
+    captured(name, at, by) {
+      const lane = lanes.get(name);
+      if (!lane || !at || at.epoch !== epoch) return [];
+      const included = frameSet(by);
+      const dropIds = [];
+      lane.awaiting = lane.awaiting.filter((frame) => {
+        const held = frame.epoch === at.epoch &&
+          (contains(included, frame.client, frame.n) || (frame.seq !== null && frame.seq <= at.seq));
+        if (held) dropIds.push(...frame.entries.map((e) => e.id));
+        return !held;
+      });
+      return dropIds;
+    },
     // Read the room again: a store opened after this tab joined, or a save the
     // room merged whose state may not have arrived yet.
     refresh() {
@@ -593,11 +877,14 @@ export function createFastLane({
     storeOpened() {
       if (epoch !== null && connected) resync();
     },
+    roomBound(name) {
+      return !stopped && lanes.get(name)?.room === true;
+    },
     isWriter() {
       return writer !== null && writer === clientId;
     },
     get status() {
-      return { connected, synced, epoch, seq, writer, clientId, stopped };
+      return { connected, synced, epoch, seq, writer, clientId, stopped, provenanceVersion, receiptGeneration };
     },
     stop,
   };