@panphora/clayjs 1.15.2 → 1.17.0

package/src/page/format-gate.js

@@ -0,0 +1,179 @@
+// The format gate: the one place a new-format command asks whether the document
+// may use that format yet.
+//
+// R understands floor 1 and sends that capability on every page write, but has
+// no floor-1 command of its own. F's first new-format command calls this gate
+// before it touches content:
+//
+//   const gate = createFormatGate({ host, installed, revision, lane });
+//   const result = await gate.run({ apply: (selection) => command(selection) });
+//
+// Activation adds the canonical marker to an otherwise equivalent capture and
+// nothing else. It is idempotent, it is refused while an admitted page editor
+// could not read floor 1, and a refusal leaves ordinary writing and every
+// unsaved store exactly as they were. The command that asked only applies if the
+// same editor installation and document revision still exist afterwards;
+// otherwise the answer is retryable and the content is untouched.
+//
+// The host seam is deliberately one object, because the floor is read, checked
+// and persisted under one per-document lock:
+//
+//   read()        -> Promise<{ floor, revision }>   the canonical floor as it stands
+//   capabilities()-> Promise<number[]>              admitted page editors' declared capabilities
+//   activate({ floor, capability, revision })
+//                 -> Promise<{ accepted: true, revision, receipt }
+//                          | { accepted: false, code }>
+//
+// `activate` holds the document's admission/write lock while it checks the
+// admitted editors again and persists the marker, so a legacy registration that
+// lands between `capabilities()` and `activate()` is refused rather than missed.
+
+import { PAGE_FORMAT, PAGE_FORMAT_EXTENSION, PAGE_FORMAT_UPGRADE, formatCapability, notePageFormatFloor, pageFormatDecision, pageFormatFloor } from "./format-level.js";
+
+const UPGRADE_MESSAGE = "This document uses a newer page format; update the editor in the other tabs to keep writing";
+
+const upgrade = (required) => ({ status: "upgrade-required", code: PAGE_FORMAT_UPGRADE, required, minimum: required, message: UPGRADE_MESSAGE });
+
+export function createFormatGate({
+  host,
+  capability = PAGE_FORMAT,
+  supported = () => true,
+  installed = () => null,
+  revision = () => null,
+  lane = null,
+} = {}) {
+  if (!host || typeof host.activate !== "function") throw new TypeError("format-gate: a host adapter is required");
+  let floor = 0;
+  let pending = null;
+  let lanePending = false;
+  let disposed = false;
+
+  // The floor this gate knows the document at. A save or a room answer can tell
+  // it, so a gate opened on an already-floor-1 document never asks to activate
+  // again.
+  function note(level) {
+    floor = Math.max(floor, formatCapability(level));
+    notePageFormatFloor(floor);
+    return floor;
+  }
+
+  async function read() {
+    try {
+      const answer = await host.read();
+      note(answer?.floor ?? pageFormatFloor(answer?.html));
+    } catch {}
+    return floor;
+  }
+
+  async function admittance() {
+    try {
+      const admitted = await host.capabilities();
+      return Array.isArray(admitted) ? admitted : [];
+    } catch {
+      return [];
+    }
+  }
+
+  // Whether a floor rise may happen at all: the host must have announced the
+  // format contract, and this runtime must declare the capability it writes with.
+  async function supportedHere() {
+    try {
+      return (await supported()) !== false;
+    } catch {
+      return false;
+    }
+  }
+
+  async function activateNow() {
+    if (disposed) return { status: "disposed", retry: false };
+    if (!(await supportedHere())) return { status: "unsupported-host", code: "page-format-unsupported", extension: PAGE_FORMAT_EXTENSION };
+    await read();
+    if (floor >= PAGE_FORMAT) return { status: "active", floor };
+    const admitted = await admittance();
+    const early = pageFormatDecision({ floor, required: PAGE_FORMAT, capability, admitted });
+    if (!early.ok) return upgrade(early.minimum);
+    const stamp = { revision: revision(), installed: installed() };
+    let answer;
+    try {
+      answer = await host.activate({ floor: PAGE_FORMAT, capability, revision: stamp.revision, installed: stamp.installed });
+    } catch (error) {
+      return { status: "failed", code: "page-format-activation-failed", error, retry: true };
+    }
+    if (!answer || answer.accepted !== true) {
+      if (answer?.code === PAGE_FORMAT_UPGRADE) return upgrade(PAGE_FORMAT);
+      return { status: "failed", code: answer?.code ?? "page-format-activation-failed", retry: true };
+    }
+    if (disposed) {
+      // The save was accepted, so the document is at floor 1 either way; this
+      // tab is gone and must not act on it.
+      note(PAGE_FORMAT);
+      return { status: "disposed", retry: false };
+    }
+    note(PAGE_FORMAT);
+    lanePending = true;
+    await joinLane(answer.receipt ?? null);
+    return { status: "active", floor, receipt: answer.receipt ?? null };
+  }
+
+  // Joining the new lane scope happens after the receipt is accepted, and only
+  // then: an interrupted switch leaves this tab on floor 0's scope with every
+  // store intact and the switch still pending, never a lane it cannot cover.
+  async function joinLane(receipt) {
+    if (!lane || !lanePending) return false;
+    try {
+      const result = await lane.switchTo({ floor: PAGE_FORMAT, receipt });
+      if (result && result.status === "switched") {
+        lanePending = false;
+        return true;
+      }
+    } catch {}
+    return false;
+  }
+
+  function activate() {
+    if (disposed) return Promise.resolve({ status: "disposed", retry: false });
+    if (floor >= PAGE_FORMAT) return joinLane(null).then(() => ({ status: "active", floor }));
+    if (!pending) pending = activateNow().finally(() => { pending = null; });
+    return pending;
+  }
+
+  return {
+    get floor() {
+      return floor;
+    },
+    get disposed() {
+      return disposed;
+    },
+    note,
+    read,
+    // Activation, once: a second caller while one is in flight waits on the
+    // same attempt, and a retry after a failure starts a new one.
+    activate,
+    // A new-format command: capture what it applies to, ask the gate, and apply
+    // only when activation succeeded and nothing moved underneath it.
+    async run(command) {
+      const stamp = { revision: revision(), installed: installed() };
+      const result = await activate();
+      if (result.status !== "active") return result;
+      if (disposed) return { status: "disposed", retry: false };
+      if (revision() !== stamp.revision || installed() !== stamp.installed) {
+        return { status: "retry", code: "format-gate-stale", retry: true };
+      }
+      return { status: "applied", floor, result: await command?.apply?.(stamp) };
+    },
+    // Retry what is still pending: a lane switch whose receipt is in hand, or an
+    // activation that failed on the wire. Unsaved work is never part of this.
+    async retry() {
+      if (disposed) return { status: "disposed", retry: false };
+      if (await joinLane(null)) return { status: "active", floor };
+      return activate();
+    },
+    // Disposal while awaiting the save: the answer is not applied, the lane is
+    // not switched, and the deferred command does not run.
+    dispose() {
+      disposed = true;
+      lanePending = false;
+      return { status: "disposed" };
+    },
+  };
+}

