@panphora/clayjs 1.13.1 → 1.15.0

package/src/page/ybind/moves.js

@@ -0,0 +1,288 @@
+import * as Y from "../../vendor/yjs.vendor.js";
+import { LOCAL, REMOTE_META, 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 { unitIds } from "./origins.js";
+import { attrKey, copyActiveKey, parseGoneIntents, physicalKeyOf, recoveredRoot, removeKey, restoreKey } from "./recovery.js";
+
+const refuse = (code) => ({ status: "refused", code });
+
+const attrsKey = (attrs) => {
+  if (!attrs) return "";
+  const out = [];
+  for (const key of Object.keys(attrs).sort()) out.push(`${key}=${JSON.stringify(attrs[key])}`);
+  return out.join("\n");
+};
+
+const visibleBlocks = (pd, current, view) => {
+  const doc = view ? view.state.doc : null;
+  const settled = doc && doc.childCount === current.visible.length && current.visible.every((seg, index) => doc.child(index).attrs.id === seg.id);
+  const source = settled ? doc : docOf(pd, current);
+  const out = [];
+  source.forEach((node) => {
+    if (node.attrs.id === null || node.attrs.id === undefined) return;
+    out.push({ id: node.attrs.id, parent: node.attrs.parent ?? null, t: node.type.name });
+  });
+  return out;
+};
+
+const ancestors = (byId, id) => {
+  const out = [];
+  let cur = byId.get(id)?.parent ?? null;
+  let guard = 0;
+  while (cur !== null && cur !== undefined && guard++ <= byId.size) {
+    out.push(cur);
+    cur = byId.get(cur)?.parent ?? null;
+  }
+  return out;
+};
+
+const isAncestor = (byId, ancestor, id) => ancestors(byId, id).includes(ancestor);
+const inSubtree = (byId, id, root) => id === root || isAncestor(byId, root, id);
+
+const setAttr = (pd, seg, id, field, value) => {
+  if (seg?.recovered) {
+    const key = attrKey(seg.sourceKey, field);
+    if ((pd.gone.has(key) ? pd.gone.get(key) : seg.fields?.[field] ?? null) !== value) pd.gone.set(key, value);
+    return;
+  }
+  let map = pd.attrs.get(id);
+  if (!map) { map = new Y.Map(); pd.attrs.set(id, map); }
+  if (map.get(field) !== value) map.set(field, value);
+};
+
+const setParent = (pd, seg, id, parent) => setAttr(pd, seg, id, "parent", parent);
+
+const MAX_INDENT = 8;
+const ATTR_RULES = {
+  indent: (value, block) => block.t === "list_item" && Number.isInteger(value) && value >= 0 && value <= MAX_INDENT,
+  open: (value, block) => block.t === "toggle" && typeof value === "boolean",
+};
+
+const attrChanges = (args, byId) => {
+  if (args?.attrs === undefined) return [];
+  if (!args.attrs || typeof args.attrs !== "object" || Array.isArray(args.attrs)) return null;
+  const out = [];
+  for (const [id, fields] of Object.entries(args.attrs)) {
+    const block = byId.get(id);
+    if (!block || !fields || typeof fields !== "object" || Array.isArray(fields)) return null;
+    for (const [field, value] of Object.entries(fields)) {
+      if (!ATTR_RULES[field] || !ATTR_RULES[field](value, block)) return null;
+      out.push({ id, field, value });
+    }
+  }
+  return out;
+};
+
+const flowUnits = (pd, origins) => {
+  const ids = unitIds(pd.flow, 0, pd.flow.length);
+  const out = [];
+  let at = 0;
+  for (const part of pd.flow.toDelta()) {
+    const attrs = part.attributes;
+    if (typeof part.insert === "string") {
+      for (let i = 0; i < part.insert.length; i++) out.push({ ch: part.insert[i], attrs, source: origins.resolve(ids[at++]) });
+    } else out.push({ embed: part.insert, attrs, source: origins.resolve(ids[at++]) });
+  }
+  if (at !== ids.length) throw new Error(`The flow delta has ${at} units but the document has ${ids.length}`);
+  return out;
+};
+
+const liveRemovals = (pd, current, selected) => {
+  const observed = new Map();
+  for (const seg of current.visible) if (selected.has(seg.id) && seg.brk) observed.set(physicalKeyOf(seg.brk), seg.id);
+  for (const id of selected) for (const key of current.copies.get(id) ?? []) observed.set(key, id);
+  const out = [];
+  for (let it = pd.flow._start; it; it = it.right) {
+    if (it.deleted || !(it.content instanceof Y.ContentEmbed)) continue;
+    const id = it.content.embed?.b;
+    if (id === undefined || observed.get(physicalKeyOf(it.id)) !== id) continue;
+    let end = null;
+    for (let next = it.right; next; next = next.right) {
+      if (next.deleted || !(next.content instanceof Y.ContentEmbed)) continue;
+      const other = next.content.embed?.b;
+      if (other === undefined || other === id) continue;
+      end = physicalKeyOf(next.id);
+      break;
+    }
+    out.push({ key: physicalKeyOf(it.id), blockId: id, end });
+  }
+  return out;
+};
+
+export function moveBlocks({ pd, view, um, origins, render }, args = {}) {
+  const ids = Array.isArray(args?.ids) ? [...new Set(args.ids)] : [];
+  const afterId = args?.afterId === undefined ? null : args.afterId;
+  const hasParent = args?.parent !== undefined;
+
+  const current = walk(pd, origins);
+  const list = visibleBlocks(pd, current, view);
+  const byId = new Map(list.map((block) => [block.id, block]));
+  const order = list.map((block) => block.id);
+
+  if (!ids.length) return refuse("missing-source");
+  for (const id of ids) if (!byId.has(id)) return refuse("missing-source");
+  const changes = attrChanges(args, byId);
+  if (!changes) return refuse("invalid-attrs");
+
+  const roots = new Set(ids.filter((id) => !ids.some((other) => other !== id && isAncestor(byId, other, id))));
+  const selected = list.filter((block) => ids.some((root) => inSubtree(byId, block.id, root)));
+  const selectedSet = new Set(selected.map((block) => block.id));
+
+  const segments = new Map(current.visible.map((seg) => [seg.id, seg]));
+  for (const block of selected) {
+    const seg = segments.get(block.id);
+    if (!seg || seg.implicit || !seg.brk) return refuse("missing-source");
+  }
+
+  let parent;
+  if (hasParent) parent = args.parent ?? null;
+  else {
+    const parents = new Set(selected.filter((block) => roots.has(block.id)).map((block) => block.parent));
+    if (parents.size !== 1) return refuse("invalid-parent");
+    parent = [...parents][0];
+  }
+  if (hasParent && parent !== null) {
+    const node = byId.get(parent);
+    if (!node || node.t !== "toggle") return refuse("invalid-parent");
+    if (selectedSet.has(parent)) return refuse("cycle");
+  }
+  if (afterId !== null) {
+    if (typeof afterId !== "string" || !byId.has(afterId)) return refuse("missing-destination");
+    if (selectedSet.has(afterId)) return refuse("cycle");
+    if (byId.get(afterId).parent !== parent) return refuse("missing-destination");
+  }
+
+  const remaining = list.filter((block) => !selectedSet.has(block.id));
+  let insertAt = 0;
+  if (afterId === null) {
+    if (parent !== null) {
+      const first = remaining.findIndex((block) => block.parent === parent);
+      const own = remaining.findIndex((block) => block.id === parent);
+      insertAt = first >= 0 ? first : own < 0 ? 0 : own + 1;
+    }
+  } else {
+    insertAt = remaining.findIndex((block) => block.id === afterId) + 1;
+    while (insertAt < remaining.length && inSubtree(byId, remaining[insertAt].id, afterId)) insertAt++;
+  }
+
+  const desired = [...remaining.slice(0, insertAt), ...selected, ...remaining.slice(insertAt)];
+  const sameOrder = desired.length === order.length && desired.every((block, index) => block.id === order[index]);
+  const movedRoots = selected.filter((block) => roots.has(block.id) && block.parent !== parent);
+  const movedIds = selected.map((block) => block.id);
+  if (sameOrder && !movedRoots.length && !changes.length) return { status: "unchanged" };
+
+  if (sameOrder) {
+    um?.stopCapturing();
+    pd.ydoc.transact(() => {
+      for (const block of movedRoots) setParent(pd, segments.get(block.id), block.id, parent);
+      for (const change of changes) setAttr(pd, segments.get(change.id), change.id, change.field, change.value);
+    }, LOCAL);
+    um?.stopCapturing();
+    render();
+    return { status: "moved", ids: movedIds };
+  }
+
+  const sv = [...Y.decodeStateVector(Y.encodeStateVector(pd.ydoc)).entries()].sort((left, right) => left[0] - right[0]);
+  const operationId = mintOp(pd);
+  const units = flowUnits(pd, origins);
+  const before = createProjectionMap(current, pd.flow.length);
+  const captured = [];
+  let cursor = 0;
+  for (const seg of current.visible) {
+    if (selectedSet.has(seg.id)) {
+      const block = [];
+      for (const [from, to] of before.physicalRanges(cursor, cursor + seg.len)) for (let unit = from; unit < to; unit++) block.push(units[unit]);
+      captured.push({ seg, units: block });
+    }
+    cursor += seg.len;
+  }
+  for (let index = 0; index < captured.length; index++) {
+    const block = captured[index];
+    if (block.seg.id !== movedIds[index]) throw new Error(`Captured ${block.seg.id} where ${movedIds[index]} was expected`);
+    if (!block.units.length || block.units[0].embed === undefined || block.units[0].embed.b !== block.seg.id) throw new Error(`The selected block ${block.seg.id} has no physical marker to copy`);
+  }
+
+  const removals = liveRemovals(pd, current, selectedSet);
+  const intents = parseGoneIntents(pd.gone);
+  const promotions = new Map();
+  for (const block of selected) {
+    const seg = segments.get(block.id);
+    if (!seg.recovered) continue;
+    const removalsOf = current.removals.filter((removal) => removal.sourceKey === seg.sourceKey);
+    const winner = recoveredRoot(seg.sourceKey, removalsOf, intents);
+    const baseline = intents.restores.find((restore) => restore.key === winner?.key)?.baseline ?? { type: seg.t, attrs: seg.fields ?? {} };
+    promotions.set(seg.sourceKey, { covers: removalsOf.map((removal) => removal.key), baseline: JSON.parse(JSON.stringify(baseline)) });
+  }
+  const caret = (() => {
+    const sel = view?.state.selection;
+    if (!(sel instanceof pmState.TextSelection)) return null;
+    const at = (pos) => { const $pos = view.state.doc.resolve(pos); return $pos.depth ? { id: $pos.node(1).attrs.id, offset: $pos.parentOffset } : null; };
+    const anchor = at(sel.anchor), head = at(sel.head);
+    return anchor && head && (selectedSet.has(anchor.id) || selectedSet.has(head.id)) ? { anchor, head } : null;
+  })();
+  if (!removals.length) throw new Error("The selected blocks have no live physical markers to retire");
+
+  um?.stopCapturing();
+  pd.ydoc.transact(() => {
+    for (const removal of removals) pd.gone.set(removeKey(removal.key, operationId), { blockId: removal.blockId, end: removal.end, sv });
+
+    const after = walk(pd, origins);
+    const map = createProjectionMap(after, pd.flow.length);
+    const afterIds = after.visible.map((seg) => seg.id);
+    let index = 0;
+    if (insertAt > 0) {
+      const found = afterIds.indexOf(remaining[insertAt - 1].id);
+      index = found < 0 ? 0 : found + 1;
+    }
+    let position = 0;
+    for (let i = 0; i < index; i++) position += after.visible[i].len;
+    let cursor = map.toPhysical(position, "before");
+    const spans = [];
+    for (const block of captured) {
+      const start = cursor;
+      let text = null, textAttrs = null;
+      const flush = () => {
+        if (text === null) return;
+        pd.flow.insert(cursor, text, textAttrs ?? undefined);
+        cursor += text.length;
+        text = null;
+      };
+      for (const unit of block.units) {
+        if (unit.ch !== undefined) {
+          if (text !== null && attrsKey(unit.attrs) !== attrsKey(textAttrs)) flush();
+          if (text === null) { text = ""; textAttrs = unit.attrs; }
+          text += unit.ch;
+        } else {
+          flush();
+          pd.flow.insertEmbed(cursor, unit.embed, unit.attrs);
+          cursor += 1;
+        }
+      }
+      flush();
+      const dest = unitIds(pd.flow, start, cursor);
+      if (dest.length !== block.units.length) throw new Error(`Copied ${block.seg.id} as ${dest.length} units instead of ${block.units.length}`);
+      for (let i = 1; i < block.units.length; i++) spans.push({ dest: dest[i], source: block.units[i].source });
+      origins.recordBoundary(dest[0], block.seg.recovered ? { blockId: block.seg.id, kind: "copy", recoveryOf: block.seg.sourceKey } : { blockId: block.seg.id, kind: "copy" });
+      if (block.seg.recovered) pd.gone.set(restoreKey(block.seg.sourceKey, operationId), promotions.get(block.seg.sourceKey));
+      pd.gone.set(copyActiveKey(physicalKeyOf(dest[0])), true);
+    }
+    if (spans.length) origins.recordSpans(spans);
+    for (const block of movedRoots) setParent(pd, segments.get(block.id), block.id, parent);
+    for (const change of changes) setAttr(pd, segments.get(change.id), change.id, change.field, change.value);
+  }, LOCAL);
+  um?.stopCapturing();
+  render();
+  if (caret && view) {
+    const place = ({ id, offset }) => {
+      let found = null;
+      view.state.doc.forEach((node, pos) => { if (found === null && node.attrs.id === id) found = pos + 1 + Math.min(offset, node.content.size); });
+      return found;
+    };
+    const anchor = place(caret.anchor), head = place(caret.head);
+    if (anchor !== null && head !== null) view.dispatch(view.state.tr.setSelection(pmState.TextSelection.create(view.state.doc, anchor, head)).setMeta(REMOTE_META, true).setMeta("addToHistory", false));
+  }
+  return { status: "moved", ids: movedIds };
+}

package/src/page/ybind/origins.js

@@ -0,0 +1,257 @@
+import * as Y from "../../vendor/yjs.vendor.js";
+
+export const ORIGINS_ORIGIN = "page-origins";
+export const UNDO_OVERLAP_ORIGIN = "page-undo-overlap-repair";
+
+export const spanKey = (client, clock) => JSON.stringify(["span", client, clock]);
+export const aliasKey = (client, clock) => JSON.stringify(["alias", client, clock]);
+export const boundaryKey = (client, clock) => JSON.stringify(["boundary", client, clock]);
+
+const BOUNDARY_KINDS = ["copy", "removed", "restore"];
+const DIGITS = /^(?:0|[1-9]\d*)$/;
+const idKey = (client, clock) => `${client}.${clock}`;
+const isClock = (value) => Number.isSafeInteger(value) && value >= 0;
+const isLength = (value) => Number.isSafeInteger(value) && value > 0;
+const isPlain = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const conflicting = (key) => new Error(`Conflicting immutable origin record: ${key}`);
+
+const isSourceKey = (value) => {
+  if (typeof value !== "string") return false;
+  const dot = value.indexOf(".");
+  if (dot < 1 || dot === value.length - 1) return false;
+  const client = value.slice(0, dot), clock = value.slice(dot + 1);
+  return DIGITS.test(client) && DIGITS.test(clock) && isClock(Number(client)) && isClock(Number(clock));
+};
+
+const boundaryRecord = (value) => {
+  if (!isPlain(value)) return null;
+  for (const field of Object.keys(value)) if (field !== "blockId" && field !== "kind" && field !== "recoveryOf") return null;
+  if (typeof value.blockId !== "string" || !value.blockId) return null;
+  if (!BOUNDARY_KINDS.includes(value.kind)) return null;
+  if (value.recoveryOf !== undefined && !isSourceKey(value.recoveryOf)) return null;
+  return value.recoveryOf === undefined ? { blockId: value.blockId, kind: value.kind } : { blockId: value.blockId, kind: value.kind, recoveryOf: value.recoveryOf };
+};
+
+const sameBoundary = (a, b) => a.blockId === b.blockId && a.kind === b.kind && a.recoveryOf === b.recoveryOf;
+
+const recordKey = (key) => {
+  if (typeof key !== "string" || key.charCodeAt(0) !== 91) return null;
+  let parts;
+  try { parts = JSON.parse(key); } catch { return null; }
+  if (!Array.isArray(parts) || parts.length !== 3) return null;
+  if (parts[0] !== "span" && parts[0] !== "alias" && parts[0] !== "boundary") return null;
+  return isClock(parts[1]) && isClock(parts[2]) ? parts : null;
+};
+
+export function createOriginIndex(origins) {
+  const spans = new Map();
+  const aliases = new Map();
+  const boundaries = new Map();
+
+  const lower = (list, clock) => {
+    let lo = 0, hi = list.length;
+    while (lo < hi) { const mid = (lo + hi) >> 1; if (list[mid].clock < clock) lo = mid + 1; else hi = mid; }
+    return lo;
+  };
+  const apply = (key, value) => {
+    const parts = recordKey(key);
+    if (!parts) return;
+    const [kind, client, clock] = parts;
+    if (kind === "alias") {
+      if (value && isClock(value.sourceClient) && isClock(value.sourceClock)) aliases.set(idKey(client, clock), { client: value.sourceClient, clock: value.sourceClock });
+      else aliases.delete(idKey(client, clock));
+      return;
+    }
+    if (kind === "boundary") {
+      const record = boundaryRecord(value);
+      if (record) boundaries.set(idKey(client, clock), record);
+      else boundaries.delete(idKey(client, clock));
+      return;
+    }
+    const list = spans.get(client) ?? [];
+    const at = lower(list, clock);
+    if (list[at]?.clock === clock) list.splice(at, 1);
+    if (value && isLength(value.length) && isClock(value.sourceClient) && isClock(value.sourceClock)) {
+      list.splice(lower(list, clock), 0, { client, clock, length: value.length, sourceClient: value.sourceClient, sourceClock: value.sourceClock });
+    }
+    if (list.length) spans.set(client, list);
+    else spans.delete(client);
+  };
+  for (const [key, value] of origins) apply(key, value);
+  const observer = (event) => { for (const key of event.keysChanged) apply(key, origins.get(key)); };
+  origins.observe(observer);
+
+  const resolve = (id) => {
+    const alias = aliases.get(idKey(id.client, id.clock));
+    if (alias) return { client: alias.client, clock: alias.clock };
+    const list = spans.get(id.client);
+    if (!list) return { client: id.client, clock: id.clock };
+    let lo = 0, hi = list.length - 1, found = -1;
+    while (lo <= hi) { const mid = (lo + hi) >> 1; if (list[mid].clock <= id.clock) { found = mid; lo = mid + 1; } else hi = mid - 1; }
+    if (found < 0) return { client: id.client, clock: id.clock };
+    const record = list[found];
+    const offset = id.clock - record.clock;
+    if (offset >= record.length) return { client: id.client, clock: id.clock };
+    return { client: record.sourceClient, clock: record.sourceClock + offset };
+  };
+
+  const boundaryOf = (id) => {
+    if (!id || !isClock(id.client) || !isClock(id.clock)) return null;
+    let key = idKey(id.client, id.clock);
+    const seen = new Set();
+    while (!seen.has(key)) {
+      seen.add(key);
+      const alias = aliases.get(key);
+      if (!alias) break;
+      key = idKey(alias.client, alias.clock);
+    }
+    if (seen.has(key) && aliases.has(key)) return null;
+    const record = boundaries.get(key);
+    return record ? { ...record } : null;
+  };
+
+  const writeSpan = (client, clock, value) => {
+    const key = spanKey(client, clock);
+    const old = origins.get(key);
+    if (old !== undefined && (old.length !== value.length || old.sourceClient !== value.sourceClient || old.sourceClock !== value.sourceClock)) throw conflicting(key);
+    const list = spans.get(client) ?? [];
+    const at = lower(list, clock);
+    for (const other of [list[at - 1], list[at]]) {
+      if (other && other.clock !== clock && other.clock < clock + value.length && clock < other.clock + other.length) throw conflicting(key);
+    }
+    if (old === undefined) origins.set(key, value);
+  };
+
+  const recordSpans = (entries) => {
+    const run = [];
+    const flush = () => {
+      if (!run.length) return;
+      const first = run[0];
+      const value = { length: run.length, sourceClient: first.source.client, sourceClock: first.source.clock };
+      if (!isClock(value.sourceClock + value.length - 1)) throw new Error(`Unsafe origin span: ${spanKey(first.dest.client, first.dest.clock)}`);
+      writeSpan(first.dest.client, first.dest.clock, value);
+      run.length = 0;
+    };
+    for (const entry of entries) {
+      if (!entry?.dest || !entry?.source) throw new Error("Invalid origin destination");
+      const dest = entry.dest, source = entry.source;
+      if (!isClock(dest.client) || !isClock(dest.clock) || !isClock(source.client) || !isClock(source.clock)) throw new Error("Invalid origin destination");
+      const flat = resolve(source);
+      const prev = run[run.length - 1];
+      if (prev && prev.dest.client === dest.client && prev.dest.clock + 1 === dest.clock && prev.source.client === flat.client && prev.source.clock + 1 === flat.clock) run.push({ dest, source: flat });
+      else { flush(); run.push({ dest, source: flat }); }
+    }
+    flush();
+  };
+
+  const recordAlias = (dest, source) => {
+    if (!dest || !source || !isClock(dest.client) || !isClock(dest.clock) || !isClock(source.client) || !isClock(source.clock)) throw new Error("Invalid origin destination");
+    const flat = resolve(source);
+    const key = aliasKey(dest.client, dest.clock);
+    const old = origins.get(key);
+    if (old !== undefined && (old.sourceClient !== flat.client || old.sourceClock !== flat.clock)) throw conflicting(key);
+    if (old === undefined) origins.set(key, { sourceClient: flat.client, sourceClock: flat.clock });
+  };
+
+  const recordBoundary = (dest, value) => {
+    if (!dest || !isClock(dest.client) || !isClock(dest.clock)) throw new Error("Invalid origin destination");
+    const record = boundaryRecord(value);
+    if (!record) throw new Error(`Invalid boundary record: ${boundaryKey(dest.client, dest.clock)}`);
+    const key = boundaryKey(dest.client, dest.clock);
+    const existing = origins.get(key);
+    if (existing === undefined) { origins.set(key, record); return; }
+    const previous = boundaryRecord(existing);
+    if (!previous || !sameBoundary(previous, record)) throw conflicting(key);
+  };
+
+  return {
+    origins, resolve, recordSpans, recordAlias, recordBoundary, boundaryOf,
+    get size() { return origins.size; },
+    dispose() { origins.unobserve(observer); },
+  };
+}
+
+export function unitIds(flow, from, to) {
+  const out = [];
+  let at = 0;
+  for (let item = flow._start; item && at < to; item = item.right) {
+    if (item.deleted || !item.countable) continue;
+    const start = at;
+    at += item.length;
+    if (at <= from) continue;
+    const lo = Math.max(0, from - start);
+    const hi = Math.min(item.length, to - start);
+    for (let offset = lo; offset < hi; offset++) out.push({ client: item.id.client, clock: item.id.clock + offset });
+  }
+  return out;
+}
+
+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);
+});
+
+const livePhysicalIndex = (flow, id) => {
+  let at = 0;
+  for (let item = flow._start; item; item = item.right) {
+    if (item.deleted || !item.countable) continue;
+    if (item.id.client === id.client && item.id.clock <= id.clock && id.clock < item.id.clock + item.length) return at + id.clock - item.id.clock;
+    at += item.length;
+  }
+  return null;
+};
+
+const repairOverlaps = (pd, dests) => {
+  const indexes = [];
+  for (const dest of dests) {
+    const at = livePhysicalIndex(pd.flow, dest);
+    if (at !== null) indexes.push(at);
+  }
+  indexes.sort((a, b) => a - b);
+  const ranges = [];
+  for (const at of indexes) {
+    const last = ranges[ranges.length - 1];
+    if (last && at <= last[1]) last[1] = Math.max(last[1], at + 1);
+    else ranges.push([at, at + 1]);
+  }
+  for (let i = ranges.length - 1; i >= 0; i--) {
+    const [from, to] = ranges[i];
+    if (to > from) pd.flow.delete(from, to - from);
+  }
+};
+
+export function installUndoOrigins(pd, um, index = createOriginIndex(pd.origins), textDeletes = () => []) {
+  const hook = (transaction) => {
+    if (transaction.origin !== um || !um.currStackItem) return;
+    const spans = [];
+    const aliases = [];
+    const repairs = [];
+    const records = textDeletes(pd.gone);
+    Y.iterateDeletedStructs(transaction, um.currStackItem.deletions, (item) => {
+      if (!(item instanceof Y.Item) || item.parent !== pd.flow || !item.countable || !item.redone) return;
+      const marker = item.content instanceof Y.ContentEmbed && item.content.embed?.b !== undefined;
+      for (let offset = 0; offset < item.length; offset++) {
+        const original = { client: item.id.client, clock: item.id.clock + offset };
+        const source = index.resolve(original);
+        let dest = { client: item.redone.client, clock: item.redone.clock + offset };
+        let live = Y.getItem(pd.ydoc.store, dest);
+        while (live instanceof Y.Item && live.redone) {
+          dest = { client: live.redone.client, clock: live.redone.clock + dest.clock - live.id.clock };
+          live = Y.getItem(pd.ydoc.store, dest);
+        }
+        if (!(live instanceof Y.Item) || live.deleted) continue;
+        if (dest.clock < (transaction.beforeState.get(dest.client) ?? 0)) continue;
+        if (!marker && coversOriginal(records, pd.ydoc.clientID, original)) { repairs.push(dest); continue; }
+        (marker ? aliases : spans).push({ dest, source });
+      }
+    });
+    if (spans.length || aliases.length) pd.ydoc.transact(() => {
+      if (spans.length) index.recordSpans(spans);
+      for (const alias of aliases) index.recordAlias(alias.dest, alias.source);
+    }, ORIGINS_ORIGIN);
+    if (repairs.length) pd.ydoc.transact(() => repairOverlaps(pd, repairs), UNDO_OVERLAP_ORIGIN);
+  };
+  pd.ydoc.on("beforeObserverCalls", hook);
+  return () => pd.ydoc.off("beforeObserverCalls", hook);
+}

