@panphora/clayjs 1.25.1 → 1.26.0

package/src/page/ybind/moves.js

@@ -1,12 +1,12 @@
 import * as Y from "../../vendor/yjs.vendor.js";
-import { LOCAL, REMOTE_META, mintOp } from "./layout.js";
+import { LOCAL, REMOTE_META, idKey, mintOp } from "./layout.js";
 import { state as pmState } from "../../vendor/prosemirror.vendor.js";
 import { walk } from "./walk.js";
 import { docOf } from "./doc.js";
 import { createProjectionMap } from "./projection-map.js";
 import { beforeFence } from "./writer.js";
-import { unitIds } from "./origins.js";
-import { attrKey, copyActiveKey, parseGoneIntents, physicalKeyOf, recoveredRoot, removeKey, restoreKey } from "./recovery.js";
+import { coversOriginal, unitIds } from "./origins.js";
+import { COPY_ACTIVE, REMOVE, TEXT_DELETE, attrKey, copyActiveKey, parseGoneIntents, parsePhysicalKey, physicalKeyOf, recoveredRoot, removeKey, restoreKey, visibleOriginIndex } from "./recovery.js";
 
 const refuse = (code) => ({ status: "refused", code });
 
@@ -298,3 +298,437 @@ export function moveBlocks({ pd, view, um, origins, render, walked = null }, arg
   restoreCaret();
   return { status: "moved", ids: movedIds };
 }