package/src/page/format-host.js

@@ -0,0 +1,54 @@
+// The production host adapter behind the format gate: the floor the document is
+// already at, the host's own admission answer, and the one explicit save that
+// raises it.
+//
+// The host is the authority, so `capabilities()` answers nothing here: the editors
+// admitted to the document are checked under its admission/write lock when the save
+// carrying the marker arrives, which is the check no registration can race. A save
+// refused there reports `page-format-upgrade-required` like any other refusal, and
+// this tab stays at the floor it already knew.
+//
+// Nothing is noted before the host answers: `notePageFormatFloor` runs when the gate
+// accepts the activation, so a refusal leaves every later save at floor 0.
+
+import { PAGE_FORMAT, PAGE_FORMAT_META, PAGE_FORMAT_UPGRADE, knownPageFormatFloor, pageFormatFloor } from "./format-level.js";
+import { hostPageFormat } from "../core/host-meta.js";
+
+const FAILED = "page-format-activation-failed";
+
+// The document's own marker, as it was served. A tab that joined a document already
+// at floor 1 must not ask to activate it again.
+function servedFloor() {
+  const tag = document.querySelector(`meta[name="${PAGE_FORMAT_META}"]`);
+  return tag ? pageFormatFloor(tag.outerHTML) : 0;
+}
+
+// The editor's own explicit save, fetched when a floor is really raised: a tab that
+// never uses a newer format never downloads the lane to raise one.
+const savePage = async (options) => (await import("../core/save.js")).savePageForce(() => {}, options);
+
+export function createFormatHost({
+  save = savePage,
+  supported = () => hostPageFormat().then((floor) => floor === PAGE_FORMAT),
+} = {}) {
+  return {
+    read() {
+      return { floor: Math.max(knownPageFormatFloor(), servedFloor()), revision: null };
+    },
+    capabilities() {
+      return [];
+    },
+    supported,
+    async activate({ floor = PAGE_FORMAT } = {}) {
+      let result;
+      try {
+        result = await save({ pageFormatFloor: floor });
+      } catch (error) {
+        return { accepted: false, code: error?.code ?? FAILED };
+      }
+      if (result?.ok) return { accepted: true, revision: null, receipt: result.receipt ?? result.etag ?? null };
+      if (result?.code === PAGE_FORMAT_UPGRADE) return { accepted: false, code: PAGE_FORMAT_UPGRADE };
+      return { accepted: false, code: result?.code ?? FAILED };
+    },
+  };
+}