package/src/page/ybind/parts.js

@@ -0,0 +1,44 @@
+export const PART_KEY = /^(.+)\.(\d+)\.(\d+)$/;
+export const BASE64 = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}(?:==)?|[A-Za-z0-9+/]{3}=?)?$/;
+const PART_CHARS = /^[A-Za-z0-9+/=\t\n\f\r ]*$/;
+
+export function entriesOf(y) {
+  const whole = [];
+  const parts = new Map();
+  for (const k of Object.keys(y).sort()) {
+    const m = PART_KEY.exec(k);
+    if (!m) { whole.push([k, y[k]]); continue; }
+    const group = parts.get(m[1]) ?? { n: Number(m[3]), got: [] };
+    group.got[Number(m[2])] = y[k];
+    parts.set(m[1], group);
+  }
+  for (const [k, group] of parts) {
+    let have = 0;
+    for (let i = 0; i < group.n; i++) if (typeof group.got[i] === "string") have++;
+    if (have === group.n) whole.push([k, group.got.join("")]);
+  }
+  return whole;
+}
+
+export function captureYValue(value) {
+  if (value?.v !== 1 || !value.y || typeof value.y !== "object" || Array.isArray(value.y)) return value;
+  const groups = new Map();
+  for (const [key, text] of Object.entries(value.y)) {
+    const part = PART_KEY.exec(key);
+    if (!part) continue;
+    const base = part[1], index = Number(part[2]), count = Number(part[3]);
+    const group = groups.get(base) ?? { count, indices: new Set(), keys: [], invalid: false };
+    if (!Number.isSafeInteger(index) || !Number.isSafeInteger(count) || count < 1 || index >= count || group.count !== count || group.indices.has(index) || typeof text !== "string" || !PART_CHARS.test(text)) group.invalid = true;
+    group.indices.add(index);
+    group.keys.push(key);
+    groups.set(base, group);
+  }
+  const omit = new Set();
+  for (const [base, group] of groups) {
+    if (!group.invalid && !Object.hasOwn(value.y, base) && group.indices.size < group.count) {
+      for (const key of group.keys) omit.add(key);
+    }
+  }
+  if (!omit.size) return value;
+  return { ...value, y: Object.fromEntries(Object.entries(value.y).filter(([key]) => !omit.has(key))) };
+}

