@heycys/gallery 0.1.1 → 0.1.2

package/browser/editor/page/autosave.mjs

@@ -29,11 +29,13 @@ import { unpack } from "./sync-state.mjs";
 // (settled) and the reader pauses, the page reloads to show it, where the reader was
 // (reloadView). Only when that write put texts the reader committed back as they were (an Agent
 // writing the whole file from what it read earlier) does the page ask first: it keeps the texts it
-// committed (commits.committed(), and those of its earlier loads in sessionStorage), the blocks it
-// made and moved this load (commits.placedUnits()) and what its components wrote (commits.written(),
-// those of earlier loads too), and the server says which the file now has as before (POST
-// /__gallery/edit/reverted): a text as it was, a block it made gone, a block it moved back in the unit
-// it was in, a part as before a write of the page's.
+// committed (commits.committed(), and those of its earlier loads: the journal), the blocks it
+// made and moved this load (commits.placedUnits(), and those earlier loads made) and what its
+// components wrote (commits.written(), those of earlier loads too), and the server says which the
+// file now has as before (POST /__gallery/edit/reverted): a text as it was, a block it made gone, a
+// block it moved back in the unit it was in, a part as before a write of the page's. A page going away
+// keeps all of it in localStorage (journalKey) with the version of the file it last knew; the next
+// page of the document, in this tab or another, opening on another version, asks at once.
 
 const IDLE = 1600;
 const LONGEST = 8000;
@@ -41,6 +43,7 @@ const RETRY = [1000, 2000, 5000, 10000, 30000];
 const QUIET = 1500; // how long the reader has changed nothing before the page reloads by itself
 const STORE_EVERY = 1000; // the crash buffer while typing, at most this often
 const JOURNAL_FOR = 60 * 60 * 1000; // how long a committed text is checked for being put back
+const JOURNAL_SIZE = 100_000; // the most characters one document's journal keeps (the newest entries)
 const OWN_FOR = 5000; // how long the live-reload channel may still announce a version this page wrote
 // A page of the Agent's own (its address's ?agent: the Agent 自用 one gallery open prints, gallery
 // component try's): its commits say so (`agent`), and are no reader's edit to the review of the