package/src/page/format-level.js

@@ -0,0 +1,157 @@
+// The document format floor: how much of the page format a runtime must know
+// before it may write.
+//
+// The canonical marker is document metadata, outside the unchanged `{v,g,y}`
+// page value:
+//   <meta name="clay-page-format" content="1">
+// Absence means floor 0. A document's floor only ever rises, and every path that
+// writes a page declares the capability it writes with in
+// `X-Clay-Page-Format`. The value is protocol capability, not authorization: the
+// host still applies every permission check.
+//
+// `requiredPageFormat` answers the other direction: what floor does THIS content
+// need? Its registry is frozen at R (floor 1), so it does not shrink back as a
+// later release adds native schema support.
+
+export {
+  PAGE_FORMAT, PAGE_FORMAT_HEADER, PAGE_FORMAT_META, PAGE_FORMAT_EXTENSION, PAGE_FORMAT_UPGRADE,
+  formatCapability, pageFormatFloor, withPageFormatFloor, knownPageFormatFloor, notePageFormatFloor,
+} from "../core/page-format.js";
+import { PAGE_FORMAT, PAGE_FORMAT_UPGRADE, formatCapability } from "../core/page-format.js";
+
+const level = (value) => (Number.isSafeInteger(value) && value > 0 ? value : 0);
+
+// The floor-0 registry, frozen: every block type, mark code and block field R
+// understood when the floor was introduced. Built on first ask, so a client that
+// never checks content for its floor never carries the list.
+const REGISTRY = {
+  types: [
+    "paragraph", "heading", "list_item", "callout", "code_block", "toggle",
+    "divider", "image", "file", "table", "chart", "board", "tool", "preserved",
+  ],
+  marks: ["a", "b", "c", "i", "s"],
+  fields: [
+    "id", "t", "parent", "c", "m", "level", "kind", "indent", "checked", "owner",
+    "due", "lang", "open", "src", "alt", "caption", "width", "align", "name",
+    "size", "mime", "cols", "rows", "sort", "source", "series", "title",
+    "highlight", "columns", "cards", "artifact", "rev", "state", "html", "pos",
+  ],
+};
+let frozen = null;
+
+export function floorZero() {
+  if (!frozen) {
+    frozen = Object.freeze({
+      types: Object.freeze([...REGISTRY.types]),
+      marks: Object.freeze([...REGISTRY.marks]),
+      fields: Object.freeze([...REGISTRY.fields]),
+    });
+  }
+  return frozen;
+}
+
+const CODE = /^[A-Za-z]$/;
+
+// A mark key holds one code per mark, each followed by its attrs as a JSON array
+// when it carries them. Anything this registry has no code for is a newer
+// runtime's: an unfamiliar compact token, or `x` with a named extension.
+function newerMark(key) {
+  if (typeof key !== "string") throw new TypeError("page: a mark key is not a string");
+  if (!key || key[0] === "@") return false;
+  for (let i = 0; i < key.length;) {
+    const code = key[i];
+    if (!CODE.test(code)) throw new SyntaxError(`page: malformed mark key ${key}`);
+    if (!floorZero().marks.includes(code)) return true;
+    i += 1;
+    if (key[i] !== "[") continue;
+    let depth = 0, quoted = false;
+    const start = i;
+    for (; i < key.length; i++) {
+      const ch = key[i];
+      if (quoted) {
+        if (ch === "\\") i++;
+        else if (ch === '"') quoted = false;
+      } else if (ch === '"') quoted = true;
+      else if (ch === "[") depth++;
+      else if (ch === "]" && --depth === 0) { i++; break; }
+    }
+    if (i >= key.length && key[key.length - 1] !== "]") throw new SyntaxError(`page: unterminated attrs in mark key ${key.slice(start)}`);
+  }
+  return false;
+}
+
+const newerRuns = (m) => {
+  if (!Array.isArray(m)) return false;
+  for (const run of m) {
+    if (Array.isArray(run)) {
+      if (run.length === 2 && Number.isInteger(run[0]) && newerMark(run[1])) return true;
+    } else if (newerMark(run)) return true;
+  }
+  return false;
+};
+
+/**
+ * The floor a prospective semantic model needs: 1 when it holds a named
+ * extension mark, an unfamiliar compact token, an unfamiliar block or a block
+ * field the floor-0 registry does not know, 0 otherwise.
+ *
+ * @param {Array<Object>} model - items as projection.js projects them
+ * @returns {number}
+ */
+export function requiredPageFormat(model) {
+  if (!Array.isArray(model)) throw new TypeError("page: requiredPageFormat expects a model");
+  for (const item of model) {
+    if (!item || typeof item !== "object") continue;
+    if (!floorZero().types.includes(item.t)) return PAGE_FORMAT;
+    for (const key of Object.keys(item)) {
+      if (!floorZero().fields.includes(key)) return PAGE_FORMAT;
+    }
+    if (newerRuns(item.m)) return PAGE_FORMAT;
+    if (!Array.isArray(item.rows)) continue;
+    for (const row of item.rows) {
+      for (const cell of Object.values(row?.cells ?? {})) {
+        if (cell && typeof cell === "object" && newerRuns(cell.m)) return PAGE_FORMAT;
+      }
+    }
+  }
+  return 0;
+}
+
+/**
+ * One floor decision for every writer: the client's activation gate and the
+ * room's admission helper ask the same question and get the same answer.
+ *
+ * `floor` is the document's active floor, `required` what the prospective model
+ * needs, `capability` what this writer declares, and `admitted` the capabilities
+ * of the page editors already in the room. A write is refused before any
+ * mutation when this writer is below what the content needs, and a floor rise is
+ * refused while an admitted editor could not read the result.
+ *
+ * @param {Object} input
+ * @param {number} [input.floor]
+ * @param {number} [input.required]
+ * @param {number} [input.capability]
+ * @param {number[]} [input.admitted]
+ * @returns {{ok: boolean, activate: boolean, floor: number, required: number}}
+ */
+export function pageFormatDecision({ floor = 0, required = 0, capability = 0, admitted = [] } = {}) {
+  const active = level(floor);
+  const needs = Math.max(level(required), active);
+  const refuse = (minimum) => ({ ok: false, activate: false, floor: active, required: needs, minimum });
+  if (formatCapability(capability) < needs) return refuse(needs);
+  const activate = needs > active;
+  if (activate && admitted.some((value) => formatCapability(value) < needs)) return refuse(needs);
+  return { ok: true, activate, floor: needs, required: needs };
+}
+
+// What a refused writer is told: which floor the document needs and that its own
+// unsaved work is still its own. Nothing here is a reload.
+export function pageFormatRefusal(required, message = null) {
+  const minimum = level(required) || PAGE_FORMAT;
+  const error = new Error(message ?? `This document uses a newer page format (floor ${minimum}); update the editor to keep writing`);
+  error.name = "PageFormatUpgradeRequired";
+  error.code = PAGE_FORMAT_UPGRADE;
+  error.statusCode = 409;
+  error.minimum = minimum;
+  return error;
+}

