@panphora/clayjs 1.23.0 → 1.24.1

package/src/core/upgrade-run.js

@@ -123,16 +123,16 @@ async function declaredRenames(htmlText) {
 const PAGE_STORE = 'script[clay~="live"][merge]';
 
 function carryPage(doc, afterDoc, article) {
-  const target = afterDoc.querySelector("article[data-page]");
+  const target = afterDoc.querySelector("article[data-blockeditor]");
   if (!target) return null;
   target.replaceWith(afterDoc.importNode(article, true));
   for (const store of doc.querySelectorAll(PAGE_STORE)) {
     const name = store.getAttribute("merge");
-    if (name !== "page" && !name.startsWith("page.")) continue;
+    if (name !== "blockeditor" && !name.startsWith("blockeditor.")) continue;
     const copy = afterDoc.importNode(store, true);
     const existing = [...afterDoc.querySelectorAll(PAGE_STORE)].find((el) => el.getAttribute("merge") === name);
     if (existing) existing.replaceWith(copy);
-    else afterDoc.querySelector("article[data-page]").after(copy);
+    else afterDoc.querySelector("article[data-blockeditor]").after(copy);
   }
   const doctype = afterDoc.doctype ? `<!DOCTYPE ${afterDoc.doctype.name}>\n` : "";
   return doctype + afterDoc.documentElement.outerHTML;
@@ -209,7 +209,7 @@ export async function prepare(update, {
   }
   const afterDoc = new DOMParser().parseFromString(result.html, "text/html");
   const before = upgrade.extractAll(doc).dataByName;
-  const article = doc.querySelector("article[data-page]");
+  const article = doc.querySelector("article[data-blockeditor]");
   if (!article && !Object.keys(before || {}).length) {
     return { ok: false, code: "undeclared", message: UNDECLARED };
   }

package/src/lib/ai-comment.js

@@ -0,0 +1,23 @@
+// The comment conventions an AI request shares: the payload ceiling, the @tokens that
+// name a context file, and whether a comment asks for the saved page.
+
+// The request ceiling, kept below the host's 1 MiB envelope so the refusal happens
+// here, where the message can say what to do about it.
+export const MAX_PAYLOAD_BYTES = 900 * 1024;
+
+// Context refs are @tokens containing a dot or slash (@notes.md, @src/x.js). Bare
+// @words are not refs: a leading one is an engine token (@fable, @codex — routed
+// helper-side), and mid-text ones are prose.
+// The @ has to start a word, so an email address or a URL is prose too.
+export function contextRefsOf(comment) {
+  return [...String(comment ?? '').matchAll(/(?<![\w\u00C0-\u024F.@\/:-])@([\w.-]*[/.][\w./-]*)/g)]
+    .map(m => m[1].replace(/\.+$/, '')) // a sentence's full stop is not part of the name
+    .filter(ref => ref !== 'page')
+    .filter(ref => /[/.]/.test(ref));
+}
+
+// Every request that names @page reads the file from disk rather than a copy in the
+// payload, so the caller has to save first and then ask for it by flag.
+export function wantsPage(comment) {
+  return /(?<![\w\u00C0-\u024F.@\/:-])@page(?![\w\/-]|\.\w)/.test(String(comment ?? ''));
+}

package/src/lib/effect.js

@@ -115,8 +115,15 @@ export function effect(fn) {
     for (const type of undoEvents) clay.undo?.on?.(type, schedule);
   };
 
+  // Shared values the host sent back are applied with observers paused, to keep them out of
+  // undo, so this event is the only sign they changed the page.
+  const onSiteData = (event) => {
+    if (event.detail?.applied?.length) schedule();
+  };
+
   const offMutation = Mutation.onAnyChange({ debounce: 0, require: "observed" }, schedule);
   document.addEventListener("clay:sync-applied", schedule);
+  document.addEventListener("clay:site-data", onSiteData);
   document.addEventListener("clay:modechange", bindUndo);
   bindUndo();
 
@@ -124,6 +131,7 @@ export function effect(fn) {
     stopped = true;
     offMutation();
     document.removeEventListener("clay:sync-applied", schedule);
+    document.removeEventListener("clay:site-data", onSiteData);
     document.removeEventListener("clay:modechange", bindUndo);
     for (const type of undoEvents) clay.undo?.off?.(type, schedule);
   };

package/src/lib/idb-error-code.js

@@ -0,0 +1,20 @@
+/**
+ * The failure code a thrown IndexedDB error means to a caller.
+ *
+ * Only one of these is about this device being full (`quota`); the rest are about
+ * the database being unreachable, refused, or mid-upgrade somewhere else. None of
+ * them is a save result, and none of them is durable.
+ *
+ * @param {*} error
+ * @returns {string}
+ */
+export function codeFor(error) {
+  const name = error?.name || "";
+  if (name === "QuotaExceededError" || name === "NS_ERROR_DOM_QUOTA_REACHED") return "quota";
+  if (name === "VersionError") return "unknown-schema";
+  if (name === "DataCloneError") return "uncloneable";
+  if (name === "AbortError") return "aborted";
+  if (name === "TransactionInactiveError" || name === "InvalidStateError") return "aborted";
+  if (name === "SecurityError" || name === "UnknownError" || name === "NotSupportedError") return "unavailable";
+  return "error";
+}

package/src/live/fast-lane.js

@@ -24,7 +24,7 @@ export const FRAME_BYTES = 63 * 1024;
 // What a host still on the old 16 KB body cap takes: a multi-op frame it
 // answers 413 is packed again at this size for the rest of the session.
 export const OLD_FRAME_BYTES = 15 * 1024;
-const PAGE_STORE = /^page(\.[0-9]+)?$/;
+const PAGE_STORE = /^blockeditor(\.[0-9]+)?$/;
 const BUFFER_MAX = 512;
 const RETRY_MAX_MS = 8000;
 const REVOKED = new Set([401, 403]);
@@ -79,7 +79,7 @@ export function createFastLane({
   let synced = false;
   let epoch = null;
   let receiptGeneration = null;
-  let pageGeneration = null;
+  let blockeditorGeneration = null;
   let provenanceVersion = 0;
   let seq = 0;
   let writer = null;
@@ -202,7 +202,7 @@ export function createFastLane({
         count++;
       }
       const take = lane.unsent.splice(0, count);
-      const frame = { n: ++lane.n, ops: take.map((entry) => entry.op), entries: take, first: take[0].id, through: take[take.length - 1].id, seq: null, sent: false, receiptGeneration, pageGeneration };
+      const frame = { n: ++lane.n, ops: take.map((entry) => entry.op), entries: take, first: take[0].id, through: take[take.length - 1].id, seq: null, sent: false, receiptGeneration, blockeditorGeneration };
       markAdopted(lane, frame);
       lane.framed = Math.max(lane.framed, frame.through);
       lane.awaiting.push(frame);
@@ -231,7 +231,7 @@ export function createFastLane({
     lastSentAt = now();
     let result;
     try {
-      result = await transport.send(clientId, { name, n: frame.n, ops: frame.ops, epoch: sentEpoch, ...(conn !== undefined && { conn }), ...(frame.receiptGeneration !== null && { receiptGeneration: frame.receiptGeneration }), ...(frame.pageGeneration !== null && PAGE_STORE.test(name) && { pageGeneration: frame.pageGeneration }), ...(frame.adopted && { adopted: frame.adopted }), ...(PAGE_STORE.test(name) && lane.compaction?.v === 1 && { compaction: 1 }) });
+      result = await transport.send(clientId, { name, n: frame.n, ops: frame.ops, epoch: sentEpoch, ...(conn !== undefined && { conn }), ...(frame.receiptGeneration !== null && { receiptGeneration: frame.receiptGeneration }), ...(frame.blockeditorGeneration !== null && PAGE_STORE.test(name) && { blockeditorGeneration: frame.blockeditorGeneration }), ...(frame.adopted && { adopted: frame.adopted }), ...(PAGE_STORE.test(name) && lane.compaction?.v === 1 && { compaction: 1 }) });
     } catch {
       result = null;
     }
@@ -255,7 +255,7 @@ export function createFastLane({
       frame.sent = false;
       frame.seq = null;
       if (frame.epoch !== epoch) frame.receiptGeneration = receiptGeneration;
-      if (frame.epoch !== epoch) frame.pageGeneration = pageGeneration;
+      if (frame.epoch !== epoch) frame.blockeditorGeneration = blockeditorGeneration;
       return;
     }
     // Its store left the room meanwhile: its ops stay pending for the save,
@@ -494,9 +494,9 @@ export function createFastLane({
     const fresh = state.epoch !== epoch;
     provenanceVersion = Number.isInteger(state.provenanceVersion) ? state.provenanceVersion : 0;
     receiptGeneration = Number.isSafeInteger(state.receiptGeneration) ? state.receiptGeneration : null;
-    const priorGeneration = pageGeneration;
-    pageGeneration = typeof state.pageTransition?.id === "string" ? state.pageTransition.id : null;
-    const replaced = pageGeneration !== priorGeneration;
+    const priorGeneration = blockeditorGeneration;
+    blockeditorGeneration = typeof state.blockeditorTransition?.id === "string" ? state.blockeditorTransition.id : null;
+    const replaced = blockeditorGeneration !== priorGeneration;
     let joined = false;
     // Every store is read whole here.
     missed = false;
@@ -573,7 +573,7 @@ export function createFastLane({
           frame.sent = false;
           frame.seq = null;
           frame.receiptGeneration = receiptGeneration;
-          frame.pageGeneration = pageGeneration;
+          frame.blockeditorGeneration = blockeditorGeneration;
         }
         lane.awaiting = resend;
         entry.store.rebase(room.value, { source: "state", dropIds, room: { seq, fresh: true, moves: state.moves?.[name] ?? null, floor: Number.isInteger(room.floor) ? room.floor : null, compaction: lane.compaction } });
@@ -842,7 +842,7 @@ export function createFastLane({
           const take = pending.splice(0, count);
           const frame = { n: ++lane.n, ops: take.map((e) => e.op), entries: take,
             first: take[0].id, through: take[take.length - 1].id, seq: null,
-            sent: false, refused: true, epoch, client: clientId, receiptGeneration, pageGeneration };
+            sent: false, refused: true, epoch, client: clientId, receiptGeneration, blockeditorGeneration };
           markAdopted(lane, frame);
           lane.awaiting.push(frame);
           lane.framed = frame.through;

package/src/live/local-lane.js

@@ -68,11 +68,11 @@ const encoder = new TextEncoder();
 // Floor 1 moves the durable lane to its own channel scope: a tab that cannot read
 // floor 1 never receives future-format updates, and its writes are refused by the
 // host floor. The message protocol inside the scope is unchanged.
-export const FORMAT_SCOPE = "page-format:1";
+export const FORMAT_SCOPE = "blockeditor-format:1";
 
 // The room scope: this lane's sequencer is a host-mode room, so a tab of the lane
 // before it, which cannot read that room, is never on the same channel or lock.
-export const ROOM_SCOPE = "page-rooms:2";
+export const ROOM_SCOPE = "blockeditor-rooms:2";
 
 export function localLaneKey(floor = 0, path = window.location.pathname) {
   const base = "clay-live:" + path;
@@ -193,7 +193,7 @@ export function localTransport({ seed, key = "clay-live:" + window.location.path
     const meta = {};
     for (const [name, m] of mirror.stores) {
       stores[name] = { value: cloneJson(m.value), ephemeral: m.ephemeral, seen: receiptsFor(name), last: m.last, landed: landedIn(m) };
-      if (name === "page" && isYValue(m.value)) stores[name].compaction = { v: COMPACTION.version, loose: COMPACTION.loose, activeBytes: COMPACTION.activeBytes };
+      if (name === "blockeditor" && isYValue(m.value)) stores[name].compaction = { v: COMPACTION.version, loose: COMPACTION.loose, activeBytes: COMPACTION.activeBytes };
       meta[name] = { log: m.log, last: m.last, landed: m.landed, floor: m.floor, behind: m.behind, file: m.file, inFile: m.inFile };
     }
     const state = { epoch: room.epoch, seq: room.seq, writer: clientId, stores, mirror: { seen: [...mirror.seen], stores: meta } };
@@ -386,7 +386,7 @@ export function localTransport({ seed, key = "clay-live:" + window.location.path
   const pageHost = () => ({ retired: new Set(), lastFull: null, deletesSince: 0, failed: null, ranges: createRangeCache(), task: null, overflow: false });
 
   const pageStore = () => {
-    const m = mirror.stores.get("page");
+    const m = mirror.stores.get("blockeditor");
     return m && !m.ephemeral && isYValue(m.value) ? m : null;
   };
 
@@ -471,14 +471,14 @@ export function localTransport({ seed, key = "clay-live:" + window.location.path
       host.lastFull = { bytes, seq: room.seq };
       host.deletesSince = 0;
     }
-    const data = { epoch: room.epoch, seq: room.seq, name: "page", ops, from: "compactor", n: 0, kind: plan.kind };
+    const data = { epoch: room.epoch, seq: room.seq, name: "blockeditor", ops, from: "compactor", n: 0, kind: plan.kind };
     advance(data);
     if (clean) m.landed = room.seq;
     post({ type: "data", data });
     handlers.frame(cloneJson(data));
     if (clean) {
-      tellLanded(["page"]);
-      post({ type: "landed", name: "page", at: { epoch: room.epoch, seq: room.seq } });
+      tellLanded(["blockeditor"]);
+      post({ type: "landed", name: "blockeditor", at: { epoch: room.epoch, seq: room.seq } });
     }
     const shape = pageShape(m.value.y, COMPACTION);
     if (shape.loose >= COMPACTION.soft || !shape.normal) due();
@@ -502,7 +502,7 @@ export function localTransport({ seed, key = "clay-live:" + window.location.path
       return { status: 422, body: { error: err.message }, retryAfter: 0 };
     }
     const host = room.host;
-    const admission = frame.name === "page" && isYValue(m.value) ? admitPageOps({ y: m.value.y, ops, state: { ...host, compaction: frame.compaction }, limits: COMPACTION }) : null;
+    const admission = frame.name === "blockeditor" && isYValue(m.value) ? admitPageOps({ y: m.value.y, ops, state: { ...host, compaction: frame.compaction }, limits: COMPACTION }) : null;
     if (admission?.error) {
       if (admission.error === "checkpoint-required") due();
       return refused(admission.error, admission.retryAfter);
@@ -516,7 +516,7 @@ export function localTransport({ seed, key = "clay-live:" + window.location.path
     const bytes = admission ? pageBytes(trial.value) : 0;
     trial.undo();
     if (admission && bytes > admission.limit) {
-      if (admission.failed || (host.lastFull && host.deletesSince === 0)) return refused("page-full");
+      if (admission.failed || (host.lastFull && host.deletesSince === 0)) return refused("blockeditor-full");
       due(true);
       return refused("checkpoint-required");
     }
@@ -572,7 +572,7 @@ export function localTransport({ seed, key = "clay-live:" + window.location.path
     }
     if (value === null || typeof value !== "object" || Array.isArray(value) !== Array.isArray(m.value)) return null;
     const file = { seq: seq ?? null, hash: textHash(serializeLive(value)) };
-    if (name === "page" && isYValue(m.value) && isYValue(value)) return mergePageFile(m, value, file);
+    if (name === "blockeditor" && isYValue(m.value) && isYValue(value)) return mergePageFile(m, value, file);
     // A stamp of this room places the file. Still the value its stamp names, it
     // is a capture and holds no merge past the stamp; edited, or unstamped, it
     // descends from the file before it, which holds the merges in inFile.

package/src/live/page-compaction.js

@@ -16,8 +16,8 @@ export const COMPACTION = Object.freeze({
 });
 
 export const ROOM_ERROR_STATUS = Object.freeze({
-  'checkpoint-required': 503, 'page-full': 409, 'compaction-failed': 409,
-  'page-immutable': 409, 'page-batch': 409, 'page-update-invalid': 422, 'page-upgrade': 404,
+  'checkpoint-required': 503, 'blockeditor-full': 409, 'compaction-failed': 409,
+  'blockeditor-immutable': 409, 'blockeditor-batch': 409, 'blockeditor-update-invalid': 422, 'blockeditor-upgrade': 404,
 });
 
 export const CLIENT_KEY = /^[ur][0-9a-z]+(-[0-9a-z]+){2}$/;
@@ -98,25 +98,25 @@ export function checkUpdate(text) {
 }
 
 export function admitPageOps({ y, ops, state, limits }) {
-  if (state.compaction !== limits.version) return { error: 'page-upgrade' };
+  if (state.compaction !== limits.version) return { error: 'blockeditor-upgrade' };
   let added = 0;
   let deleted = 0;
   let inserts = false;
   for (const op of ops) {
     const key = op.path?.[1];
-    if (op.op !== 'set' || typeof key !== 'string' || !CLIENT_KEY.test(key)) return { error: 'page-immutable' };
+    if (op.op !== 'set' || typeof key !== 'string' || !CLIENT_KEY.test(key)) return { error: 'blockeditor-immutable' };
     if (Object.hasOwn(y, key)) {
-      if (y[key] !== op.value) return { error: 'page-immutable' };
+      if (y[key] !== op.value) return { error: 'blockeditor-immutable' };
       continue;
     }
-    if (state.retired.has(key)) return { error: 'page-immutable' };
+    if (state.retired.has(key)) return { error: 'blockeditor-immutable' };
     const checked = checkUpdate(op.value);
-    if (!checked) return { error: 'page-update-invalid' };
+    if (!checked) return { error: 'blockeditor-update-invalid' };
     added += 1;
     deleted += checked.deleted;
     inserts ||= checked.inserts;
   }
-  if (added > limits.newPerFrame) return { error: 'page-batch' };
+  if (added > limits.newPerFrame) return { error: 'blockeditor-batch' };
   // A page whose compaction failed keeps taking edits up to its byte limit, as a room
   // without compaction does, and refuses past it as full instead of waiting for a fold.
   if (state.failed) return { added, deleted, inserts, limit: limits.activeBytes + (inserts ? 0 : limits.deleteReserve), shape: null, failed: true };

package/src/live/server-lane.js

@@ -5,7 +5,7 @@ import { PAGE_FORMAT, PAGE_FORMAT_HEADER } from "../core/page-format.js";
 // one POST per frame of ops, one GET for the room's whole state. Both name the
 // document with Document-URL, as the sync relay and presence do, and both declare
 // the page format this client writes: registration, operation and checkpoint are
-// page-writing paths, so each one carries the capability the floor decides on.
+// blockeditor-writing paths, so each one carries the capability the floor decides on.
 
 const DATA_PATH = "/_/sync/data";
 

package/src/loader-logic.js

@@ -39,10 +39,10 @@ export const PLUGIN_PATHS = {
   // A live JSON tag as an in-memory object (clay.live). Not editOnly: a reader's
   // tab still shows the game, and its writes stay in that tab.
   live:      { path: "plugins/live.js",           editOnly: false, default: false },
-  page:      { path: "plugins/page.js",           editOnly: true,  default: false },
-  // The reader half of `page`, added by resolveModules for a Document in view mode
+  blockeditor: { path: "plugins/page.js",          editOnly: true,  default: false },
+  // The reader half of `blockeditor`, added by resolveModules for a Document in view mode
   // and never named in a URL: the reader's article follows each saved file.
-  "page-view": { path: "plugins/page-view.js", editOnly: false, default: false, internal: true },
+  "blockeditor-view": { path: "plugins/page-view.js", editOnly: false, default: false, internal: true },
   sortable:  { path: "plugins/sortable.js",        editOnly: true,  default: false },
   undo:      { path: "plugins/undo.js",            editOnly: true,  default: false },
   unsent:    { path: "plugins/unsent.js",          editOnly: true,  default: false },
@@ -118,6 +118,7 @@ export const MODULES = {
   "core/snapshot.js":           () => import("./core/snapshot.js"),
   "core/save-core.js":          () => import("./core/save-core.js"),
   "core/save.js":               () => import("./core/save.js"),
+  "core/site-edits.js":         () => import("./core/site-edits.js"),
   "core/conflict-notice.js":     () => import("./core/conflict-notice.js"),
   "core/recovery.js":           () => import("./core/recovery.js"),
   "core/unsaved-warning.js":    () => import("./core/unsaved-warning.js"),
@@ -159,7 +160,7 @@ export const MODULES = {
 
 // `source` is last on purpose: its install captures a save clone, so it wants every
 // plugin that registers a document transform to have registered it first.
-const PLUGIN_ORDER = ["visitor-drafts", "visitor-menu", "richclay", "indicator", "sortable", "undo", "unsent", "quickcrop", "upload", "people", "menu", "upgrade", "cms", "page-view", "sync", "live", "page", "message", "like", "wire", "ai-edit", "demo", "derive", "bind-text", "source"];
+const PLUGIN_ORDER = ["visitor-drafts", "visitor-menu", "richclay", "indicator", "sortable", "undo", "unsent", "quickcrop", "upload", "people", "menu", "upgrade", "cms", "blockeditor-view", "sync", "live", "blockeditor", "message", "like", "wire", "ai-edit", "demo", "derive", "bind-text", "source"];
 
 // A plugin that cannot do its whole job alone. hypercms reads the cropper through
 // a capability lookup (`clay.quickcrop`) and silently uploads the raw file when it
@@ -189,15 +190,22 @@ const PLUGIN_ORDER = ["visitor-drafts", "visitor-menu", "richclay", "indicator",
 // The menu is how a person opens the CMS: hypercms adds no button of its own. It loads
 // in view too, because that is where a person starts, and it shows itself only to
 // someone who can edit. A page with its own control uses exclude=menu.
-const IMPLIES = { cms: ["quickcrop", "upload", "menu"], "ai-edit": ["wire"], page: ["live", "sync", "upload"] };
+const IMPLIES = { cms: ["quickcrop", "upload", "menu"], "ai-edit": ["wire"], blockeditor: ["live", "sync", "upload", "wire", "ai-edit"] };
 
 // A Document's editor owns its article's rich text, so richclay (for [editable]) has
-// nothing to do there; plugins=page,richclay still loads it.
-const DISPLACES = { page: ["richclay"] };
+// nothing to do there; plugins=blockeditor,richclay still loads it.
+const DISPLACES = { blockeditor: ["richclay"] };
+// A Document's editor keeps its own history, the same one Cmd+Z in the editor uses, and
+// hyper-undo takes Cmd+Z for the whole window: loaded together the two would fight over
+// every press. This is the one pair where a name the page asked for by hand still loses.
+const CANNOT_RUN_WITH = { blockeditor: ["undo"] };
 // No first paint or keystroke waits for these. source keeps the file's bytes outside
 // the edited parts stable; a save before it installs is the ordinary full serialization.
 // upgrade only asks the host for a newer version once `clay.ready` resolves.
+// The editor half of `blockeditor` owns AI editing, so only a page that asked for it can wait
+// for the wire and the composer; everywhere else they are ordinary plugins.
 const LATE = new Set(["source", "sortable", "menu", "upgrade"]);
+const LATE_WITH_PAGE = new Set(["wire", "ai-edit"]);
 
 function parseCsv(params, key, enabled, apply) {
   const raw = params.get(key);
@@ -214,8 +222,15 @@ function parseCsv(params, key, enabled, apply) {
 }
 
 // Each of these talks to the host or writes outside the visitor's own record, so a
-// page that keeps its edits in this browser cannot carry them.
-const DRAFT_DROPS = ["sync", "live", "page", "upload", "quickcrop", "cms", "people", "menu", "upgrade", "wire", "ai-edit", "demo", "source"];
+// page that keeps its edits in this browser cannot carry them. A page document keeps
+// page and live: the editor runs on a store this browser keeps.
+const DRAFT_DROPS = ["sync", "live", "blockeditor", "upload", "quickcrop", "cms", "people", "menu", "upgrade", "wire", "ai-edit", "demo", "source"];
+
+// The one core module a document asks for by what it declares: shared site values are
+// tracked only on a page whose rules tag names them, and only where a save reaches the
+// host (a visitor's draft is saved into this browser). It goes after the save modules,
+// which it registers with. No other document ever fetches it.
+export const SITE_EDITS = "core/site-edits.js";
 
 // [refetch-on-save] swaps its element for a fresh GET of the same URL after every
 // save, which on a visitor's own draft is a request to the host. The conflict notice
@@ -225,9 +240,10 @@ const DRAFT_DROPS_CORE = ["attrs/refetch-on-save.js", "core/conflict-notice.js"]
 // Only that host's copies auto-add the update check; another source names it.
 const TEMPLATE_SOURCE_PREFIX = "https://hyperclay.com/templates/";
 
-export function resolveModules(params, isEditMode, { isDraftMode = false, hasSap = false, hasVariants = false, canEdit = false, templateSource = null } = {}) {
+export function resolveModules(params, isEditMode, { isDraftMode = false, hasSap = false, hasVariants = false, hasSite = false, canEdit = false, templateSource = null } = {}) {
   const core = [...CORE_WAVES.always];
   if (isEditMode) core.push(...CORE_WAVES.editOnly);
+  if (isEditMode && !isDraftMode && hasSite) core.splice(core.indexOf("core/save.js") + 1, 0, SITE_EDITS);
 
   const explicit = new Set();
   parseCsv(params, "plugins", explicit, (set, name) => set.add(name));
@@ -241,23 +257,27 @@ export function resolveModules(params, isEditMode, { isDraftMode = false, hasSap
   if (hasSap) enabled.add("derive");
   // Two or more looks need the dock's variant pill, and only someone who can edit sees it.
   if (hasVariants && (isEditMode || canEdit)) enabled.add("menu");
-  // ai-edit cannot run without the wire, so excluding the wire excludes it too.
-  if (excluded.has("wire")) enabled.delete("ai-edit");
-  if (!isEditMode && !isDraftMode && enabled.has("page")) enabled.add("page-view");
+  if (!isEditMode && !isDraftMode && enabled.has("blockeditor")) enabled.add("blockeditor-view");
   // A plugin this mode does not load brings nothing with it, whether a default put
   // it in the set or the tag named it. A page that wants what an edit-only plugin
-  // implies in view mode names that plugin too. `page` is the case that matters
+  // implies in view mode names that plugin too. `blockeditor` is the case that matters
   // most: a reader loads its reader half and no generic sync, live data service or
-  // upload, so `plugins=page` in view mode resolves to page-view alone and the
-  // saved transport page-view owns is the only stream.
+  // upload, so `plugins=blockeditor` in view mode resolves to blockeditor-view alone and the
+  // saved transport blockeditor-view owns is the only stream.
   for (const name of [...enabled]) {
     if (excluded.has(name)) continue;
     if (PLUGIN_PATHS[name].editOnly && !isEditMode) continue;
     for (const implied of IMPLIES[name] || []) enabled.add(implied);
   }
+  // ai-edit cannot run without the wire, so excluding the wire excludes it too. After
+  // the implications, or a page that implies ai-edit would re-add it without a wire.
+  if (excluded.has("wire")) enabled.delete("ai-edit");
   for (const name of excluded) enabled.delete(name);
   if (isDraftMode) {
-    for (const name of DRAFT_DROPS) enabled.delete(name);
+    // A page document keeps its editor and the store under it: a visitor edits the real
+    // page, and the save pipeline's draft transport is its only host.
+    const keepsPage = enabled.has("blockeditor");
+    for (const name of DRAFT_DROPS) if (!(keepsPage && (name === "blockeditor" || name === "live"))) enabled.delete(name);
     for (const path of DRAFT_DROPS_CORE) {
       const at = core.indexOf(path);
       if (at > -1) core.splice(at, 1);
@@ -276,13 +296,23 @@ export function resolveModules(params, isEditMode, { isDraftMode = false, hasSap
     if (enabled.has(owner)) for (const name of names) if (!explicit.has(name)) enabled.delete(name);
   }
 
+  for (const [owner, names] of Object.entries(CANNOT_RUN_WITH)) {
+    if (!enabled.has(owner)) continue;
+    for (const name of names) {
+      if (!enabled.has(name)) continue;
+      enabled.delete(name);
+      console.warn(`clayjs: plugin "${name}" cannot run with "${owner}" and was left out`);
+    }
+  }
+
   const plugins = [];
   const late = [];
   for (const name of PLUGIN_ORDER) {
     if (!enabled.has(name)) continue;
     const spec = PLUGIN_PATHS[name];
     if ((spec.editOnly && !isEditMode) || (spec.draft && !isDraftMode)) continue;
-    (LATE.has(name) ? late : plugins).push(spec.ownerPath && !isDraftMode ? spec.ownerPath : spec.path);
+    const lateHere = LATE.has(name) || (LATE_WITH_PAGE.has(name) && enabled.has("blockeditor"));
+    (lateHere ? late : plugins).push(spec.ownerPath && !isDraftMode ? spec.ownerPath : spec.path);
   }
   return { core, plugins, late };
 }

package/src/loader.js

@@ -87,10 +87,13 @@ export async function boot(base, params, readyResolve, manifest = null, suppleme
 
   const hasSap = Boolean(document.querySelector("[sap]"));
   const hasVariants = document.querySelectorAll("head style[clay-variant]").length >= 2;
+  // A page of a multi-page site names the values every page shares under `site` in its
+  // rules tag. core/site-edits.js makes the same test before it does anything.
+  const hasSite = /(?:^|[{,])\s*["']?site["']?\s*:/.test(document.querySelector('script[data-rules-name~="api"]')?.textContent ?? "");
   // derive.js imports the sapjs core only when no sap.js script took the page over.
   const hasSapJs = Boolean(document.querySelector('script[src*="sap.js"]'));
   bootPhase.holdSettle = hasSap && isEditMode;
-  const plan = resolveModules(params, isEditMode, { isDraftMode, hasSap, hasVariants, canEdit, templateSource: templateSource() });
+  const plan = resolveModules(params, isEditMode, { isDraftMode, hasSap, hasVariants, hasSite, canEdit, templateSource: templateSource() });
   // Where edits land, resolved once: a visitor draft saves into its draft slot, the
   // demo plugin into localStorage, and everything else to the host. setMode takes no
   // destination, and V4 has no draft-to-host transition.
@@ -127,13 +130,13 @@ export async function boot(base, params, readyResolve, manifest = null, suppleme
   // Nothing is fetched for it here: the decision and the controller behind it wait for the
   // first switch, so this costs a reader with a declaration no more than one attribute.
   if (document.documentElement.getAttribute("clay-mode-switch") === "live") {
-    const editing = resolveModules(params, true, { isDraftMode, hasSap, hasVariants, canEdit, templateSource: templateSource() });
+    const editing = resolveModules(params, true, { isDraftMode, hasSap, hasVariants, hasSite, canEdit, templateSource: templateSource() });
     loaded["core/edit-mode.js"].noteLiveSwitch({
       edit: editing,
       // The plan a view boot would have resolved, not the edit plan this boot resolved: an
       // exit imports it and starts its reader, and an edit-only module belongs to the
       // session being left.
-      view: resolveModules(params, false, { isDraftMode, hasSap, hasVariants, canEdit, templateSource: templateSource() }),
+      view: resolveModules(params, false, { isDraftMode, hasSap, hasVariants, hasSite, canEdit, templateSource: templateSource() }),
       loaded,
       modules: MODULES,
       // A live entry attaches the edit plugins after boot: clay.plugins names them from then on.
@@ -154,7 +157,7 @@ export async function boot(base, params, readyResolve, manifest = null, suppleme
   await loaded["core/edit-mode.js"].activateInitialMode();
   window.clay.plugins = Object.freeze([...plan.plugins, ...plan.late].map((path) => PLUGIN_NAMES[path]));
   // What an edit session here would load, so view-mode chrome can offer an edit-only feature.
-  const editPlan = isEditMode ? plan : resolveModules(params, true, { isDraftMode, hasSap, hasVariants, canEdit, templateSource: templateSource() });
+  const editPlan = isEditMode ? plan : resolveModules(params, true, { isDraftMode, hasSap, hasVariants, hasSite, canEdit, templateSource: templateSource() });
   window.clay.editPlugins = Object.freeze([...editPlan.plugins, ...editPlan.late].map((path) => PLUGIN_NAMES[path]));
 
   for (const path of plan.plugins) {
@@ -171,6 +174,8 @@ export async function boot(base, params, readyResolve, manifest = null, suppleme
       continue;
     }
     loaded[path] = mod;
+    // A draft held only in the database goes onto the page before a plugin that reads the page loads.
+    if (path === "plugins/visitor-drafts.js") await mod.restoring;
     if (path === "plugins/page-view.js") mod.start(readerOptions);
     attachPluginMember(path, mod, loaded); // immediately, not after the loop: hypercms's ?cms=true
                                      // auto-open runs as a microtask queued during ITS evaluation
@@ -209,7 +214,7 @@ const stale = (path, editMode) =>
 // degrades to absent as at boot.
 async function loadLate(paths, editMode) {
   try {
-    await window.clay.page?.ready;
+    await window.clay.blockeditor?.ready;
   } catch {}
   for (const path of paths) {
     if (stale(path, editMode)) continue;
@@ -357,7 +362,7 @@ function attachPluginMember(path, mod, namespaces = loaded) {
   } else if (path === "plugins/live.js") {
     clay.live = mod.live;
   } else if (path === "plugins/page.js") {
-    clay.page = mod.page;
+    clay.blockeditor = mod.page;
   } else if (path === "plugins/upgrade.js") {
     clay.save = clay.save || {};
     clay.save.replace = mod.replace;

package/src/page/adopt-boot.js

@@ -201,7 +201,7 @@ export function installAdoption({
         if (!outcome.ok || outcome.outcome !== "adopted") return outcome;
         requestCheckpoint();
         notice(outcome.counts);
-        doc.dispatchEvent(new CustomEvent("clay:page-adopted", { detail: outcome.counts }));
+        doc.dispatchEvent(new CustomEvent("clay:blockeditor-adopted", { detail: outcome.counts }));
         return outcome;
       });
     return queue;

package/src/page/adopt.js

@@ -13,7 +13,7 @@ import { DEFAULTS, project, canon, revOf, parseModel, renderModel, fragmentClean
 import { unflatten } from "./inline.js";
 import { blocksFromPageValues } from "./ybind/decode.js";
 
-export const ADOPT = "page-adopt";
+export const ADOPT = "blockeditor-adopt";
 const same = (a, b) => canon(a) === canon(b);
 const body = ({ id, parent, ...rest }) => ({ ...rest, parent: parent ?? null });
 
@@ -85,7 +85,7 @@ const opaqueNode = (schema, id, block) => {
 
 // The editor’s blocks as the article and the record state them: an opaque node
 // stands for the record it carries, never for a block type of its own.
-const recordsOf = (blocks) => Object.fromEntries(Object.entries(blocks).map(([id, b]) => {
+export const recordsOf = (blocks) => Object.fromEntries(Object.entries(blocks).map(([id, b]) => {
   if (b.t !== "opaque_block") return [id, b];
   const { t: _t, raw, ...rest } = b;
   const { t, ...fields } = raw ?? {};