@panphora/clayjs 1.23.0 → 1.24.1

package/src/plugins/visitor-drafts.js

@@ -1,17 +1,38 @@
 import { isDraftMode, isEditMode, isOwner } from "../core/is-edit-mode.js";
 import { hasSaveToken } from "../core/host-attrs.js";
-import { draftSlot, setDraftTransport, setDraftFlush } from "../core/draft-mode.js";
-import { createStore, adoptLegacy, draftPath, legacyKey, safeStorage } from "./visitor-drafts/store.js";
+import { draftSlot, draftStoreFailed, setDraftTransport, setDraftFlush, setDraftUnconfirmed } from "../core/draft-mode.js";
+import { reloadAfterDiscard } from "../core/unsaved-warning.js";
+import { createStore, adoptLegacy, draftPath, legacyKey, safeStorage, storageFailure } from "./visitor-drafts/store.js";
 import { createUiMemory } from "./visitor-drafts/ui-memory.js";
 import { rememberSource, downloadUrl } from "./visitor-drafts/source.js";
 import { mountPrompt } from "./visitor-drafts/prompt.js";
 import { DOWNLOAD_URL, backToDraft, editOriginal, inertVisitorDrafts } from "./visitor-drafts/inert.js";
 
 let store = null;
+// This tab's side of the draft database, once it has opened. Without one, `localStorage`
+// holds the record for this page load, as it did before the database.
+let session = null;
+let direct = true;
+let database = false;
+let opening = Promise.resolve();
+// The database did not open and the full draft is only there: nothing is saved over it
+// for the rest of this page load.
+let refused = false;
 let restoredDetail = null;
 let downloadLink = DOWNLOAD_URL;
 let source = null;
 let ready = Promise.resolve();