package/src/page/format-native-commands.js

@@ -0,0 +1,142 @@
+// The commands behind the four formats this release adds — underline, text color,
+// highlight and the quote block — and the rows the More menu offers them by.
+//
+// Nothing here is on the ready path. Every caller loads this module the first
+// time one of the commands runs, so reading and drawing an existing document
+// never fetches a transaction, a palette or a refusal notice.
+//
+// Every command that writes one of them goes through runFormat, which is the
+// editor's own format gate: nothing is applied and no descriptor is written
+// unless the gate answered "applied".
+import { history } from "../vendor/prosemirror.vendor.js";
+import { schema } from "./schema.js";
+import { PALETTE, markable } from "./format-native.js";
+import { announce } from "./announce.js";
+import { openPageMenu } from "./chrome.js";
+
+// blocks.js's STEP, read here rather than imported from it: this module is part
+// of the projection's graph, and blocks.js reads the projection's constants as it
+// loads. A command of ours is one undo item by itself, like every other command.
+const STEP = "page-step";
+const asStep = (tr) => history.closeHistory(tr).setMeta(STEP, true);
+
+const holds = (mark, attrs) => !!mark && Object.keys(mark.type.attrs).every((name) => mark.attrs[name] === attrs[name]);
+
+function toggle(view, type, attrs) {
+  const st = view.state;
+  const { from, to, empty, $from } = st.selection;
+  const tr = st.tr;
+  if (empty) {
+    if (holds(type.isInSet(st.storedMarks || $from.marks()), attrs)) tr.removeStoredMark(type);
+    else tr.addStoredMark(type.create(attrs));
+  } else {
+    let all = true;
+    st.doc.nodesBetween(from, to, (node) => {
+      if (all && node.isText && !holds(type.isInSet(node.marks), attrs)) all = false;
+    });
+    if (all) tr.removeMark(from, to, type);
+    else tr.addMark(from, to, type.create(attrs));
+  }
+  view.dispatch(asStep(tr));
+  return true;
+}
+
+function remove(view, type) {
+  const st = view.state;
+  const tr = st.tr;
+  if (st.selection.empty) tr.removeStoredMark(type);
+  else tr.removeMark(st.selection.from, st.selection.to, type);
+  view.dispatch(asStep(tr));
+  return true;
+}
+
+// The gate, in one place: an editor mounted without one cannot write a floor-1
+// format, and a refusal leaves the content exactly as it was.
+export function runFormat(view, apply) {
+  const run = view.runFormatCommand;
+  if (typeof run !== "function") return Promise.resolve({ status: "unsupported-host", code: "page-format-unsupported", retry: false });
+  return run(apply);
+}
+
+// A mark command: toggle it on the selection, or with reset take it off. A
+// selection the mark cannot reach is refused before the gate is asked, so a code
+// block never raises the document's floor.
+export function formatMark(view, name, attrs = {}, { reset = false } = {}) {
+  const type = schema.marks[name];
+  if (!type) return Promise.resolve({ status: "refused", code: "unsupported-format" });
+  if (!view.editable) return Promise.resolve({ status: "refused", code: "not-editable" });
+  if (!markable(view.state, type)) return Promise.resolve({ status: "refused", code: "mark-not-allowed" });
+  return runFormat(view, () => (reset ? remove(view, type) : toggle(view, type, attrs)));
+}
+
+// The four formats pasted in from elsewhere are floor-1 content too: the slice is
+// inserted only once the gate answered applied. A refusal keeps the text and
+// writes no descriptor; a selection that moved while the answer came back takes
+// neither.
+export function pasteFormats(view, slice, from, to) {
+  const place = () => {
+    if (view.isDestroyed) return false;
+    const st = view.state;
+    if (st.selection.from !== from || st.selection.to !== to) return false;
+    view.dispatch(st.tr.replaceSelection(slice).scrollIntoView());
+    return true;
+  };
+  const plain = () => {
+    const text = slice.content.textBetween(0, slice.content.size, "\n", " ");
+    if (!view.isDestroyed && text) view.dispatch(view.state.tr.insertText(text, from, to));
+    return false;
+  };
+  runFormat(view, place).then((result) => {
+    if (result?.status === "applied") return;
+    if (!view.isDestroyed) announce(view, result?.message ?? "That format isn\u2019t available here.");
+    plain();
+  }, plain);
+}
+
+// The typed `" ` shortcut: the paragraph the reader is typing in became a quote,
+// and the space that typed it goes with it. A refusal puts the space back as
+// itself, so the typed character is never swallowed.
+export function quoteFromSpace(plugin, view, { at, from, to }, plain) {
+  const convert = () => {
+    if (view.isDestroyed) return false;
+    const now = view.state;
+    const current = now.doc.nodeAt(at);
+    if (!current || current.type !== schema.nodes.paragraph || current.textContent !== '"') return plain();
+    const tr = now.tr.delete(at + 1, at + 2).setNodeMarkup(at, schema.nodes.quote, current.attrs);
+    view.dispatch(asStep(tr.setMeta(plugin, { transform: tr, from, to, text: " " })));
+    return true;
+  };
+  view.runFormatCommand(convert).then((result) => { if (result?.status !== "applied") plain(); }, plain);
+}
+
+// The More menu's rows: the underline command, the palette of a color mark and
+// the notice a refusal raises. The palette is fixed: nine keys and the way back
+// to none, and no arbitrary color picker is offered.
+const CANNOT_MARK = "This text can\u2019t take that format.";
+const refusalText = (result) => (result.status === "upgrade-required" ? result.message : result.code === "mark-not-allowed" ? CANNOT_MARK : "That format isn\u2019t available here.");
+
+const notice = (view, result) => {
+  if (result?.status !== "applied" && !view.isDestroyed) announce(view, refusalText(result ?? {}));
+};
+
+export const runNative = (view, name, attrs = {}, options = undefined) => {
+  formatMark(view, name, attrs, options).then((result) => notice(view, result));
+};
+
+// A block command from a later format, like the turn into a quote: the write asks
+// the gate first, and a refusal is a notice rather than a change.
+export const gateTurn = (view, turn) => {
+  runFormat(view, turn).then((result) => notice(view, result));
+};
+
+// The palette of one color mark, as its own short menu: the nine fixed keys and
+// the way back to none.
+export function nativeMenu(view, name, anchor) {
+  if (name === "underline") return runNative(view, name);
+  const colorLabel = name === "text_color" ? "Text" : "Highlight";
+  const noneLabel = name === "text_color" ? "Automatic" : "No highlight";
+  return openPageMenu(view, anchor, [
+    ...PALETTE.map((color) => ({ key: `${name}_${color}`, label: `${colorLabel}: ${color[0].toUpperCase()}${color.slice(1)}`, icon: "\u25CF", run: (v) => runNative(v, name, { color }) })),
+    { key: `${name}_none`, label: noneLabel, icon: "\u00d7", run: (v) => runNative(v, name, {}, { reset: true }) },
+  ]);
+}

