@heycys/gallery 0.1.0 → 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,13 +43,45 @@ 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
+// Agent's changes, so none ends a document's first writing (docs/editor.md "Agent's changes").
+const AGENT_PAGE = typeof location !== "undefined" && new URLSearchParams(location.search).has("agent");
 
 // A committed text as the revert check names it, whichever load named it: the report's title, a block of
 // a unit by the unit's id (or what named the unit, with none) and its place in it, any other by what
 // 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):
@@ -58,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
@@ -96,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 = [];
@@ -227,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);
@@ -335,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(() => {});
   }
@@ -347,6 +406,8 @@ export function createAutosave({ map, commits, blocked, changedAt, holding = ()
    */
   function heard(version, anyway = false, at = Date.now()) {
     if (closed) return;
+    // A write the reader asked for is on its way (showOwn): what is heard meanwhile is its own, or heard again once it failed.
+    if (owning) return void (missed = true);
     // It may be the commit on its way, or one whose answer was lost: known once that one is answered
     // (as of when it was announced).
     if ((flight || parked) && !anyway) return void events.push([version, at]);
@@ -386,20 +447,45 @@ 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, 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).
-      ...(answer.units ?? []).filter(({ key }) => units.some((unit) => unit.key === key)).map(({ key, gone }) => ({ key: `p${key}`, unit: key, gone: Boolean(gone), mine: commits.unitText(key) })),
+      // A block put back: by its unit, with what it holds (the reader's words, to copy) and, taken out, the
+      // blocks taken out inside it (`within`, decided with it; what it holds that the file still has is not).
+      ...(answer.units ?? []).filter(({ key, gone }) => units.some((unit) => unit.key === key) && !(gone && commits.heldWithin?.(key, goneUnits))).map(({ key, gone }) => ({ key: `p${key}`, unit: key, gone: Boolean(gone), mine: commits.unitText(key), ...(gone ? { within: goneUnits.filter((inner) => commits.heldWithin?.(inner, [key])) } : {}) })),
       // Parts a component wrote put back: by its unit, with the hashes the file holds of them (`written`)
       // and what the page holds of them (`data`, the reader's, kept with the crash buffer); none the page
       // holds as the file does, however the file spells it (heldOtherwise).
@@ -448,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) {
@@ -468,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);
@@ -476,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();
   }
 
   /**
@@ -499,7 +646,7 @@ export function createAutosave({ map, commits, blocked, changedAt, holding = ()
       // A block put back: kept (made again, or moved again where the page has it), or the file's. Parts a
       // component wrote: written again over the file's (its hashes of them), or the file's.
       if (entry.written) commits.rewrite(entry.unit, entry.written, mine);
-      else commits.putBack(entry.unit, { gone: entry.gone, mine });
+      else commits.putBack(entry.unit, { gone: entry.gone, mine, within: entry.within });
       reverts.delete(key);
       storedFrom = null;
       if (mine) changed(true);
@@ -523,6 +670,54 @@ export function createAutosave({ map, commits, blocked, changedAt, holding = ()
     return true;
   }
 
+  /**
+   * 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 (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.
+   */
+  let owning = false; // showOwn's write is on its way
+  let missed = false; // and the live-reload channel spoke meanwhile
+  async function showOwn(run) {
+    if (closed || reloading) return false;
+    reloading = owning = true;
+    missed = false;
+    clearTimeout(reloadTimer);
+    let done = false;
+    let wrote = null; // the version its write left, when run() says
+    try {
+      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;
+    }
+    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);
+    return true;
+  }
+
   /** Show the file as it is once nothing waits (the reader gave a change up for the file's, or what the page is made of changed). */
   function reloadSoon() {
     foreign = true;
@@ -552,10 +747,12 @@ export function createAutosave({ map, commits, blocked, changedAt, holding = ()
     changed,
     flush,
     leave,
+    opened,
     heard,
     store,
     decide,
     reloadSoon,
+    showOwn,
     close,
     get state() {
       return { waiting: waiting(), syncing: Boolean(flight), offline, stopped, foreign, reloading, held: commits.issues.size + reverts.size, drafts, unstored };
@@ -566,7 +763,7 @@ export function createAutosave({ map, commits, blocked, changedAt, holding = ()
 // A commit sent: the server's answer, or { ok: false, reason: "server" } when it failed or answered
 // no JSON (a lost connection rejects: the caller reads that as offline).
 async function postCommit(map, request, { keepalive = false } = {}) {
-  const response = await postJson("/__gallery/edit/commit", map.token, { slug: map.slug, ...request }, { keepalive });
+  const response = await postJson("/__gallery/edit/commit", map.token, { slug: map.slug, ...request, ...(AGENT_PAGE ? { agent: true } : {}) }, { keepalive });
   if (response.status >= 500) return { ok: false, reason: "server" };
   return response.json().catch(() => ({ ok: false, reason: "server" }));
 }
@@ -646,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/beside.mjs

@@ -6,16 +6,16 @@ import { isHost } from "./core.mjs";
 // (selection/).
 
 /**
- * Whether a click to the right of a block (outside it) selects it: a boxed block (a code block, a
- * highlight block, a disclosure, a card, a table, a divider…) or a row of columns, as opposed to text
- * and the boxes text flows in (a list, a quote, a section).
+ * Whether a click to the right of a block, past the text area it stands in (insert/ boxedBeside),
+ * selects it: a boxed block (a code block, a highlight block, a disclosure, a card, a table, a
+ * divider…) or a row of columns, as opposed to text and the boxes text flows in (a list, a quote, a
+ * section).
  */
 export const selectsBeside = (unit) => BESIDE.has(unit?.getAttribute?.("data-ge-unit-kind"));
 
 /**
  * Whether Enter on a block selected (the first of those selected) puts a new paragraph after them
  * (blocks.mjs, insert.paragraphAfter): a block of no text of its own, those a click to their right
- * selects and a 选项卡区块; not a text block among them (a callout, whose text Enter edits, a formula
- * block, whose editor it opens).
+ * selects and a 选项卡区块; not a text block among them (a formula block, whose editor it opens).
  */
 export const entersAfter = (unit) => Boolean(unit) && !isHost(unit) && ENTERS_AFTER.has(unit.getAttribute("data-ge-unit-kind"));

package/browser/editor/page/block-menu/colors.mjs

@@ -12,7 +12,7 @@ import { t } from "../../../shared/i18n/index.mjs";
 // show one of the nine with none of a family (a callout's background is blue: `defaults`), that
 // family has no 默认: that color is ringed for none, and picking it takes the class away. Each
 // swatch names its color in a tooltip. The swatches are drawn with the kit's own classes, so they
-// match the text in either theme. A pick gives every target that color of its family, the other family's staying (one
+// match the text in either theme, a background's as the block's fill (`--doc-fill`). A pick gives every target that color of its family, the other family's staying (one
 // undo step: look, history.mjs; a table cell's one color: table/). Only the families the targets take show.
 
 const STYLE = `
@@ -21,6 +21,8 @@ const STYLE = `
   .ge-pop .ge-color-cell > span { display: flex; align-items: center; justify-content: center; box-sizing: border-box; width: 26px; height: 26px; border-radius: 6px;
     font-size: 16px; font-weight: 500; line-height: 1; box-shadow: inset 0 0 0 1px var(--ge-ring); }
   .ge-pop .ge-color-cell > span:not([class*="doc-text-"]) { color: var(--ge-tx); }
+  /* A block's background swatch shows the block's fill, not the words' deeper one the kit gives a span. */
+  .ge-pop .ge-color-cell > span[class*="doc-highlight-"] { background: var(--doc-fill); }
   .ge-pop .ge-color-cell:hover > span, .ge-pop .ge-color-cell[data-active] > span { box-shadow: inset 0 0 0 2px var(--ge-ring); }
   .ge-pop .ge-color-cell[aria-current="true"] > span { box-shadow: inset 0 0 0 2px var(--ge-ring-strong); }
   ${Object.entries(RINGS).map(([name, [light, dark, strong, strongDark]]) => `.ge-pop .ge-color-cell[data-ring="${name}"] { --ge-ring: light-dark(${light}, ${dark}); --ge-ring-strong: light-dark(${strong}, ${strongDark}); }`).join("\n  ")}

package/browser/editor/page/block-menu/index.mjs

@@ -54,7 +54,7 @@ const WIDTH = MENU_WIDTH; // the menu, as wide as its grid (no room left beside
  * color rows). copyLink(target): the block's address on the clipboard, in the click on its row; null
  * on a page no address leads to; linkAhead(): the menu opens with that row, what the click will want is read now.
  */
-export function createBlockMenu({ info, menu, selection, remove, turnInto, convert, turnIntoAll = () => null, convertAll = () => {}, below, belowTypes = () => [], add, look, copyLink = () => {}, linkAhead = () => {} }) {
+export function createBlockMenu({ info, menu, selection, remove, takenWith = (units) => units, turnInto, convert, turnIntoAll = () => null, convertAll = () => {}, below, belowTypes = () => [], add, look, copyLink = () => {}, linkAhead = () => {} }) {
   const chapters = sectionOps();
   const columns = columnOps();
   const { kindOf, nameOf, keepText, boxKindOf } = info;
@@ -95,12 +95,13 @@ export function createBlockMenu({ info, menu, selection, remove, turnInto, conve
   // where it is. What it holds comes out as it stands, so a block in a column keeps its column, the row
   // of columns coming out whole, and one in a section in a Sheet panel ends in the panel. None for a
   // block that has no 分区与分栏 › of its own (no columns row, in a section: a list item, a flowchart's
-  // node, a quote's later paragraph, a block an item holds).
+  // node, a quote's later paragraph, a block an item holds): asked of the block alone (a folded heading
+  // whose section a column cannot take keeps it).
   const dissolveRow = (units) => {
     const section = chapters?.dissolvesFrom(units[0]);
     if (!section || units.some((unit) => chapters.dissolvesFrom(unit) !== section)) return [];
     const own = units[0] === section;
-    if (!own && units.some((unit) => (columns?.columnsCheck([unit]) ?? null) === null)) return [];
+    if (!own && units.some((unit) => (columns?.columnsCheck([unit], (alone) => [alone]) ?? null) === null)) return [];
     const reason = chapters.unwrapCheck(section);
     return [{ label: own ? t("解散分区") : t("解散所在分区"), icon: ICONS.dissolve, disabled: Boolean(reason), note: reason || undefined, run: () => chapters.unwrap(section, own ? null : units) }];
   };
@@ -149,8 +150,9 @@ export function createBlockMenu({ info, menu, selection, remove, turnInto, conve
       const colors = colorRow(group);
       items.push(...colors, ...(colors.length > 0 ? [{ separator: true }] : []));
       // Blocks next to each other in the page or a Sheet panel become a section; a selection with gaps does not.
-      const wrap = chapters?.wrapCheck(group) ?? null;
-      const sections = [...(wrap !== null ? [{ label: t("组成新分区"), icon: ICONS.group, disabled: Boolean(wrap), note: wrap || undefined, run: () => chapters.wrap(group) }] : []), ...dissolveRow(group)];
+      // A folded heading among them goes in with what it hides (fold/).
+      const wrap = chapters?.wrapCheck(takenWith(group)) ?? null;
+      const sections = [...(wrap !== null ? [{ label: t("组成新分区"), icon: ICONS.group, disabled: Boolean(wrap), note: wrap || undefined, run: () => chapters.wrap(takenWith(group)) }] : []), ...dissolveRow(group)];
       // Neighbours in one container go side by side, a column each.
       items.push(...groupRow(sections, splitRows(group)));
       items.push({ label: t("删除"), icon: ICONS.trash, hint: "Del", disabled: Boolean(refused), note, run: () => remove(group) });
@@ -193,7 +195,7 @@ export function createBlockMenu({ info, menu, selection, remove, turnInto, conve
     }
     const sections = [];
     if (chapter(target)) sections.push({ label: t("在下方新建分区"), icon: ICONS.section, run: () => add(target, "section") });
-    if (chapters?.wrapCheck([target]) === "") sections.push({ label: t("组成新分区"), icon: ICONS.group, run: () => chapters.wrap([target]) });
+    if (chapters?.wrapCheck(takenWith([target])) === "") sections.push({ label: t("组成新分区"), icon: ICONS.group, run: () => chapters.wrap(takenWith([target])) });
     sections.push(...dissolveRow([target]));
     const splits = splitRows([target]);
     // 选中外层 joins 分区与分栏 › where the block has that submenu; a block with none gets none for it.