+// Settles once the draft is on the page. Already settled for a first visit and for a
+// draft `localStorage` holds in full; the loader awaits it before the next plugin loads.
+let restoring = Promise.resolve();
+// The synchronous half of a save: false while something this tab changed is neither
+// stored nor in its journal slot.
+let keep = () => true;
+// A promise while the page's last changes are not yet where the download page reads them,
+// null once they are.
+let settle = () => null;
+// Past this deadline the download uses this page's current HTML.
+const DOWNLOAD_WAIT_MS = 3000;
 
 // The chip is a convenience: a failed import leaves the draft working without it.
 function mountChip() {
@@ -41,29 +62,121 @@ const rulesTag = document.querySelector('script[data-rules-name~="api"]');
 if (isDraftMode && slot && rulesTag) {
   const path = draftPath();
   const moved = adoptLegacy(slot, { path });
+  const local = safeStorage();
   store = createStore({ path, fallback: moved === "failed" ? legacyKey(slot) : null });
-  setDraftTransport((html) => store.write(html));
-  const result = store.restore();
-  restoredDetail = { restored: result.restored, hadDraft: result.hadDraft, parked: Boolean(result.parked), ...(result.partial && { partial: true }), ...(result.blocked && { blocked: true }) };
-  document.dispatchEvent(new CustomEvent("clay:drafts-restored", { detail: restoredDetail }));
-  const memory = createUiMemory(store.key, safeStorage());
+  direct = !(typeof globalThis.indexedDB?.open === "function" && globalThis.IDBKeyRange);
+  database = !direct;
+  // The session loads beside the database open, off the path of a draft `localStorage` holds
+  // in full. Until it is there a save still makes its operation and journals it.
+  opening = direct ? Promise.resolve() : import("./visitor-drafts/session.js")
+    .then((m) => m.openSession({ store, storage: local, reload: () => reloadAfterDiscard({ isCurrent: () => true, reload: () => window.location.reload() }) }))
+    .then((opened) => { session = opened; }, () => { direct = true; });
+
+  setDraftTransport((html) => {
+    const recapture = !restoredDetail;
+    return restoring.then(() => {
+      if (refused) throw storageFailure(document, new Error("the draft database did not open"));
+      if (recapture) html = window.clay.getHTML();
+      if (direct) return void store.write(html);
+      store.capture(html);
+      return opening.then(() => {
+        if (session) return session.sync().then(() => {});
+        store.write(html);
+      });
+    });
+  });
+
+  const memory = createUiMemory(store.key, local);
   source = rememberSource(memory);
   downloadLink = downloadUrl(source);
-  const appName = document.querySelector('meta[name="application-name"]')?.content?.trim() || document.title.split(/:|\s\|\s/)[0].trim() || "This app";
-  const template = document.querySelector("template[visitor-intro]");
-  const start = () => {
-    ready = mountPrompt({ memory, appName, link: downloadLink }).then((prompt) => mountIntroLate({ memory, template, appName, hadDraft: result.hadDraft }).then(() => prompt)).then((prompt) => {
-      document.addEventListener("clay:drafts-store-failed", () => prompt.showError());
-      document.addEventListener("clay:drafts-saved", () => prompt.clearError());
-      return (isOwner ? mountChip() : Promise.resolve(null)).then(() => prompt);
-    });
+
+  function finish(result) {
+    restoredDetail = { restored: result.restored, hadDraft: result.hadDraft, parked: Boolean(result.parked), ...(result.partial && { partial: true }), ...(result.blocked && { blocked: true }) };
+    document.dispatchEvent(new CustomEvent("clay:drafts-restored", { detail: restoredDetail }));
+    const appName = document.querySelector('meta[name="application-name"]')?.content?.trim() || document.title.split(/:|\s\|\s/)[0].trim() || "This app";
+    const template = document.querySelector("template[visitor-intro]");
+    const start = () => {
+      ready = mountPrompt({ memory, appName, link: downloadLink, settle: () => settle(), canDownloadCurrent: () => !refused && !restoredDetail.blocked }).then((prompt) => mountIntroLate({ memory, template, appName, hadDraft: result.hadDraft || store.kept() }).then(() => prompt)).then((prompt) => {
+        document.addEventListener("clay:drafts-store-failed", () => prompt.showError());
+        document.addEventListener("clay:drafts-saved", () => prompt.clearError());
+        if (draftStoreFailed()) prompt.showError();
+        return (isOwner ? mountChip() : Promise.resolve(null)).then(() => prompt);
+      });
+    };
+    document.readyState === "loading" ? document.addEventListener("DOMContentLoaded", start, { once: true }) : start();
+  }
+
+  keep = () => {
+    if (refused) return false;
+    if (!restoredDetail) return true;
+    if (direct) return store.flush();
+    const safe = store.keep();
+    session?.hide();
+    return safe;
+  };
+  setDraftFlush(keep);
+  setDraftUnconfirmed(() => !direct && store.unsafe());
+  settle = () => {
+    if (refused) return Promise.resolve(false);
+    if (!restoredDetail) return restoring.then(() => settle());
+    if (direct) {
+      return store.flush() ? null : Promise.resolve(false);
+    }
+    const safe = store.keep();
+    if (!store.pending()) return safe ? null : Promise.resolve(false);
+    const committed = opening.then(() => session ? session.sync().then(() => true) : store.flush()).catch(() => false);
+    let timer;
+    return Promise.race([committed, new Promise((resolve) => { timer = setTimeout(() => resolve(false), DOWNLOAD_WAIT_MS); })])
+      .finally(() => clearTimeout(timer));
   };
-  document.readyState === "loading" ? document.addEventListener("DOMContentLoaded", start, { once: true }) : start();
-  setDraftFlush(() => store.flush());
-  window.addEventListener("storage", (event) => { if (event.key === store.key) store.adoptExternal(); });
-  const flush = () => store.flush();
-  document.addEventListener("visibilitychange", () => { if (document.visibilityState === "hidden") flush(); });
-  window.addEventListener("pagehide", flush);
+  document.addEventListener("visibilitychange", () => { if (document.visibilityState === "hidden") keep(); });
+  window.addEventListener("pagehide", keep);
+
+  // Another tab's save reaches a page on the database through its session. With
+  // `localStorage` as the record it arrives as that key's storage event, once the page
+  // editor listens (an event before that is missed), and when the tab comes back from the
+  // page cache.
+  const takeOtherTab = () => {
+    if (!direct || refused || !restoredDetail) return;
+    // Read before adopting: adopting reads the record as this tab's own.
+    const unit = store.externalUnit();
+    // A page another tab wrote goes to the page editor, which merges it into its own.
+    if (unit) document.dispatchEvent(new CustomEvent("clay:drafts-blockeditor-external", { detail: { live: unit.live, adopted: () => store.adoptedUnit(unit) } }));
+    store.adoptExternal();
+  };
+  window.addEventListener("storage", (event) => { if (event.key === store.key) takeOtherTab(); });
+  document.addEventListener("clay:drafts-blockeditor-listening", takeOtherTab);
+  window.addEventListener("pageshow", (event) => { if (event.persisted) takeOtherTab(); });
+
+  const held = store.held();
+  const head = held?.v === 2 && held.idb === true;
+  const foreignReset = !direct && held?.v === 1 && held.w === undefined && store.generation() !== "";
+  if (head || foreignReset || (!direct && held?.w && held.w.reset !== store.generation())) {
+    // The full draft is only in the database, or this copy is from before the last Start
+    // over: the page waits for the database's record, and plugins that read the document
+    // wait with the page.
+    restoring = opening.then(() => session?.first).then((result) => {
+      if (result) return finish(store.restore(result.record && { raw: JSON.stringify(result.record), record: result.record }));
+      throw new Error("the draft database did not open");
+    }).catch((error) => {
+      if (!head) {
+        if (!foreignReset) { try { local?.removeItem(store.key); } catch {} }
+        return finish(store.restore());
+      }
+      refused = true;
+      storageFailure(document, error);
+      finish({ restored: false, hadDraft: true, blocked: true });
+    });
+  } else {
+    finish(store.restore());
+    // The database did not open: `localStorage` is the record for this page load, and what
+    // this tab journaled while it waited is saved there.
+    opening.then(() => {
+      if (session) return;
+      store.release();
+      store.flush();
+    });
+  }
 } else if (!slot || !rulesTag) {
   const missing = [];
   if (!slot) missing.push('a visitor-drafts="<slot>" attribute on <html>');
@@ -73,18 +186,33 @@ if (isDraftMode && slot && rulesTag) {
   ready = mountChip();
 }
 
-export { ready };
+export { ready, restoring };
 
 export const visitorDrafts = store ? {
   active: true,
   slot: store.slot,
   key: store.key,
-  hasDraft: () => Boolean(store.read()),
+  hasDraft: () => store.kept(),
   restored: () => restoredDetail,
-  saveNow: () => store.writeLive(),
+  saveNow() {
+    if (refused || !restoredDetail) return false;
+    if (direct) return store.writeLive();
+    try { store.capture(window.clay.getHTML()); } catch { return false; }
+    session?.sync().catch(() => {});
+    return !store.unsafe();
+  },
   reset() {
-    store.clear();
-    window.location.reload();
+    if (!database) {
+      store.clear();
+      window.location.reload();
+      return true;
+    }
+    // The generation ends in the database before the page loads again.
+    opening.then(() => {
+      if (session) return session.startOver();
+      if (direct && !refused) return store.clear();
+      throw new Error("the draft database did not open");
+    }).then(() => window.location.reload(), (error) => storageFailure(document, error));
     return true;
   },
   onRestore(fn) {
@@ -98,6 +226,9 @@ export const visitorDrafts = store ? {
   editOriginal,
   backToDraft,
   downloadUrl: () => downloadLink,
-  download: () => ready.then((prompt) => { store.flush(); return prompt?.download(); }),
+  download: () => ready.then(async (prompt) => {
+    const saved = await settle();
+    return prompt?.download(saved === false);
+  }),
   source,
 } : inertVisitorDrafts();

package/src/server/checkpoint/index.js

@@ -9,7 +9,7 @@ import { merge3, mergeJson } from 'hyper-morph';
 import { mergePageModels } from '../../page/merge.js';
 import { documentTitle } from '../../page/document-title.js';
 
-const PAGE = /^page(\.[0-9]+)?$/;
+const PAGE = /^blockeditor(\.[0-9]+)?$/;
 const TITLE_MODE = 'clay-seo-title-mode';
 const NAME = /^[A-Za-z0-9_.:-]{1,64}$/;
 const attr = (node, name) => node.attrs.find((item) => item.name === name)?.value;
@@ -25,7 +25,7 @@ function provenanceOf(room, store) {
 export function captureCheckpoint(room, { nodeId, roomKey }) {
   if (!room || room.key !== roomKey || String(room.nodeId) !== String(nodeId)) throw new TypeError('The room identity changed');
   const { epoch, seq } = room;
-  const generation = room.pageTransition?.id ?? null;
+  const generation = room.blockeditorTransition?.id ?? null;
   const stores = [...room.stores].filter(([, store]) => !store.ephemeral).map(([name, store]) => {
     const text = serializeLive(store.value);
     return { name, value: cloneJson(store.value), text, liveAt: stampOf(epoch, seq, text), provenance: provenanceOf(room, store) };
@@ -51,7 +51,7 @@ function inspect(html) {
     if (!blocked && node.parentNode === head && node.tagName === 'meta' && (attr(node, 'name') ?? '').trim().toLowerCase() === TITLE_MODE) {
       titleModes.push(attr(node, 'content'));
     }
-    if (!blocked && node.tagName === 'article' && attr(node, 'data-page') !== undefined) articles.push(node);
+    if (!blocked && node.tagName === 'article' && attr(node, 'data-blockeditor') !== undefined) articles.push(node);
     if (!blocked && node.tagName === 'script' && attr(node, 'src') === undefined &&
       (attr(node, 'clay') ?? '').split(/\s+/).includes('live')) {
       const type = (attr(node, 'type') ?? '').split(';')[0].trim().toLowerCase();
@@ -81,8 +81,8 @@ function startTag(html, node, store) {
 }
 
 function projection(capture) {
-  const page = capture.stores.find((store) => store.name === 'page');
-  if (!page || capture.stores.some((store) => PAGE.test(store.name) && store.name !== 'page')) return { kind: 'refused', reason: 'invalid-document' };
+  const page = capture.stores.find((store) => store.name === 'blockeditor');
+  if (!page || capture.stores.some((store) => PAGE.test(store.name) && store.name !== 'blockeditor')) return { kind: 'refused', reason: 'invalid-document' };
   try {
     const blocks = blocksFromYValue(page.value);
     if (Object.values(blocks).some((block) => block.t === 'tool' || (block.t === 'table' && !Object.keys(block.cols ?? {}).length))) {
@@ -91,8 +91,8 @@ function projection(capture) {
     return { kind: 'ok', blocks };
   } catch (error) {
     if (error instanceof YDecodeError) {
-      return { kind: 'refused', reason: error.code === 'incomplete-update' || error.code === 'unresolved-update' ? 'incomplete-page'
-        : error.code === 'unsupported-content' ? 'unknown-page-content' : 'invalid-document' };
+      return { kind: 'refused', reason: error.code === 'incomplete-update' || error.code === 'unresolved-update' ? 'incomplete-blockeditor'
+        : error.code === 'unsupported-content' ? 'unknown-blockeditor-content' : 'invalid-document' };
     }
     throw error;
   }
@@ -234,7 +234,7 @@ export function renderCheckpoint(currentHtml, capture, { createDocument, recover
     if (!recovery && found.kind === 'adopt' && capture.adopted !== found.A && !holdsEdit(found, decoded.blocks, doc)) return { kind: 'refused', reason: 'needs-adoption' };
     const current = currentHtml.slice(articleLoc.startTag.endOffset, articleLoc.endTag.startOffset);
     rendered = renderBlocks(decoded.blocks, { clean: fragmentCleaner(doc) });
-    if (current !== rendered.html && holdsEnvelope(current)) return { kind: 'refused', reason: 'unknown-page-content' };
+    if (current !== rendered.html && holdsEnvelope(current)) return { kind: 'refused', reason: 'unknown-blockeditor-content' };
   }
   catch (error) {
     if (error instanceof YDecodeError || error instanceof SyntaxError) return { kind: 'refused', reason: 'invalid-document' };

package/src/server/rooms/index.js

@@ -40,8 +40,8 @@ export {
   postReceipt,
 } from './live-provenance.js';
 
-export { isHybridPageValue, isYPageValue, inspectPage, pageBaseline, captureFormat, checkPageFormatAdmission } from './page-admission.js';
-export { PAGE_FORMAT, PAGE_FORMAT_HEADER, PAGE_FORMAT_EXTENSION, PAGE_FORMAT_UPGRADE, formatCapability, pageFormatFloor, withPageFormatFloor } from '../../core/page-format.js';
+export { isHybridPageValue, isYPageValue, inspectPage, pageBaseline, captureFormat, checkPageFormatAdmission, oldBlockeditorFormat, oldFormatRefusal } from './page-admission.js';
+export { PAGE_FORMAT, PAGE_FORMAT_HEADER, PAGE_FORMAT_EXTENSION, PAGE_FORMAT_UPGRADE, formatCapability, blockeditorFormatFloor, withPageFormatFloor } from '../../core/page-format.js';
 
 export { splitPage, composePage, pageRev } from './page-state.js';
 

package/src/server/rooms/live-data-rooms.js

@@ -55,7 +55,7 @@ export const LIVE_LIMITS = Object.freeze({
   movesBytes: 1024 * 1024,
 });
 
-const PAGE = /^page(\.[0-9]+)?$/;
+const PAGE = /^blockeditor(\.[0-9]+)?$/;
 export const COMPACTOR = 'compactor';
 const isContainer = (v) => v !== null && typeof v === 'object';
 
@@ -239,7 +239,7 @@ export function createRooms({ now = Date.now, newEpoch = randomUUID, liveBytes =
     lastSentAt: new Map(),
     seen: new Map(),
     emptySince: null,
-    ...(inspectPage(html).kind === 'yjs' && { pageTransition: makePageTransition() }),
+    ...(inspectPage(html).kind === 'yjs' && { blockeditorTransition: makePageTransition() }),
     compaction: hostMode(inspectPage(html).kind === 'yjs'),
   });
 
@@ -249,7 +249,7 @@ export function createRooms({ now = Date.now, newEpoch = randomUUID, liveBytes =
     return total;
   };
   const heldBy = (room) => {
-    let total = (room.receiptBytes ?? 0) + (room.pageTransition?.bytes ?? 0) + (room.compaction?.job?.reserved ?? 0);
+    let total = (room.receiptBytes ?? 0) + (room.blockeditorTransition?.bytes ?? 0) + (room.compaction?.job?.reserved ?? 0);
     for (const s of room.stores.values()) total += s.bytes + s.logBytes;
     return total;
   };
@@ -265,7 +265,7 @@ export function createRooms({ now = Date.now, newEpoch = randomUUID, liveBytes =
     return {
       limit,
       over() {
-        if (answer.failed || (state.lastFull && state.deletesSince === 0)) return { error: 'page-full' };
+        if (answer.failed || (state.lastFull && state.deletesSince === 0)) return { error: 'blockeditor-full' };
         due(room, true);
         return { error: 'checkpoint-required', retryAfter: 0 };
       },
@@ -342,7 +342,7 @@ export function createRooms({ now = Date.now, newEpoch = randomUUID, liveBytes =
 
   const pageSource = (key, nodeId) => {
     if (nodeId == null) throw new PageConversionError('invalid-document');
-    if (pageReservations.has(key) || persistentReservations.has(key) || reservedNodes.has(String(nodeId))) throw new PageConversionError('page-converting');
+    if (pageReservations.has(key) || persistentReservations.has(key) || reservedNodes.has(String(nodeId))) throw new PageConversionError('blockeditor-converting');
     let room = rooms.get(key) ?? null;
     if (room && String(room.nodeId) !== String(nodeId)) {
       used -= heldBy(room);
@@ -355,7 +355,7 @@ export function createRooms({ now = Date.now, newEpoch = randomUUID, liveBytes =
   const reservePageTarget = (key, nodeId, room, html, details) => {
     const receipts = new Set([...(room?.lastN.keys() ?? [])].filter((key) => PAGE.test(key.slice(0, key.indexOf('\n')))));
     if (receipts.size >= LIVE_LIMITS.receipts ||
-      (room?.pageTransition?.receiptCount ?? 0) + receipts.size > LIVE_LIMITS.receipts) throw new PageConversionError('receipt-capacity');
+      (room?.blockeditorTransition?.receiptCount ?? 0) + receipts.size > LIVE_LIMITS.receipts) throw new PageConversionError('receipt-capacity');
     const names = details.names ?? [...new Set([
       ...[...(room?.stores.keys() ?? [])].filter((name) => PAGE.test(name)),
       ...[...receipts].map((key) => key.slice(0, key.indexOf('\n'))),
@@ -373,7 +373,7 @@ export function createRooms({ now = Date.now, newEpoch = randomUUID, liveBytes =
         heldCount: others.length,
       });
       for (const store of stores.values()) store.from = null;
-      budget = transition.bytes - (room.pageTransition?.historyBytes ?? 0) +
+      budget = transition.bytes - (room.blockeditorTransition?.historyBytes ?? 0) +
         [...stores.values()].reduce((sum, store) => sum + store.bytes, 0);
       const replacedBytes = [...room.stores].filter(([name]) => PAGE.test(name))
         .reduce((sum, [, store]) => sum + store.bytes + store.logBytes, 0);
@@ -413,11 +413,11 @@ export function createRooms({ now = Date.now, newEpoch = randomUUID, liveBytes =
       }
       if (!isContainer(value) || Array.isArray(value) !== Array.isArray(store.value)) continue;
       if (PAGE.test(tag.name)) {
-        if (room.pageTransition?.format === 'yjs') {
-          if (tag.name !== 'page' || !isYPageValue(value)) continue;
+        if (room.blockeditorTransition?.format === 'yjs') {
+          if (tag.name !== 'blockeditor' || !isYPageValue(value)) continue;
         } else if (isYPageValue(value, { complete: false })) continue;
       }
-      const host = Boolean(room.compaction && tag.name === 'page' && room.pageTransition?.format === 'yjs');
+      const host = Boolean(room.compaction && tag.name === 'blockeditor' && room.blockeditorTransition?.format === 'yjs');
       const before = store.landed;
       const base = baseOf(room, store, tag.at);
       // A capture (stamped, and still the value its stamp names) holds no merge
@@ -548,9 +548,9 @@ export function createRooms({ now = Date.now, newEpoch = randomUUID, liveBytes =
       return reservePageTarget(key, nodeId, room, html, { source, base, epoch, names, format: 'yjs' });
     },
 
-    reservePageInitial(key, { nodeId, currentHtml, html, ifMatch, pageWrite = null, createDocument }) {
+    reservePageInitial(key, { nodeId, currentHtml, html, ifMatch, blockeditorWrite = null, createDocument }) {
       const room = pageSource(key, nodeId);
-      checkPageInitial({ currentHtml, html, ifMatch, room, pageWrite, createDocument });
+      checkPageInitial({ currentHtml, html, ifMatch, room, blockeditorWrite, createDocument });
       return reservePageTarget(key, nodeId, room, html, { source: 'initial', names: [], format: 'yjs' });
     },
 
@@ -591,7 +591,7 @@ export function createRooms({ now = Date.now, newEpoch = randomUUID, liveBytes =
         room.stores.set(name, store);
         bytes += store.bytes;
       }
-      room.pageTransition = transition;
+      room.blockeditorTransition = transition;
       if (hostLimits) room.compaction = hostMode(transition.format === 'yjs');
       reservation.target = null;
       used += heldBy(room) - before - reservation.budget;
@@ -662,8 +662,8 @@ export function createRooms({ now = Date.now, newEpoch = randomUUID, liveBytes =
           throw new PersistentReservationError('invalid-target');
         }
         if (PAGE.test(name)) {
-          if (record.room.pageTransition?.format === 'yjs') {
-            if (name !== 'page' || !isYPageValue(value) || value.g !== store.value.g) {
+          if (record.room.blockeditorTransition?.format === 'yjs') {
+            if (name !== 'blockeditor' || !isYPageValue(value) || value.g !== store.value.g) {
               throw new PersistentReservationError('invalid-target');
             }
           } else if (isYPageValue(value, { complete: false })) throw new PersistentReservationError('invalid-target');
@@ -839,14 +839,14 @@ export function createRooms({ now = Date.now, newEpoch = randomUUID, liveBytes =
       if (current === room && persistentReservations.has(room.key)) return { error: 'checkpointing' };
       if (!isContainer(frame)) return { error: 'bad-frame' };
       if (current !== room) return { stale: true, epoch: current?.epoch ?? null };
-      if (pageReservations.has(room.key) && PAGE.test(frame.name)) return { error: 'page-converting' };
+      if (pageReservations.has(room.key) && PAGE.test(frame.name)) return { error: 'blockeditor-converting' };
       // Made for an earlier room: the tab resends its ops once it has this room's state.
       if ((PAGE.test(frame.name) || frame.epoch !== undefined) && frame.epoch !== room.epoch) return { stale: true, epoch: room.epoch };
-      const transition = PAGE.test(frame.name) ? room.pageTransition : null;
-      if (PAGE.test(frame.name) && (transition?.format === 'yjs' || frame.pageGeneration !== undefined) &&
-        (frame.pageGeneration ?? null) !== (transition?.id ?? null)) return { error: 'page-generation' };
+      const transition = PAGE.test(frame.name) ? room.blockeditorTransition : null;
+      if (PAGE.test(frame.name) && (transition?.format === 'yjs' || frame.blockeditorGeneration !== undefined) &&
+        (frame.blockeditorGeneration ?? null) !== (transition?.id ?? null)) return { error: 'blockeditor-generation' };
       const converted = transition?.format === 'yjs';
-      if (converted && frame.name !== 'page') return { error: 'page-format' };
+      if (converted && frame.name !== 'blockeditor') return { error: 'blockeditor-format' };
       const store = room.stores.get(frame.name);
       if (!store) return { error: 'unknown-store' };
       if (!Number.isInteger(frame.n) || frame.n < 1) return { error: 'bad-frame' };
@@ -862,11 +862,11 @@ export function createRooms({ now = Date.now, newEpoch = randomUUID, liveBytes =
           return { error: 'bad-op', message: err.message };
         }
         if (ops.some((op) => op.path.length !== 2 || op.path[0] !== 'y' ||
-          !(op.op === 'del' || (op.op === 'set' && typeof op.value === 'string')))) return { error: 'page-format' };
+          !(op.op === 'del' || (op.op === 'set' && typeof op.value === 'string')))) return { error: 'blockeditor-format' };
       }
       const nKey = frame.name + '\n' + clientId;
       const last = room.lastN.get(nKey);
-      const admission = room.compaction && frame.name === 'page' && !receiptHas(last, frame.n) ? admit(room, store, frame, ops) : null;
+      const admission = room.compaction && frame.name === 'blockeditor' && !receiptHas(last, frame.n) ? admit(room, store, frame, ops) : null;
       if (admission?.error) return admission;
       // Answered with the seq the sender's last frame landed at, so the tab knows
       // which applied state holds it.
@@ -914,12 +914,12 @@ export function createRooms({ now = Date.now, newEpoch = randomUUID, liveBytes =
       }
       if (converted && !isYPageValue(value, { complete: false })) {
         undo();
-        return { error: 'page-format' };
+        return { error: 'blockeditor-format' };
       }
       if (!converted && PAGE.test(frame.name) && (isYPageValue(value, { complete: false }) ||
         (hybridSource && (Object.hasOwn(value, 'y') || Object.hasOwn(value, 'v'))))) {
         undo();
-        return { error: 'page-conversion-required' };
+        return { error: 'blockeditor-conversion-required' };
       }
       if (bytes > LIVE_LIMITS.storeBytes || roomBytes(room) - store.bytes + bytes > LIVE_LIMITS.roomBytes) {
         undo();
@@ -957,7 +957,7 @@ export function createRooms({ now = Date.now, newEpoch = randomUUID, liveBytes =
       if (admission && done.length) admission.admitted(bytes);
       const writerGone = room.writer && connected && !connected.includes(room.writer);
       if ((!room.writer || writerGone) && (!connected || connected.includes(clientId))) room.writer = clientId;
-      return { seq: room.seq, epoch: room.epoch, name: frame.name, ops, writer: room.writer, checkpoint: pressed(store), receiptGeneration: room.receiptGeneration ?? 0, ...(transition && { pageGeneration: transition.id }) };
+      return { seq: room.seq, epoch: room.epoch, name: frame.name, ops, writer: room.writer, checkpoint: pressed(store), receiptGeneration: room.receiptGeneration ?? 0, ...(transition && { blockeditorGeneration: transition.id }) };
     },
 
     /** Everything a joining tab needs, with clientId's own receipt per store. Values are the room's own objects: serialize, never mutate. With since in this room's epoch, moves carries each store's log entries after since.seq (null where the log no longer reaches back that far). */
@@ -970,12 +970,12 @@ export function createRooms({ now = Date.now, newEpoch = randomUUID, liveBytes =
       }
       const hidden = Boolean(legacy && (capable !== undefined ? capable !== hostLimits.version : clientId && legacy.has(clientId)));
       for (const [name, s] of room.stores) {
-        if (hidden && name === 'page') continue;
+        if (hidden && name === 'blockeditor') continue;
         const seen = {};
         const mine = clientId ? room.lastN.get(name + '\n' + clientId) : null;
         if (mine) seen[clientId] = mine.n;
         stores[name] = { value: s.value, ephemeral: s.ephemeral, from: s.from, landed: s.landed, floor: s.floor, last: s.last, seen, ...(mine?.saved?.length && { saved: mine.saved }),
-          ...(name === 'page' && room.compaction && { compaction: { v: hostLimits.version, loose: hostLimits.loose, activeBytes: hostLimits.activeBytes } }) };
+          ...(name === 'blockeditor' && room.compaction && { compaction: { v: hostLimits.version, loose: hostLimits.loose, activeBytes: hostLimits.activeBytes } }) };
       }
       // A client's own read (since is its { epoch, seq }, or null for a first
       // read) carries moves: those after its seq in its own epoch, else this
@@ -983,8 +983,8 @@ export function createRooms({ now = Date.now, newEpoch = randomUUID, liveBytes =
       // heals other tabs already sent by their steps. A broadcast passes no since
       // and carries none.
       const provenance = { provenanceVersion: 2, receiptGeneration: room.receiptGeneration ?? 0 };
-      if (room.pageTransition) {
-        provenance.pageTransition = pageTransitionState(room.pageTransition, clientId);
+      if (room.blockeditorTransition) {
+        provenance.blockeditorTransition = pageTransitionState(room.blockeditorTransition, clientId);
       }
       if (since === undefined) return { epoch: room.epoch, seq: room.seq, writer: room.writer, stores, ...provenance };
       const from = since && since.epoch === room.epoch && Number.isInteger(since.seq) ? since.seq : 0;
@@ -1110,7 +1110,7 @@ export function createRooms({ now = Date.now, newEpoch = randomUUID, liveBytes =
         if (now() < state.job.deadline) return null;
         endJob(state.job);
       }
-      const store = room.stores.get('page');
+      const store = room.stores.get('blockeditor');
       if (!store || pageReservations.has(room.key) || persistentReservations.has(room.key)) return null;
       const plan = planCompaction(store.value.y, { overflow }, hostLimits);
       if (!plan) return null;
@@ -1118,7 +1118,7 @@ export function createRooms({ now = Date.now, newEpoch = randomUUID, liveBytes =
       if (used + reserved > liveBytes) return null;
       state.fence += 1;
       const token = Object.freeze({ key: room.key, epoch: room.epoch, fence: state.fence });
-      const job = { token, room, store, epoch: room.epoch, generation: room.pageTransition?.id ?? null, kind: plan.kind,
+      const job = { token, room, store, epoch: room.epoch, generation: room.blockeditorTransition?.id ?? null, kind: plan.kind,
         sources: new Map(plan.sources), physical: Object.keys(store.value.y), reserved, deadline: now() + hostLimits.leaseMs, deletesAtBegin: state.deletesSince };
       state.job = job;
       used += reserved;
@@ -1141,8 +1141,8 @@ export function createRooms({ now = Date.now, newEpoch = randomUUID, liveBytes =
       jobs.delete(token);
       const { room, store } = job;
       if (!endJob(job)) return { refused: 'stale-token' };
-      if (rooms.get(room.key) !== room || room.epoch !== job.epoch || room.stores.get('page') !== store ||
-        (room.pageTransition?.id ?? null) !== job.generation) return { refused: 'stale-token' };
+      if (rooms.get(room.key) !== room || room.epoch !== job.epoch || room.stores.get('blockeditor') !== store ||
+        (room.blockeditorTransition?.id ?? null) !== job.generation) return { refused: 'stale-token' };
       const y = store.value.y;
       const retire = job.physical.filter((k) => {
         const part = PART_KEY.exec(k);
@@ -1196,8 +1196,8 @@ export function createRooms({ now = Date.now, newEpoch = randomUUID, liveBytes =
         state.deletesSince -= job.deletesAtBegin;
       }
       if (pageShape(store.value.y, hostLimits).loose >= hostLimits.soft || !pageShape(store.value.y, hostLimits).normal) due(room);
-      return { seq: room.seq, epoch: room.epoch, name: 'page', ops, from: COMPACTOR, kind: job.kind, landed: store.landed,
-        ...(room.pageTransition && { pageGeneration: room.pageTransition.id }) };
+      return { seq: room.seq, epoch: room.epoch, name: 'blockeditor', ops, from: COMPACTOR, kind: job.kind, landed: store.landed,
+        ...(room.blockeditorTransition && { blockeditorGeneration: room.blockeditorTransition.id }) };
     },
 
     /** Every room's key. */

package/src/server/rooms/live-page-history.js

@@ -3,10 +3,10 @@ import { cloneJson, serializeLive } from './live-data-ops.js';
 
 export function makePageTransition({ room = null, format = 'yjs', sources = [], receipts = new Map() } = {}) {
   const archived = new Map([...receipts].map(([key, receipt]) => [key, cloneJson(receipt)]));
-  const history = [...(room?.pageTransition?.history ?? [])];
+  const history = [...(room?.blockeditorTransition?.history ?? [])];
   if (archived.size) history.push({
     epoch: room.epoch,
-    generation: room.pageTransition?.id ?? null,
+    generation: room.blockeditorTransition?.id ?? null,
     receiptGeneration: room.receiptGeneration ?? 0,
     sources: [...sources],
     receipts: archived,

package/src/server/rooms/page-admission.js

@@ -5,9 +5,9 @@ import { liveTags } from './live-data-tags.js';
 import { recent } from './recent.js';
 import { project } from '../../page/projection.js';
 import { blocksFromPageValues } from '../../page/ybind/decode.js';
-import { pageFormatDecision, pageFormatFloor, pageFormatRefusal, requiredPageFormat, withPageFormatFloor } from '../../page/format-level.js';
+import { pageFormatDecision, blockeditorFormatFloor, pageFormatRefusal, requiredPageFormat, withPageFormatFloor } from '../../page/format-level.js';
 
-const PAGE = /^page(\.[0-9]+)?$/;
+const PAGE = /^blockeditor(\.[0-9]+)?$/;
 const PART = /^(.+)\.(\d+)\.(\d+)$/;
 const record = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
 export const isHybridPageValue = (value) => record(value) && record(value.blocks) && (value.deleted == null || record(value.deleted)) && Object.keys(value).every((key) => key === 'blocks' || key === 'deleted');
@@ -37,6 +37,34 @@ export function isYPageValue(value, { complete = true } = {}) {
   return true;
 }
 
+// A live tag in the format before 1.24.0 (`merge="page"` or `page.N`) holding a Yjs envelope.
+// Hosts refuse such a write, because 1.24.0 reads none of it. An author's own live store
+// named `page` with ordinary JSON is not the block editor's and is never refused.
+const OLD_TAG = /^page(\.[0-9]+)?$/;
+const OLD_FORMAT_MSG = 'This document now uses the new Block editor format, so this change was not saved. Copy any text you need from this tab, then reload.';
+
+// Thrown by a host's save path; hosts answer it like a format refusal: 409, code and message.
+export function oldFormatRefusal() {
+  const error = new Error(OLD_FORMAT_MSG);
+  error.name = 'BlockeditorOldFormat';
+  error.code = 'blockeditor-old-format';
+  error.statusCode = 409;
+  return error;
+}
+
+export function oldBlockeditorFormat(html) {
+  if (typeof html !== 'string' || !/merge/i.test(html)) return false;
+  return liveTags(html, { includeDuplicates: true }).some((tag) => {
+    if (!OLD_TAG.test(tag.name)) return false;
+    try {
+      const value = parseJsonRelaxed(tag.text);
+      return record(value) && (Object.hasOwn(value, 'y') || Object.hasOwn(value, 'v'));
+    } catch {
+      return false;
+    }
+  });
+}
+
 // Callers get their own copy of the tags, so none can change another's answer.
 export function inspectPage(html) {
   const answer = inspected(html);
@@ -60,7 +88,7 @@ const inspected = recent(4, (html) => {
     }
   }
   if (tags.some(([, value]) => record(value) && (Object.hasOwn(value, 'y') || Object.hasOwn(value, 'v')))) {
-    if (tags.length !== 1 || tags[0][0] !== 'page' || !isYPageValue(tags[0][1])) return { kind: 'invalid', reason: 'invalid-yjs', tags };
+    if (tags.length !== 1 || tags[0][0] !== 'blockeditor' || !isYPageValue(tags[0][1])) return { kind: 'invalid', reason: 'invalid-yjs', tags };
     return { kind: 'yjs', tags };
   }
   return { kind: tags.every(([, value]) => isHybridPageValue(value)) ? 'hybrid' : 'other', tags };
@@ -94,16 +122,16 @@ export function captureFormat(html) {
 // The floor decision for one page write, taken before anything is mutated.
 // `floor` is the document's established floor, `required` what the captured
 // content needs (its own marker included) and `capability` what the writer
-// declares in X-Clay-Page-Format. `admitted` lists the capabilities of the page
+// declares in X-Clay-Blockeditor-Format. `admitted` lists the capabilities of the page
 // editors the room has admitted, so a floor rise is refused while an editor that
 // could not read the result is connected. On success the returned body carries
 // the marker the room must persist, so a stale save that omitted it cannot lower
 // the floor.
 export function checkPageFormatAdmission({ currentHtml, html, capability = 0, admitted = [] }) {
-  const established = pageFormatFloor(currentHtml ?? '');
+  const established = blockeditorFormatFloor(currentHtml ?? '');
   const decision = pageFormatDecision({
     floor: established,
-    required: Math.max(captureFormat(html), pageFormatFloor(html ?? '')),
+    required: Math.max(captureFormat(html), blockeditorFormatFloor(html ?? '')),
     capability,
     admitted,
   });

package/src/server/rooms/page-conversion.js

@@ -1,7 +1,7 @@
 import { ifMatchSatisfied } from './spec-wire.js';
 import { inspectPage, pageBaseline } from './page-admission.js';
 
-const PAGE = /^page(\.[0-9]+)?$/;
+const PAGE = /^blockeditor(\.[0-9]+)?$/;
 const BASE = /^[0-9a-f]{64}$/;
 const EPOCH = /^[A-Za-z0-9-]{1,64}$/;