@@ -52,6 +55,33 @@ const AGENT_PAGE = typeof location !== "undefined" && new URLSearchParams(locati
 // names it but the words it had.
 const sameText = (block) => JSON.stringify(block?.title ? "title" : block?.unit ? [block.unit.id ?? block.unit.blockId ?? [block.unit.key, block.unit.open], block.self ? true : block.path ?? null] : { ...block, before: undefined });
 
+// The journal's texts (journal()) with those of commits not answered yet (`requests`: on their way, or
+// the crash buffer's) taken as committed, as committedText (commit.mjs) takes a commit's: what each
+// replaced first stays where the text started, what it was between is `earlier`, and one back as it
+// was first and nothing between is none; committed now (`at`).
+function folded(texts, requests) {
+  const named = new Map(texts.map((entry) => [sameText(entry.block), entry]));
+  let serial = 0;
+  for (const request of requests) {
+    for (const text of request?.texts ?? []) {
+      const mine = text?.parts?.find((part) => part.keep)?.html;
+      if (typeof mine !== "string" || !text.block) continue;
+      const name = sameText(text.block);
+      const was = named.get(name);
+      const original = was?.original ?? text.block.before;
+      if (typeof original !== "string" || (was && was.mine === mine)) continue;
+      const earlier = [...new Set([...(was?.earlier ?? []), ...(was ? [was.mine] : [])])].filter((each) => each !== mine && each !== original).slice(-TEXTS_KEPT);
+      if (mine === original && earlier.length === 0) {
+        named.delete(name);
+        continue;
+      }
+      const entry = { key: was?.key ?? `f${serial++}`, block: { ...text.block, before: mine }, original, mine, ...(earlier.length > 0 ? { earlier } : {}), ...(was?.time ? { time: was.time } : {}), at: Date.now() };
+      named.set(name, entry);
+    }
+  }
+  return [...named.values()];
+}
+
 /**
  * map: the page's map (slug, version, token); commits: createCommits(); blocked(): commits wait
  * (an input method is composing); changedAt(): when the reader last changed anything; holding(asked):
@@ -62,14 +92,14 @@ const sameText = (block) => JSON.stringify(block?.title ? "title" : block?.unit
  * warn("storage"): the crash buffer could not be written; storage: localStorage
  * (get/set/remove/keys); tab(): this tab's id (a duplicated tab takes a new one); notice(): what the
  * page says after it reloads by itself (a merge it just made), or null; session: sessionStorage
- * (get/set/remove); reverted(entries): texts, blocks and components' writes of the reader's that
+ * (get/remove), read once for the journal an earlier Gallery kept there; reverted(entries): texts, blocks and components' writes of the reader's that
  * someone else's write put back, for the reader to decide on (decide) before the page shows that
  * write (a component's with `written`: the parts, by name, and the hashes the file holds of them);
- * before(): called right
+ * listed(): words were added to what the page could not put back (lostKey), to be shown; before(): called right
  * before a commit goes, a promise it waits for (or null): what goes with the edit elsewhere is told
  * first (where the words of the reader's 批注 went: annotate/ sync).
  */
-export function createAutosave({ map, commits, blocked, changedAt, holding = () => false, refresh, applied, failed, warn = () => {}, storage, tab, notice = () => null, session = null, reverted = () => {}, before = () => null }) {
+export function createAutosave({ map, commits, blocked, changedAt, holding = () => false, refresh, applied, failed, warn = () => {}, storage, tab, notice = () => null, session = null, reverted = () => {}, listed = () => {}, before = () => null }) {
   let known = map.version; // the file's version as the page last knew it
   // Versions this page's commits wrote (and the one it opened on), in order, and when: the
   // live-reload channel announces them too, a little later, in the order they were written. Only
@@ -100,17 +130,39 @@ export function createAutosave({ map, commits, blocked, changedAt, holding = ()
   let unstored = false; // the crash buffer could not be written
   let storedFrom = null; // what the page held (collect()'s result) when the buffer was last written with nothing on its way; null: write it anew
   const events = []; // [version, when]: what the live-reload channel announced while a commit was on its way
-  // Texts committed by this page's earlier loads (journalKey), still checked for a while, each under a
-  // key of its own (`c<n>`: an earlier load's keys name its blocks, as this one's name others); what
-  // their components wrote is the commits' own again (carry), by instance.
-  const journalKey = `gallery-edit:${map.slug}:journal`;
+  // What earlier pages of the document committed, made and wrote (the journal, journalKey: what each
+  // page kept as it went away, by tab), taken by this one as its own: the texts, still checked for an
+  // hour, each under a key of its own (`c<n>`: an earlier load's keys name its blocks, as this one's
+  // name others); the blocks they made (`m<n>`: by the file's id, with their words), until the file is
+  // found without one (listed) or the page no longer shows one it was found with (the reader deleted
+  // it); what their components wrote, the commits' own again (carry), by instance. This tab's are taken
+  // as the page is made, those of tabs no longer open once it knows which are (opened).
   let carried = [];
+  let carriedMade = [];
+  let textSerial = 0;
+  let madeSerial = 0;
+  // The version of the file the page last knew: every write up to it the page's own or asked of (the
+  // revert check answered about it, what it put back held for the reader). What the page keeps as it
+  // goes away says it; null while a question about what earlier pages kept is not answered yet.
+  let seen = map.version;
+  let asking = false; // what earlier pages kept, taken, is to be asked of (the file not the version they last knew)
+  const adopt = (departures) => {
+    let ask = false;
+    for (const { known, entries } of departures) {
+      if (known !== map.version) ask = true;
+      carried.push(...entries.filter((entry) => entry.instance === undefined && entry.made === undefined && entry.block).map((entry) => ({ ...entry, key: `c${textSerial++}` })));
+      carriedMade.push(...entries.filter((entry) => typeof entry.made === "string" && !carriedMade.some((other) => other.id === entry.made))
+        .map(({ made, parent, text, time }) => ({ key: `m${madeSerial++}`, id: made, parent: parent ?? null, text: String(text ?? ""), time, confirmed: known === map.version })));
+      commits.carry(entries.filter((entry) => entry.instance !== undefined).map(({ instance, parts, time }) => ({ id: instance, parts, time })));
+    }
+    if (ask) {
+      asking = true;
+      seen = null;
+    }
+  };
   try {
-    const kept = (JSON.parse(session?.get(journalKey) ?? "[]") ?? []).filter((entry) => entry && Date.now() - entry.time < JOURNAL_FOR);
-    carried = kept.filter((entry) => entry.instance === undefined).map((entry, index) => ({ ...entry, key: `c${index}` }));
-    commits.carry(kept.filter((entry) => entry.instance !== undefined).map(({ instance, parts, time }) => ({ id: instance, parts, time })));
+    adopt([...legacyJournal(session, map.slug), ...takeJournal(storage, map.slug, (id) => id === tab())]);
   } catch {}
-  session?.remove(journalKey);
   const reverts = new Map(); // key -> entry: put back by someone else, waiting for the reader
   let checking = false;
   const waiters = [];
@@ -231,8 +283,11 @@ export function createAutosave({ map, commits, blocked, changedAt, holding = ()
       retryAt = 0;
       offline = false;
       known = receipt.version;
+      // Written over the version the page last knew, no one else's write between: the page knows this one.
+      if (!receipt.foreign && seen !== null && sent.request.known === seen) seen = receipt.version;
       if (receipt.wrote !== false) own.push({ version: receipt.version, at: Date.now() }); // one that changed nothing wrote no version
       if (receipt.foreign) foreign = true;
+      deleted(sent.request, receipt);
       applied(commits.apply(sent.pending, receipt, { alone: !foreign }), receipt);
       after = commits.collect();
       recount(after);
@@ -339,7 +394,7 @@ export function createAutosave({ map, commits, blocked, changedAt, holding = ()
     if (closed) return;
     leaving = true;
     store();
-    keepJournal();
+    keepJournal([flight?.request ?? parked?.request, buffer]); // what is on its way or in the buffer, as the file is to have it
     if (flight || parked || stopped || waiting() === 0 || !buffer) return; // what is on its way is in the buffer
     postCommit(map, buffer, { keepalive: true }).catch(() => {});
   }
@@ -392,18 +447,40 @@ export function createAutosave({ map, commits, blocked, changedAt, holding = ()
     }
     const texts = journal();
     const units = commits.placedUnits();
+    // The blocks earlier pages made: those the file was not yet found with, and those the page shows (one
+    // found with it and no longer shown, the reader deleted).
+    const made = carriedMade.filter((entry) => !entry.confirmed || commits.unitOf(entry.id) !== null);
     const instances = commits.written();
-    if (texts.length === 0 && units.length === 0 && instances.length === 0) return true;
+    if (texts.length === 0 && units.length === 0 && made.length === 0 && instances.length === 0) return true;
     checking = true;
     let answer = null;
     try {
-      const response = await postJson("/__gallery/edit/reverted", map.token, { slug: map.slug, opening: map.version, texts: texts.map(({ key, block, original, earlier }) => ({ key, block, original, ...(earlier ? { earlier } : {}) })), units, instances: instances.map(({ key, id, parts }) => ({ key, id, parts })), pageIds: commits.pageIds() });
+      const response = await postJson("/__gallery/edit/reverted", map.token, { slug: map.slug, opening: map.version, texts: texts.map(({ key, block, original, earlier }) => ({ key, block, original, ...(earlier ? { earlier } : {}) })), units: [...units, ...made.map(({ key, id, parent }) => ({ key, id, parent }))], instances: instances.map(({ key, id, parts }) => ({ key, id, parts })), pageIds: commits.pageIds() });
       answer = await response.json();
     } catch {}
     checking = false;
     if (closed) return false;
+    if (answer?.ok) {
+      // A block an earlier page made that the file no longer has is no block of this load's to hold a
+      // card for: its words are listed (lostKey), as what a page could not put back is; the others are
+      // found with the file, asked of while the page shows them.
+      const gone = made.filter(({ key }) => (answer.units ?? []).some((entry) => entry.key === key && entry.gone));
+      // One made inside another gone (a quote's paragraph, a list's item) went with it, its words among that one's.
+      const goneIds = new Set(gone.map(({ id }) => id));
+      const words = gone.filter(({ text, parent }) => text && !goneIds.has(parent)).map(({ text }) => ({ why: "reverted", text }));
+      const kept = words.length === 0 || keepLost(storage, map.slug, words);
+      if (kept) carriedMade = carriedMade.filter((entry) => !gone.includes(entry)); // asked again otherwise
+      for (const entry of made) if (!gone.includes(entry)) entry.confirmed = true;
+      if (kept && words.length > 0) listed();
+      // All of it asked of (no question waits to be asked again, which may carry more): the page knows the
+      // file as it was answered about.
+      if (kept && !recheck) {
+        seen = answer.version ?? null;
+        asking = false;
+      }
+    }
     // Of the blocks it made that the write took out, those inside another such go with it, one card.
-    const goneUnits = (answer?.units ?? []).filter(({ gone }) => gone).map(({ key }) => key);
+    const goneUnits = (answer?.units ?? []).filter(({ gone, key }) => gone && !made.some((entry) => entry.key === key)).map(({ key }) => key);
     const back = answer?.ok ? [
       ...answer.reverted.map(({ key, theirs }) => ({ ...texts.find((entry) => entry.key === key), theirs })).filter((entry) => entry.key),
       // A block put back: by its unit, with what it holds (the reader's words, to copy) and, taken out, the
@@ -457,19 +534,22 @@ export function createAutosave({ map, commits, blocked, changedAt, holding = ()
     storage.remove(bufferKey());
     storage.remove(keptKey());
     storedFrom = null; // written anew if anything stores after all
-    keepJournal();
+    keepJournal(); // a write landing after that answer and before the page shown again is served is asked of there (opened)
     refresh();
     reloadView(map.slug, null, notice());
   }
 
-  // The texts committed, this load's and earlier ones', one of each block (sameText): what an earlier
-  // load committed of a block a later one committed too is where that text started, and what it was
-  // between (two of one block are no one question: the server's answer would name neither); back as it
-  // was first, it is asked of what it was between.
+  // The texts committed, this load's and earlier ones', one of each block (sameText): what was committed
+  // of a block before (`at`, when it was last committed: two tabs' pages are taken in no order of their
+  // own) is where that text started, and what it was between (two of one block are no one question: the
+  // server's answer would name neither); back as it was first, it is asked of what it was between. Joined
+  // with one of this load's, it goes by that one's key and naming (decide lets this load's go by its key).
   const journal = () => {
     const now = commits.committed().map((entry) => ({ ...entry, time: Date.now() }));
+    const own = new Set(now.map((entry) => entry.key));
     const texts = new Map();
-    for (const entry of [...carried, ...now]) {
+    const when = (entry) => entry.at ?? entry.time ?? 0;
+    for (const entry of [...carried, ...now].sort((a, b) => when(a) - when(b))) {
       const name = sameText(entry.block);
       const was = texts.get(name);
       if (!was) {
@@ -477,7 +557,8 @@ export function createAutosave({ map, commits, blocked, changedAt, holding = ()
         continue;
       }
       const earlier = [...new Set([...(was.earlier ?? []), was.mine, entry.original, ...(entry.earlier ?? [])])].filter((text) => text !== entry.mine && text !== was.original).slice(-TEXTS_KEPT);
-      const joined = { ...entry, original: was.original, earlier };
+      const named = own.has(was.key) && !own.has(entry.key) ? { key: was.key, block: { ...was.block, before: entry.mine } } : {};
+      const joined = { ...entry, ...named, original: was.original, earlier, time: Math.max(was.time ?? 0, entry.time ?? 0) || undefined };
       if (earlier.length === 0) delete joined.earlier;
       if (entry.mine === was.original && earlier.length === 0) texts.delete(name);
       else texts.set(name, joined);
@@ -485,16 +566,73 @@ export function createAutosave({ map, commits, blocked, changedAt, holding = ()
     return [...texts.values()];
   };
 
-  // What the page committed (journal()) and what its components wrote (commits.written()), kept for the
-  // next load of the page in this tab, which asks of them as its own: when it is shown again, and when
-  // the page goes away (a reload of the reader's, another document opened in a workbench).
-  function keepJournal() {
-    const kept = [
-      ...journal().map((entry) => ({ ...entry, time: entry.time ?? Date.now() })),
+  // A commit of the page's that the file took deleted blocks (`request`'s removals, answered `receipt`): of
+  // the blocks earlier pages made, those (and those made inside them) are the reader's own deletion, asked
+  // of by no page any more: this one's, and those kept by pages of tabs gone that no page took yet.
+  function deleted(request, receipt) {
+    const ids = (request.units ?? []).filter((op) => op.remove && !(receipt.units ?? []).some((answer) => answer.key === op.key && answer.status === "conflict"))
+      .flatMap((op) => [op.unit?.id, ...(op.items ?? []).map((item) => item?.id)]).filter((id) => typeof id === "string");
+    if (ids.length === 0) return;
+    const gone = madeWithin(ids, carriedMade.map(({ id, parent }) => ({ id, parent })));
+    carriedMade = carriedMade.filter((entry) => !gone.has(entry.id));
+    try {
+      forgetMade(storage, map.slug, ids);
+    } catch {}
+  }
+
+  // What the page committed (journal()), made (its blocks the file has, by their ids, with their words:
+  // this load's and those of earlier loads it still shows or has not found the file with yet) and what
+  // its components wrote (commits.written()), kept in the journal under this tab with the version of the
+  // file it last knew (`known`, null when it does not), for the next page of the document, in this tab
+  // or another, which takes them as its own, and asks of them at once if it opens on another version
+  // (opened): when the page goes to show the file again, when it goes away (a reload of the reader's,
+  // another document opened, the tab closed) and after a write the reader asked for (showOwn). `pending`:
+  // commits not answered yet (on their way, or the crash buffer's, which the next page sends), whose
+  // texts are taken as committed, the reader's own words (an undo back to what an earlier commit
+  // replaced) being no one else's write.
+  function keepJournal(pending = []) {
+    const time = Date.now();
+    const made = new Map();
+    for (const { key, id, parent, from } of commits.placedUnits()) if (from === undefined && !reverts.has(`p${key}`)) made.set(id, { made: id, parent, text: commits.unitText(key), time });
+    for (const entry of carriedMade) {
+      const unit = commits.unitOf(entry.id);
+      if (made.has(entry.id) || (entry.confirmed && unit === null)) continue;
+      made.set(entry.id, { made: entry.id, parent: entry.parent, text: (unit !== null && commits.unitText(unit)) || entry.text, time: entry.time ?? time });
+    }
+    const entries = [
+      ...folded(journal(), pending.filter(Boolean)).map((entry) => ({ ...entry, time: entry.time ?? time })),
       ...commits.written().map(({ id, parts, time }) => ({ instance: id, parts, time })),
+      ...made.values(),
     ];
-    if (kept.length > 0) session?.set(journalKey, JSON.stringify(kept));
-    else session?.remove(journalKey);
+    try {
+      keepDeparture(storage, map.slug, tab(), entries.length > 0 ? { known: seen, time, entries } : null);
+    } catch {}
+  }
+
+  /**
+   * The page opened and edits, the workbench told it is ready (`open`: the ids of the tabs that answered
+   * they show the document now). What pages of tabs no longer open kept is taken too (the document
+   * opened again in another tab), and where this page opened on another version of the file than an
+   * earlier page last knew (someone else's write landing while no page was there to hear of it, or
+   * between the last question of a page showing the file again and this page being served, which it
+   * never hears of as a write), all it took is asked of at once (checkReverted): a text put back is a
+   * card, a block made that the file no longer has is listed. On the very version, nothing is asked.
+   * A page done with, or going to be shown again (it kept its journal already), takes nothing: the next
+   * page does; one whose write (showOwn) failed takes it then.
+   */
+  let unopened = null; // opened()'s call while the page was to be shown again by showOwn: { open }
+  function opened(open = null) {
+    if (closed) return;
+    if (reloading) return void (unopened = { open });
+    if (open) {
+      try {
+        adopt(takeJournal(storage, map.slug, (id) => id !== tab() && !open.has(id)));
+      } catch {}
+      forgetOld(storage);
+    }
+    if (!asking) return;
+    if (checking) recheck = true;
+    else checkReverted();
   }
 
   /**
@@ -534,7 +672,7 @@ export function createAutosave({ map, commits, blocked, changedAt, holding = ()
 
   /**
    * A write the reader asked for that changes the file (撤回 of the Agent's changes and its 撤销:
-   * changes/): `run()` makes it, resolving with whether it did; then the page shows the file as after a
+   * changes/): `run()` makes it, resolving with whether it did (the version it wrote, when known); then the page shows the file as after a
    * write of its own, at once, asking nothing of what it put back (the revert check: the reader asked
    * for it), and what is heard meanwhile shows nothing first. The caller saved what waited first
    * (flush) and made sure nothing waits for the reader. Resolves with whether the page goes.
@@ -547,14 +685,22 @@ export function createAutosave({ map, commits, blocked, changedAt, holding = ()
     missed = false;
     clearTimeout(reloadTimer);
     let done = false;
+    let wrote = null; // the version its write left, when run() says
     try {
-      done = Boolean(await run());
+      const result = await run();
+      done = Boolean(result);
+      if (typeof result === "string") wrote = result;
     } catch {}
     owning = false;
     if (closed) return done;
     if (!done) {
       reloading = false;
       refresh();
+      if (unopened) {
+        const { open } = unopened;
+        unopened = null;
+        opened(open);
+      }
       if (missed) heard(null, true);
       else if (foreign) maybeReload();
       return false;
@@ -562,6 +708,10 @@ export function createAutosave({ map, commits, blocked, changedAt, holding = ()
     storage.remove(bufferKey());
     storage.remove(keptKey());
     storedFrom = null;
+    // The page knew the file it asked to be written as; a write landing before the page shown again is
+    // served is asked of there. Not told which version that is, or with a question of its own not answered
+    // yet, the next page asks whatever it opens on.
+    seen = asking ? null : wrote;
     keepJournal();
     refresh();
     reloadView(map.slug, null, null);
@@ -597,6 +747,7 @@ export function createAutosave({ map, commits, blocked, changedAt, holding = ()
     changed,
     flush,
     leave,
+    opened,
     heard,
     store,
     decide,
@@ -692,6 +843,128 @@ function keepLost(storage, slug, items) {
   return storage.set(lostKey(slug), JSON.stringify([...readLost(storage, slug), ...items.map((item) => ({ ...item, time }))].slice(-100))) !== false;
 }
 
+/**
+ * Where the pages of a document keep, as they go away, what they committed, made and wrote, for the
+ * next page of it to ask of (createAutosave: keepJournal, opened), in localStorage: { v: 1, tabs: {
+ * <tab>: { known, time, entries } } }, one departure a tab, `known` the version of the file that page
+ * last knew (null: it did not), each entry with its `time`: a text ({ key, block, original, mine,
+ * earlier?, at }, `at` when it was last committed), a block made ({ made, parent, text }; taken out of
+ * every departure once a page's commit deletes it: forgetMade) or what a component wrote ({ instance, parts }).
+ * Entries are kept for JOURNAL_FOR, the newest of them JOURNAL_SIZE characters at most.
+ */
+export const journalKey = (slug) => `gallery-edit:${slug}:journal`;
+const JOURNAL_KEY = /^gallery-edit:(.+):journal$/;
+
+// The departures the journal holds, by tab, their entries still asked of (none left: no departure).
+function readJournal(storage, slug) {
+  let record = null;
+  try {
+    record = JSON.parse(storage.get(journalKey(slug)) ?? "null");
+  } catch {}
+  const tabs = {};
+  const now = Date.now();
+  for (const [tab, departure] of Object.entries(record?.tabs && typeof record.tabs === "object" ? record.tabs : {})) {
+    const entries = (Array.isArray(departure?.entries) ? departure.entries : []).filter((entry) => entry && typeof entry === "object" && now - entry.time < JOURNAL_FOR);
+    if (entries.length > 0) tabs[tab] = { known: typeof departure.known === "string" ? departure.known : null, time: departure.time, entries };
+  }
+  return tabs;
+}
+
+// The journal written as `tabs`, the newest entries first as long as they fit (one too long left out),
+// or taken away when nothing is left. A write that fails leaves it as it was: the crash buffer comes first.
+function writeJournal(storage, slug, tabs) {
+  const all = Object.entries(tabs).flatMap(([tab, departure]) => departure.entries.map((entry) => ({ tab, entry, size: JSON.stringify(entry).length })))
+    .sort((a, b) => b.entry.time - a.entry.time);
+  let room = JOURNAL_SIZE;
+  const fits = new Set();
+  for (const { entry, size } of all) {
+    if (size > room) continue;
+    room -= size;
+    fits.add(entry);
+  }
+  const kept = {};
+  for (const [tab, departure] of Object.entries(tabs)) {
+    const entries = departure.entries.filter((entry) => fits.has(entry));
+    if (entries.length > 0) kept[tab] = { ...departure, entries };
+  }
+  if (Object.keys(kept).length === 0) return void storage.remove(journalKey(slug));
+  const text = JSON.stringify({ v: 1, tabs: kept });
+  if (storage.get(journalKey(slug)) !== text) storage.set(journalKey(slug), text);
+}
+
+// The departures of the tabs `which` picks, taken out of the journal: [{ known, entries }].
+function takeJournal(storage, slug, which) {
+  const tabs = readJournal(storage, slug);
+  const taken = Object.keys(tabs).filter(which);
+  if (taken.length === 0) return [];
+  const departures = taken.map((tab) => tabs[tab]);
+  for (const tab of taken) delete tabs[tab];
+  writeJournal(storage, slug, tabs);
+  return departures;
+}
+
+// The ids of `ids` and of the blocks made (`made`: [{ id, parent }]) inside one of them, at any depth.
+function madeWithin(ids, made) {
+  const gone = new Set(ids);
+  for (let more = true; more;) {
+    more = false;
+    for (const { id, parent } of made) {
+      if (gone.has(id) || !gone.has(parent)) continue;
+      gone.add(id);
+      more = true;
+    }
+  }
+  return gone;
+}
+
+// The blocks made that the reader deleted (`ids`, and those made inside them) taken out of every
+// departure the journal holds.
+function forgetMade(storage, slug, ids) {
+  const tabs = readJournal(storage, slug);
+  let changed = false;
+  for (const departure of Object.values(tabs)) {
+    const gone = madeWithin(ids, departure.entries.filter((entry) => typeof entry.made === "string").map(({ made, parent }) => ({ id: made, parent })));
+    const entries = departure.entries.filter((entry) => typeof entry.made !== "string" || !gone.has(entry.made));
+    if (entries.length === departure.entries.length) continue;
+    departure.entries = entries;
+    changed = true;
+  }
+  if (changed) writeJournal(storage, slug, tabs);
+}
+
+// This tab's departure written (null: none), beside the other tabs'.
+function keepDeparture(storage, slug, tab, departure) {
+  const tabs = readJournal(storage, slug);
+  if (departure) tabs[tab] = departure;
+  else if (tabs[tab]) delete tabs[tab];
+  else if (storage.get(journalKey(slug)) === null) return;
+  writeJournal(storage, slug, tabs);
+}
+
+// What a Gallery before 2026-11-08 kept for the next load in the tab (sessionStorage, under the same
+// key): its entries, or { asked, entries }, read once as this tab's departure, the version it last knew
+// that `asked` (none of "own" or nothing: not known).
+function legacyJournal(session, slug) {
+  if (!session) return [];
+  let stored = null;
+  try {
+    stored = JSON.parse(session.get(journalKey(slug)) ?? "null");
+  } catch {}
+  session.remove(journalKey(slug));
+  const entries = (Array.isArray(stored) ? stored : Array.isArray(stored?.entries) ? stored.entries : []).filter((entry) => entry && typeof entry === "object" && Date.now() - entry.time < JOURNAL_FOR);
+  const known = !Array.isArray(stored) && typeof stored?.asked === "string" && stored.asked !== "own" ? stored.asked : null;
+  return entries.length > 0 ? [{ known, entries }] : [];
+}
+
+// The journals of documents whose every entry is older than JOURNAL_FOR, taken away (a document not
+// opened again within the hour leaves none behind).
+function forgetOld(storage) {
+  for (const key of storage.keys?.() ?? []) {
+    const slug = JOURNAL_KEY.exec(key)?.[1];
+    if (slug && Object.keys(readJournal(storage, slug)).length === 0) storage.remove(key);
+  }
+}
+
 /**
  * Reload the page to show the file as it is now, keeping where the reader was (`view`, or now):
  * the scroll position, the block the caret was in (by its data-block-id) with the caret's offset in

package/browser/editor/page/board/client.mjs

@@ -0,0 +1,57 @@
+import { postAnswer } from "../post.mjs";
+
+// What a custom page's board editing sends the page service (POST /__gallery/pages/<slug>/cards:
+// src/editor/page-service.mjs), one task at a time, in the order asked. A task is the whole of what the
+// page does for one gesture or one step of undo: what it sends, built only once its turn comes, and what
+// it does with the answer (each card's cells and base taken in, the undo step pushed or moved), all done
+// before the next task starts. So a write sent while one before it waits for its answer goes with the
+// bases that answer gave (a block's two context.edit calls in a row, two quick Ctrl+Z on one card, a
+// Ctrl+Z pressed before a drop is answered, which undoes the drop), never with those it had when it was
+// asked, which the service would refuse as changed. It knows which versions of the page are its own (the
+// one it was served at, and each its ops wrote), so that the live script's "page <version>" of its own
+// write changes nothing, and it says when an answer was applied to a version that is none of them:
+// someone else wrote the page meanwhile (`others`), which the page then shows again.
+
+/**
+ * slug, token, version: the page map's. others(): someone else wrote the page (an op's answer was
+ * applied to another version than the page's). Returns { run(task) (task(send) run once every task asked
+ * before it is done, `send(body)` giving the service's answer: { ok, … }, its refusal, or { ok: false,
+ * reason: "offline" } where it cannot be reached; resolves with what the task gives), ours(version), busy,
+ * idle() (a promise of the tasks asked so far being done) }.
+ */
+export function createClient({ slug, token, version, others = () => {} }) {
+  const route = `/__gallery/pages/${slug}/cards`;
+  const ours = new Set([version]);
+  let current = version;
+  let waiting = 0;
+  let chain = Promise.resolve();
+  const send = async (body) => {
+    const answer = await postAnswer(route, token, body);
+    if (answer?.ok) {
+      const before = answer.before;
+      ours.add(answer.version);
+      if (before !== current && !ours.has(before)) others();
+      current = answer.version;
+    }
+    return answer;
+  };
+  const run = (task) => {
+    waiting++;
+    const done = chain.then(() => task(send)).finally(() => {
+      waiting--;
+    });
+    chain = done.catch(() => {}); // a task that threw is its asker's to hear of; the next goes on
+    return done;
+  };
+  return {
+    run,
+    /** Whether `version` is the page's own: served at it, or written to it by an op. */
+    ours: (version) => ours.has(version),
+    /** Whether a task is asked and not yet done (sent, answered and taken in). */
+    get busy() {
+      return waiting > 0;
+    },
+    /** Once every task asked so far is done. */
+    idle: () => chain,
+  };
+}