+
+const CARRY = "blockeditor-move-carry";
+
+const COPY_ACTIVE_KEYS = `["${COPY_ACTIVE}",`;
+const REMOVE_KEYS = `["${REMOVE}",`;
+const TEXT_DELETE_KEYS = `["${TEXT_DELETE}",`;
+
+const startOf = (pd, sourceKey) => {
+  const id = parsePhysicalKey(sourceKey);
+  if (!id) return null;
+  let it = null;
+  try { it = Y.getItem(pd.ydoc.store, id); } catch { return null; }
+  return it instanceof Y.Item && !it.deleted && it.parent === pd.flow ? it : null;
+};
+
+const targetOf = (pd, origins, walked, map, blockId) => {
+  let cursor = 0, seg = null;
+  for (const candidate of walked.visible) {
+    if (candidate.id === blockId) { seg = candidate; break; }
+    cursor += candidate.len;
+  }
+  if (!seg || seg.implicit || seg.atom || seg.opaque || !seg.brk) return null;
+  const places = new Map();
+  let head = null;
+  for (const [from, to] of map.physicalRanges(cursor, cursor + seg.len)) {
+    const ids = unitIds(pd.flow, from, to);
+    for (let i = 0; i < ids.length; i++) {
+      if (head === null) head = from;
+      else places.set(idKey(origins.resolve(ids[i])), from + i);
+    }
+  }
+  return head === null ? null : { head, places };
+};
+
+const formatsBefore = (pd, stop) => {
+  const out = new Map();
+  for (let it = pd.flow._start; it && it !== stop; it = it.right) {
+    if (it.deleted || !(it.content instanceof Y.ContentFormat)) continue;
+    if (it.content.value === null) out.delete(it.content.key);
+    else out.set(it.content.key, it.content.value);
+  }
+  return out;
+};
+
+const rangesOf = (ranges) => {
+  const set = Y.createDeleteSet();
+  for (const { client, clock, len } of ranges) (set.clients.get(client) ?? set.clients.set(client, []).get(client)).push({ clock, len });
+  return set;
+};
+
+const markerOf = (it) => it.content instanceof Y.ContentEmbed && it.content.embed?.b !== undefined;
+
+// The block a unit was typed into: the first block marker on the chain of left neighbours
+// each unit was inserted after. The chain never changes, so every tab finds the same block,
+// and a word has one home copy whose owner alone may carry it.
+const homeOf = (pd, homes, it) => {
+  const path = [];
+  let at = it, home = null;
+  for (;;) {
+    const known = homes.get(at);
+    if (known !== undefined) { home = known; break; }
+    path.push(at);
+    let next = null;
+    if (at.origin) try { next = Y.getItem(pd.ydoc.store, at.origin); } catch { next = null; }
+    if (!(next instanceof Y.Item)) break;
+    if (markerOf(next)) { home = next; break; }
+    at = next;
+  }
+  for (const item of path) homes.set(item, home);
+  return home;
+};
+
+// Only a copy's own words move, only deletions a person's record backs are mirrored, and the
+// words join the history step that shows the region again, so that step puts each word back
+// exactly where it was typed. A region a Redo hid again is only mirrored: what reached it
+// since the Undo is set aside, as before the carry existed.
+function carryAcross({ pd, origins, walked, placed }, owned, homes, flip = null, records = false) {
+  const entries = walked.hidden.filter((entry) => owned.has(entry.key));
+  if (!entries.length) return false;
+  const self = pd.ydoc.clientID;
+  const deletes = flip !== null || records ? parseGoneIntents(pd.gone).textDeletes.filter((record) => record.actor !== self) : [];
+  const removed = new Map();
+  const taken = new Set();
+  const inserts = [];
+  const folds = new Map();
+  let visible = null, map = null;
+  for (const entry of entries) {
+    const owner = owned.get(entry.key);
+    const { left, past } = owner;
+    const start = startOf(pd, entry.sourceKey);
+    if (!start) continue;
+    const live = new Map(entry.items.map((item) => [item.id, item]));
+    const region = [];
+    for (let it = start.right; it; it = it.right) {
+      if (it.countable && !it.deleted && !live.has(idKey(it.id))) break;
+      region.push(it);
+    }
+    const words = new Set(owner.copy ? region.filter((it) => !it.deleted && it.countable && !markerOf(it) && !left.has(`${idKey(it.id)}+${it.length}`) && homeOf(pd, homes, it) === start) : []);
+    const covering = deletes.filter((record) => region.some((it) => it.deleted && it.countable && it.id.client === record.client && record.clock < it.id.clock + it.length && it.id.clock < record.clock + record.length));
+    if (!words.size && !covering.length) continue;
+    const seen = owner.seen ?? new Map(entry.sv);
+    const fresh = (client, clock) => clock >= (seen.get(client) ?? 0);
+    const formats = words.size ? formatsBefore(pd, start) : null;
+    let attrs = null;
+    const units = [];
+    const shown = new Map();
+    for (const it of region) {
+      if (!it.countable) {
+        if (formats && it.content instanceof Y.ContentFormat && (!it.deleted || Y.isDeleted(past, it.id))) {
+          if (it.content.value === null) formats.delete(it.content.key);
+          else formats.set(it.content.key, it.content.value);
+          attrs = null;
+        }
+        continue;
+      }
+      const item = it.deleted ? null : live.get(idKey(it.id));
+      const word = words.has(it);
+      for (let offset = 0; offset < it.length; offset++) {
+        const id = { client: it.id.client, clock: it.id.clock + offset };
+        const source = origins.resolve(id);
+        const key = idKey(source);
+        if (!(it.deleted && covering.length && coversOriginal(covering, self, id))) shown.set(key, true);
+        else if (!shown.has(key) && (!owner.alive || fresh(id.client, id.clock) || owner.alive.has(idKey(id)))) shown.set(key, false);
+        units.push({ it, item, offset, id, source, key, attrs: word ? (attrs ??= Object.fromEntries(formats)) : null });
+      }
+    }
+    map ??= createProjectionMap(walked, pd.flow.length);
+    const target = targetOf(pd, origins, walked, map, entry.blockId);
+    if (!target) {
+      for (const it of words) left.add(`${idKey(it.id)}+${it.length}`);
+      continue;
+    }
+    if (covering.length) for (const [key, place] of target.places) if (shown.get(key) === false && !removed.has(place)) removed.set(place, null);
+    const groups = new Map();
+    let at = target.head + 1;
+    for (const unit of units) {
+      const { it, item, offset, id, source } = unit;
+      if (unit.attrs) {
+        if (!taken.has(idKey(id)) && !(visible ??= visibleOriginIndex(pd.flow, walked, origins))(source.client, source.clock)) {
+          taken.add(idKey(id));
+          removed.set(item.at + offset, owner);
+          if (owner.step && !folds.has(owner)) folds.set(owner, { deleted: [], inserted: [] });
+          const group = groups.get(at) ?? groups.set(at, []).get(at);
+          group.push(item.kind === "text" ? { ch: it.content.str[offset], attrs: unit.attrs, source } : { embed: it.content.embed, attrs: unit.attrs, source });
+          continue;
+        }
+        left.add(`${idKey(it.id)}+${it.length}`);
+      }
+      const place = target.places.get(unit.key);
+      if (place !== undefined) at = place + 1;
+    }
+    for (const [place, list] of groups) inserts.push({ at: place, units: list, owner });
+  }
+  if (!removed.size && !inserts.length) return false;
+  const ops = [...[...removed].map(([at, owner]) => ({ at, owner })), ...inserts].sort((a, b) => b.at - a.at || (a.units ? 1 : 0) - (b.units ? 1 : 0));
+  pd.ydoc.transact((tr) => {
+    let run = null;
+    // Deleting a word also deletes the format items that only it needed. The step that
+    // brings the word back has to bring those back with it, so it keeps all of them.
+    const cut = () => {
+      if (!run) return;
+      const fold = folds.get(run.owner);
+      const sizes = fold ? new Map([...tr.deleteSet.clients].map(([client, ranges]) => [client, ranges.length])) : null;
+      pd.flow.delete(run.from, run.to - run.from);
+      if (fold) for (const [client, ranges] of tr.deleteSet.clients) for (const { clock, len } of ranges.slice(sizes.get(client) ?? 0)) {
+        const struct = Y.getItem(pd.ydoc.store, { client, clock });
+        if (struct instanceof Y.Item) struct.keep = true;
+        fold.deleted.push({ client, clock, len });
+      }
+      run = null;
+    };
+    for (const op of ops) {
+      if (!op.units) {
+        if (run && op.at === run.from - 1 && op.owner === run.owner) run.from = op.at;
+        else { cut(); run = { from: op.at, to: op.at + 1, owner: op.owner }; }
+        continue;
+      }
+      cut();
+      const before = Y.getState(pd.ydoc.store, self);
+      let cursor = op.at, text = "", attrs = null;
+      const put = () => {
+        if (!text) return;
+        const chars = text;
+        beforeFence(pd, cursor, walked.fences, () => pd.flow.insert(cursor, chars, { ...attrs }));
+        cursor += chars.length;
+        text = "";
+      };
+      for (const unit of op.units) {
+        if (unit.ch === undefined) {
+          put();
+          beforeFence(pd, cursor, walked.fences, () => pd.flow.insertEmbed(cursor, { ...unit.embed }, { ...unit.attrs }));
+          cursor += 1;
+          continue;
+        }
+        if (text && attrsKey(unit.attrs) !== attrsKey(attrs)) put();
+        attrs = unit.attrs;
+        text += unit.ch;
+      }
+      put();
+      folds.get(op.owner)?.inserted.push({ client: self, clock: before, len: Y.getState(pd.ydoc.store, self) - before });
+      const dest = unitIds(pd.flow, op.at, cursor);
+      if (dest.length !== op.units.length) throw new Error(`Carried ${dest.length} units instead of ${op.units.length}`);
+      origins.recordSpans(dest.map((id, i) => ({ dest: id, source: op.units[i].source })));
+      placed.push({ ids: dest, step: op.owner.step });
+    }
+    cut();
+  }, CARRY);
+  for (const [{ step }, fold] of folds) {
+    step.deletions = Y.mergeDeleteSets([step.deletions, rangesOf(fold.deleted)]);
+    step.insertions = Y.mergeDeleteSets([step.insertions, rangesOf(fold.inserted)]);
+  }
+  return true;
+}
+
+const eachUnit = (pd, set, f) => {
+  for (const [client, ranges] of set.clients) for (const { clock, len } of ranges) {
+    for (let at = clock; at < clock + len;) {
+      let it = null;
+      try { it = Y.getItem(pd.ydoc.store, { client, clock: at }); } catch { break; }
+      const end = Math.min(clock + len, it.id.clock + it.length);
+      if (it instanceof Y.Item && it.parent === pd.flow && it.countable) for (let unit = at; unit < end; unit++) f(it, { client, clock: unit });
+      at = end;
+    }
+  }
+};
+
+const recorded = (records, id) => records.some((record) => record.client === id.client && id.clock >= record.clock && id.clock < record.clock + record.length);
+
+const gone = (pd, id) => {
+  try { return Y.getItem(pd.ydoc.store, id).deleted; } catch { return true; }
+};
+
+// Before a step is replayed. A word it inserted that a carry or another replay moved (that
+// unit and its source unit are both gone, and no person's record deleted them) is followed to
+// every live unit holding it, so the typist's Undo takes the word out where it now is. A unit
+// the step would re-create is left out when nothing holds its word any more, so a Redo never
+// brings back a word its typist undid or a person deleted.
+const followStep = (pd, origins, step) => {
+  const dead = [];
+  eachUnit(pd, step.insertions, (it, id) => { if (it.deleted) dead.push(id); });
+  if (!dead.length) return;
+  const records = parseGoneIntents(pd.gone).textDeletes;
+  const words = new Map();
+  for (const id of dead) {
+    const source = origins.resolve(id);
+    const word = words.get(idKey(source)) ?? words.set(idKey(source), { source, follow: false, redo: [] }).get(idKey(source));
+    if (!word.follow && !recorded(records, id) && gone(pd, source)) word.follow = true;
+  }
+  eachUnit(pd, step.deletions, (it, id) => words.get(idKey(origins.resolve(id)))?.redo.push(id));
+  const wanted = new Map();
+  for (const word of words.values()) {
+    if (!word.follow && !word.redo.length) continue;
+    word.lives = [];
+    (wanted.get(word.source.client) ?? wanted.set(word.source.client, []).get(word.source.client)).push(word);
+  }
+  if (!wanted.size) return;
+  for (let it = pd.flow._start; it; it = it.right) {
+    if (it.deleted || !it.countable) continue;
+    let at = it.id.clock;
+    for (const piece of origins.resolveRange(it.id.client, it.id.clock, it.length)) {
+      for (const word of wanted.get(piece.client) ?? []) {
+        const offset = word.source.clock - piece.clock;
+        if (offset >= 0 && offset < piece.length) word.lives.push({ client: it.id.client, clock: at + offset, len: 1 });
+      }
+      at += piece.length;
+    }
+  }
+  const adds = [];
+  for (const list of wanted.values()) for (const word of list) {
+    if (word.follow) adds.push(...word.lives);
+    if (!word.lives.length) for (const id of word.redo) adds.push({ client: id.client, clock: id.clock, len: 1 });
+  }
+  if (adds.length) step.insertions = Y.mergeDeleteSets([step.insertions, rangesOf(adds)]);
+};
+
+const holds = (it, id) => id !== null && it.id.client === id.client && id.clock >= it.id.clock && id.clock < it.id.clock + it.length;
+
+// A block marker another tab inserted between a carried word and the unit the carry put it
+// after, without having seen the word (its right neighbour lies past the word). Yjs orders such
+// ties by client number, so the word can end up inside that tab's new block. Returns the marker
+// nearest the unit the carry put the word after.
+const cutIn = (pd, ids) => {
+  let item;
+  try { item = Y.getItem(pd.ydoc.store, ids[0]); } catch { return null; }
+  if (item.id.clock !== ids[0].clock || !item.origin) return null;
+  const between = [item];
+  let edge = null;
+  for (let it = item.left; it && !holds(it, item.origin); it = it.left) {
+    if (markerOf(it) && it.id.client !== pd.ydoc.clientID && !between.some((other) => holds(other, it.rightOrigin))) edge = it;
+    between.push(it);
+  }
+  return edge;
+};
+
+// The carrying tab alone puts such a word back in front of that marker, into the block it was
+// carried to. If that block is hidden by then, the word is set aside there as any hidden word is.
+const reseat = (pd, origins, walked, placed) => {
+  const kept = [], moved = [];
+  for (const group of placed) {
+    const live = group.ids.filter((id) => !gone(pd, id));
+    if (!live.length) continue;
+    const edge = cutIn(pd, group.ids);
+    if (edge) moved.push({ group, edge, live: new Set(live.map(idKey)) });
+    else kept.push(group);
+  }
+  if (!moved.length) return placed;
+  const self = pd.ydoc.clientID;
+  pd.ydoc.transact(() => {
+    for (const { group, edge, live } of moved) {
+      const formats = new Map();
+      const units = [];
+      let at = 0;
+      for (let it = pd.flow._start; it; it = it.right) {
+        if (it.content instanceof Y.ContentFormat) {
+          if (!it.deleted) { if (it.content.value === null) formats.delete(it.content.key); else formats.set(it.content.key, it.content.value); }
+          continue;
+        }
+        if (it.deleted || !it.countable) continue;
+        for (let offset = 0; offset < it.length; offset++) {
+          const id = { client: it.id.client, clock: it.id.clock + offset };
+          if (live.has(idKey(id))) units.push({ at: at + offset, ch: it.content instanceof Y.ContentString ? it.content.str[offset] : undefined, embed: it.content.embed, attrs: Object.fromEntries(formats), source: origins.resolve(id) });
+        }
+        at += it.length;
+      }
+      for (let i = units.length - 1; i >= 0; i--) pd.flow.delete(units[i].at, 1);
+      let cursor = 0;
+      for (let it = pd.flow._start; it && it !== edge; it = it.right) if (!it.deleted && it.countable) cursor += it.length;
+      const start = cursor;
+      const before = Y.getState(pd.ydoc.store, self);
+      const fences = [...walked.fences, edge.id];
+      for (const unit of units) {
+        if (unit.ch === undefined) beforeFence(pd, cursor, fences, () => pd.flow.insertEmbed(cursor, { ...unit.embed }, { ...unit.attrs }));
+        else beforeFence(pd, cursor, fences, () => pd.flow.insert(cursor, unit.ch, { ...unit.attrs }));
+        cursor += 1;
+      }
+      const dest = unitIds(pd.flow, start, cursor);
+      if (dest.length !== units.length) throw new Error(`Moved ${dest.length} carried units instead of ${units.length}`);
+      origins.recordSpans(dest.map((id, i) => ({ dest: id, source: units[i].source })));
+      if (group.step) group.step.insertions = Y.mergeDeleteSets([group.step.insertions, rangesOf([{ client: self, clock: before, len: Y.getState(pd.ydoc.store, self) - before }])]);
+      kept.push({ ids: dest, step: group.step });
+    }
+  }, CARRY);
+  return kept;
+};
+
+// Whether Yjs will change anything when it pops this step. It pops every step that would not,
+// in the same press, so each of those needs its moved words followed too.
+const acts = (pd, step) => {
+  const store = pd.ydoc.store;
+  for (const [client, ranges] of step.insertions.clients) for (const { clock, len } of ranges) {
+    for (let at = clock; at < clock + len;) {
+      let it;
+      try { it = Y.getItem(store, { client, clock: at }); } catch { break; }
+      let live = it;
+      while (live instanceof Y.Item && live.redone) { try { live = Y.getItem(store, live.redone); } catch { break; } }
+      if (live instanceof Y.Item && !live.deleted) return true;
+      at = it.id.clock + it.length;
+    }
+  }
+  for (const [client, ranges] of step.deletions.clients) for (const { clock } of ranges) {
+    if (!Y.isDeleted(step.insertions, { client, clock })) return true;
+  }
+  return false;
+};
+
+const liveIn = (pd, sourceKey) => {
+  const live = new Set();
+  for (let it = startOf(pd, sourceKey)?.right ?? null; it; it = it.right) {
+    if (!it.countable || it.deleted) continue;
+    if (markerOf(it)) break;
+    for (let offset = 0; offset < it.length; offset++) live.add(idKey({ client: it.id.client, clock: it.id.clock + offset }));
+  }
+  return live;
+};
+
+// Only the tab whose own Undo retired a copy carries that copy's words: a word's home copy is
+// fixed (homeOf), so no two tabs carry the same word. A Redo carries nothing forward and
+// mirrors only the recorded loss of a unit alive at the Undo (`alive`) or newer (`seen`).
+export function createMoveCarry({ pd, origins, um, walked }) {
+  const owned = new Map();
+  const shown = new Map();
+  const homes = new WeakMap();
+  let flip = null;
+  let placed = [];
+  const run = (flipped = null, records = false) => owned.size > 0 && carryAcross({ pd, origins, walked: walked(), placed }, owned, homes, flipped, records);
+  return {
+    note(t) {
+      const keys = [...(t.changed.get(pd.gone) ?? [])].filter((key) => typeof key === "string");
+      if (!keys.some((key) => key.startsWith(COPY_ACTIVE_KEYS))) return;
+      const hidden = new Set();
+      const past = rangesOf([...t.deleteSet.clients].flatMap(([client, ranges]) => ranges.map(({ clock, len }) => ({ client, clock, len }))));
+      for (const key of keys) {
+        const copy = key.startsWith(COPY_ACTIVE_KEYS);
+        if (!copy && !key.startsWith(REMOVE_KEYS)) continue;
+        if (pd.gone.has(key) === copy) {
+          owned.delete(key);
+          if (!copy) shown.set(key, { seen: t.afterState, alive: liveIn(pd, JSON.parse(key)[1]) });
+          continue;
+        }
+        hidden.add(key);
+        owned.set(key, { copy, left: new Set(), past, seen: null, alive: null, step: null, ...(copy ? null : shown.get(key)) });
+      }
+      if (hidden.size) flip = hidden;
+    },
+    replay(direction) {
+      const pending = direction === "undo" ? um.undoStack : um.redoStack;
+      for (let i = pending.length - 1; i >= 0; i--) {
+        followStep(pd, origins, pending[i]);
+        if (acts(pd, pending[i])) break;
+      }
+      const inverse = direction === "undo" ? um.redoStack : um.undoStack;
+      const size = inverse.length;
+      flip = null;
+      if (um[direction]() === null) return false;
+      const flipped = flip;
+      flip = null;
+      if (flipped && inverse.length > size) for (const key of flipped) owned.get(key).step = inverse[inverse.length - 1];
+      run(flipped);
+      return true;
+    },
+    received(transactions) {
+      if (!owned.size && !placed.length) return;
+      let late = false, records = false;
+      for (const t of transactions) {
+        if (t.local) continue;
+        late = true;
+        for (const key of t.changed.get(pd.gone) ?? []) if (typeof key === "string" && key.startsWith(TEXT_DELETE_KEYS)) records = true;
+      }
+      if (!late) return;
+      run(null, records);
+      if (placed.length) placed = reseat(pd, origins, walked(), placed);
+    },
+  };
+}