package/src/page/format-native.js

@@ -0,0 +1,42 @@
+// The four formats this release adds: underline, text color, highlight and the
+// quote block.
+//
+// Each is written as the named descriptor an older runtime already keeps as an
+// opaque mark, `x["text_color",{"color":"red"}]`, so R reads back exactly what F
+// wrote. The palette is fixed and its keys are the only colors a descriptor may
+// name: one naming any other color stays opaque rather than being read as a
+// style, and no command accepts arbitrary CSS.
+//
+// This half is the reading one: what the schema, inline.js and the projection need
+// to read a descriptor back and draw it. The commands that write one are in
+// format-native-commands.js, which a page loads the first time one runs.
+export const NATIVE_NAMES = new Set(["underline", "text_color", "highlight"]);
+
+export const PALETTE = ["gray", "brown", "orange", "yellow", "green", "blue", "purple", "pink", "red"];
+const COLORS = new Set(PALETTE);
+
+// The descriptor attrs of a native mark, or null when this name and these attrs
+// are not one of the formats this runtime writes.
+export function nativeAttrs(name, attrs) {
+  const plain = attrs !== null && typeof attrs === "object" && !Array.isArray(attrs);
+  if (name === "underline") return plain && Object.keys(attrs).length === 0 ? {} : null;
+  if (name === "text_color" || name === "highlight") {
+    const keys = plain ? Object.keys(attrs) : [];
+    return keys.length === 1 && keys[0] === "color" && COLORS.has(attrs.color) ? { color: attrs.color } : null;
+  }
+  return null;
+}
+
+// Whether this selection holds text the mark may be added to: a code block takes
+// no marks, and a block selection is not text at all. It stays here, beside the
+// reading half, because the keyboard decides whether Mod-u is its own before any
+// command is loaded.
+export function markable(st, type) {
+  const { $from, $to, empty } = st.selection;
+  if (empty) return $from.parent.type.allowsMarkType(type);
+  let ok = false;
+  st.doc.nodesBetween($from.pos, $to.pos, (node, _at, parent) => {
+    if (!ok && node.isText && parent?.type.allowsMarkType(type)) ok = true;
+  });
+  return ok;
+}