package/src/page/ybind/projection-map.js

@@ -0,0 +1,92 @@
+const isCount = (value) => Number.isSafeInteger(value) && value >= 0;
+const fail = (message) => { throw new RangeError(message); };
+const sideOf = (affinity) => {
+  if (affinity !== "before" && affinity !== "after") fail(`Unknown affinity: ${affinity}`);
+  return affinity;
+};
+const firstAbove = (list, pick, value) => {
+  let lo = 0, hi = list.length;
+  while (lo < hi) { const mid = (lo + hi) >> 1; if (pick(list[mid]) <= value) lo = mid + 1; else hi = mid; }
+  return lo;
+};
+
+export function createProjectionMap(w, physicalLength) {
+  if (!w || typeof w !== "object" || !isCount(w.tokens)) fail("A projection map needs a walk result with a token count");
+  if (!isCount(physicalLength)) fail("A projection map needs a nonnegative physical length");
+  const holes = w.holes === undefined ? [] : w.holes;
+  if (!Array.isArray(holes)) fail("A projection map needs the walk holes");
+  const segments = [];
+  const spans = [];
+  const prefix = [0];
+  let logical = 0, physical = 0, previousAt = -1;
+  const show = (length) => {
+    segments.push({ logicalStart: logical, logicalLength: length, physicalStart: physical, physicalLength: length, kind: "visible" });
+    logical += length;
+    physical += length;
+  };
+  const hide = (length) => {
+    const last = spans[spans.length - 1];
+    if (last && last.at === logical) {
+      last.length += length;
+      last.end += length;
+      segments[segments.length - 1].physicalLength += length;
+      prefix[prefix.length - 1] += length;
+    } else {
+      spans.push({ at: logical, start: physical, end: physical + length, length });
+      segments.push({ logicalStart: logical, logicalLength: 0, physicalStart: physical, physicalLength: length, kind: "hidden" });
+      prefix.push(prefix[prefix.length - 1] + length);
+    }
+    physical += length;
+  };
+  for (const hole of holes) {
+    if (!hole || typeof hole !== "object" || !isCount(hole.at) || !isCount(hole.len)) fail("Malformed walk hole");
+    if (hole.at < previousAt) fail("Walk holes are out of order");
+    if (hole.at > w.tokens) fail("A walk hole sits past the logical length");
+    previousAt = hole.at;
+    if (hole.at > logical) show(hole.at - logical);
+    if (hole.len) hide(hole.len);
+  }
+  if (logical < w.tokens) show(w.tokens - logical);
+  if (physical !== physicalLength) fail("Walk holes do not account for the physical length");
+  const spansAt = (value) => firstAbove(spans, (span) => span.at, value);
+  const spansEnded = (value) => firstAbove(spans, (span) => span.end, value);
+  const physicalAt = (value) => value + prefix[spansAt(value)];
+  const spanAt = (value) => {
+    const span = spans[spansAt(value) - 1];
+    return span && span.at === value ? span : null;
+  };
+  const spanInside = (value) => {
+    const span = spans[spansEnded(value)];
+    return span && span.start <= value ? span : null;
+  };
+  const toPhysical = (value, affinity) => {
+    const side = sideOf(affinity);
+    if (!isCount(value) || value > w.tokens) fail(`Logical position ${value} is outside the map`);
+    const span = spanAt(value);
+    if (span) return side === "before" ? span.start : span.end;
+    return physicalAt(value);
+  };
+  const toLogical = (value, affinity) => {
+    sideOf(affinity);
+    if (!isCount(value) || value > physicalLength) fail(`Physical position ${value} is outside the flow`);
+    const span = spanInside(value);
+    if (span) return span.at;
+    return value - prefix[spansEnded(value)];
+  };
+  const physicalRanges = (from, to) => {
+    if (!isCount(from) || !isCount(to) || from > w.tokens || to > w.tokens) fail(`Logical range ${from}..${to} is outside the map`);
+    const ranges = [];
+    if (to <= from) return ranges;
+    let start = physicalAt(from);
+    for (const span of spans) {
+      if (span.at <= from) continue;
+      if (span.at > to) break;
+      if (span.start > start) ranges.push([start, span.start]);
+      start = span.end;
+    }
+    const end = physicalAt(to);
+    if (end > start) ranges.push([start, end]);
+    return ranges;
+  };
+  return { segments, logicalLength: w.tokens, physicalLength, toPhysical, toLogical, physicalRanges };
+}