package/src/page/ybind/origins.js

@@ -288,7 +288,7 @@ export function unitIds(flow, from, to) {
   return out;
 }
 
-const coversOriginal = (records, self, id) => records.some((record) => {
+export const coversOriginal = (records, self, id) => records.some((record) => {
   if (record.actor === self || record.client !== id.client) return false;
   if (id.clock < record.clock || id.clock >= record.clock + record.length) return false;
   return record.sv.some(([client, clock]) => client === id.client && clock > id.clock);

package/src/page/ybind/recovery.js

@@ -345,7 +345,7 @@ const holdsClock = (spans, clock) => {
   return false;
 };
 
-const visibleOriginIndex = (flow, walked, index) => {
+export const visibleOriginIndex = (flow, walked, index) => {
   const ranges = createProjectionMap(walked, flow.length).physicalRanges(0, walked.tokens);
   const clocks = new Map();
   const collect = (item, from, to) => {

package/src/plugins/page.js

@@ -296,10 +296,23 @@ function listen(inst, type, handler) {
   inst.listeners.push([type, handler]);
 }
 
+// On a page that loads `undo` there is one history and it is the page's: every route the
+// editor offers walks it, and the editor's own stack only says where its steps sit on it.
+const paged = () => window.clay?.undo?.pageHistory === true;
+
 // The page's own history, the one the editor's Cmd+Z already uses: nothing is undoable
 // while a proposal is only a preview, because Discard is the whole of that change and
 // Keep is the one step worth undoing.
 function pageHistory(inst) {
+  if (paged()) {
+    const history = window.clay.undo;
+    return {
+      undo: () => history.undo(),
+      redo: () => history.redo(),
+      get canUndo() { return !!history.canUndo; },
+      get canRedo() { return !!history.canRedo; },
+    };
+  }
   const binding = inst?.binding;
   const um = binding?.bridge?.um;
   if (!binding || !um) return null;
@@ -327,6 +340,9 @@ function pageHistory(inst) {
 // One event for whatever presents the history, the same one plugins/undo.js emits: after
 // every entry the page's stack takes or replays, and whenever a preview comes up or goes.
 function notifyHistory(inst) {
+  // The undo plugin announces the one page history itself; a second event from here would
+  // say the editor's own stack decides what is undoable.
+  if (paged()) return;
   const history = pageHistory(inst);
   document.dispatchEvent(new CustomEvent("clay:undo-change", {
     detail: { canUndo: !!history?.canUndo, canRedo: !!history?.canRedo },
@@ -985,7 +1001,9 @@ export function createSteps(inst, options) {
       install: async (id, mod) => {
         if (!editorView) await editorReady;
         if (!isCurrent(inst) || !editorView) return null;
-        const context = { view: editorView, upload: isDraftMode ? draftUpload : options.upload, board: binding.board, undo: binding.undo, redo: binding.redo, revise: aiRequested() ? (toolId) => { openAi({ target: { toolId } }); } : null };
+        const undo = () => (paged() ? window.clay.undo.undo() : binding.undo());
+        const redo = () => (paged() ? window.clay.undo.redo() : binding.redo());
+        const context = { view: editorView, upload: isDraftMode ? draftUpload : options.upload, board: binding.board, undo, redo, revise: aiRequested() ? (toolId) => { openAi({ target: { toolId } }); } : null };
         if (id === "tool") {
           context.toolHost = await openTools();
           if (!isCurrent(inst)) return null;
@@ -1200,8 +1218,8 @@ function mountAndAttach(inst, source, loaded) {
         doc: binding.doc(),
         dispatch: binding.dispatch,
         history: false,
-        undo: binding.undo,
-        redo: binding.redo,
+        undo: () => (paged() ? window.clay.undo.undo() : binding.undo()),
+        redo: () => (paged() ? window.clay.undo.redo() : binding.redo()),
         board: binding.board,
         editable: false,
         features,
@@ -1263,10 +1281,23 @@ function mountAndAttach(inst, source, loaded) {
     }
     loaded.refreshView?.(view);
     binding.attach(view);
+    // Every mounted editor hands its own steps to the page's history through this adapter,
+    // made here whether or not a session is live yet: the adapter reads the history per
+    // step and follows the session as it starts, stops and starts again.
+    const um = binding.bridge?.um;
+    if (um) {
+      const bridge = pageCode.createHistoryBridge({
+        um,
+        undo: () => binding.undo(),
+        redo: () => binding.redo(),
+        article,
+        focus: () => inst.view?.focus?.(),
+      });
+      addDisposer(inst, bridge.dispose);
+    }
     // The page's history tells whoever presents it once it exists (a menu opened before the
     // editor came up gets its Undo row then), and once per entry it takes or replays. A
     // peer's typing takes none of them: their work is not this tab's to undo.
-    const um = binding.bridge?.um;
     if (um) {
       const notify = () => notifyHistory(inst);
       um.on("stack-item-added", notify);
@@ -1287,9 +1318,22 @@ function mountAndAttach(inst, source, loaded) {
         const previewIs = previewShown(next.state);
         if (previewIs === previewWas) return;
         previewWas = previewIs;
+        // A proposal on screen owns the moment: the page's history is held, so Cmd+Z can
+        // undo nothing behind it, and released when the proposal goes.
+        if (paged()) {
+          if (previewIs) inst.releaseHold = window.clay.undo.hold();
+          else {
+            inst.releaseHold?.();
+            inst.releaseHold = null;
+          }
+        }
         notifyHistory(inst);
       },
     }));
+    addDisposer(inst, () => {
+      inst.releaseHold?.();
+      inst.releaseHold = null;
+    });
     installAwareness(inst, view);
     editorReadyResolve();
     // The parts the saved article demands install onto the mounted view now, whether