package/src/page/highlight-slot.js

@@ -0,0 +1,23 @@
+// The decoration slot code colours go into: code blocks highlight themselves
+// from a separate part, so the editor carries this empty plugin from boot and
+// the highlighter fills it once it loads.
+import { state, view as pmView } from "../vendor/prosemirror.vendor.js";
+
+const { Plugin, PluginKey } = state;
+const { DecorationSet } = pmView;
+
+export const highlightKey = new PluginKey("page-highlight");
+
+export function highlightSlot() {
+  return new Plugin({
+    key: highlightKey,
+    state: {
+      init: () => DecorationSet.empty,
+      apply(tr, set) {
+        const decos = tr.getMeta(highlightKey);
+        return decos ? DecorationSet.create(tr.doc, decos) : set.map(tr.mapping, tr.doc);
+      },
+    },
+    props: { decorations: (st) => highlightKey.getState(st) },
+  });
+}

package/src/page/highlight.js

@@ -5,9 +5,12 @@
 import { state, view as pmView } from "../vendor/prosemirror.vendor.js";
 import { schema } from "./schema.js";
 import { asStep } from "./blocksel.js";
+import { highlightKey, highlightSlot } from "./highlight-slot.js";
 
-const { Plugin, PluginKey } = state;
-const { Decoration, DecorationSet } = pmView;
+const { Plugin } = state;
+const { Decoration } = pmView;
+
+export { highlightKey };
 
 export const LANGS = [
   ["", "Plain text"],
@@ -106,9 +109,6 @@ const styleOf = (t) => {
   return s.join("; ");
 };
 
-export const highlightKey = new PluginKey("page-highlight");
-
-
 const CACHE_SIZE = 200;
 
 // Each pass rebuilds every code block's colours from a cache of token runs keyed
@@ -206,18 +206,32 @@ class Highlighter {
   }
 }
 
-export function highlightPlugin({ tokenize: run = tokenize, delay = 300 } = {}) {
+// The highlighter is no longer a plugin view, so nothing calls its update: it
+// watches the editor's own dispatches and stops watching when it is destroyed.
+export function startHighlighter(view, { tokenize: run = tokenize, delay = 300 } = {}) {
+  const highlighter = new Highlighter(view, run, delay);
+  const dispatch = view.dispatch.bind(view);
+  let doc = view.state.doc;
+  const wrapped = (tr) => {
+    dispatch(tr);
+    if (view.state.doc === doc) return;
+    const prev = { doc };
+    doc = view.state.doc;
+    highlighter.update(view, prev);
+  };
+  view.dispatch = wrapped;
+  const stop = highlighter.destroy.bind(highlighter);
+  highlighter.destroy = () => {
+    if (view.dispatch === wrapped) view.dispatch = dispatch;
+    stop();
+  };
+  return highlighter;
+}
+
+export function highlightPlugin(options) {
   return new Plugin({
-    key: highlightKey,
-    state: {
-      init: () => DecorationSet.empty,
-      apply(tr, set) {
-        const decos = tr.getMeta(highlightKey);
-        return decos ? DecorationSet.create(tr.doc, decos) : set.map(tr.mapping, tr.doc);
-      },
-    },
-    props: { decorations: (st) => highlightKey.getState(st) },
-    view: (view) => new Highlighter(view, run, delay),
+    ...highlightSlot().spec,
+    view: (view) => startHighlighter(view, options),
   });
 }