@panphora/clayjs 1.13.1 → 1.14.0

package/src/page/ybind/bridge.js

@@ -0,0 +1,382 @@
+import * as Y from "../../vendor/yjs.vendor.js";
+import { REMOTE_META, LOCAL, HISTORY_META, attrKeys, sameJson, parseKey, mintOp } from "./layout.js";
+import { walk, hashText } from "./walk.js";
+import { docOf } from "./doc.js";
+import { localGroup } from "./group.js";
+import { tokenIndex, yBefore, yAfter } from "./tokens.js";
+import { state as pmState } from "../../vendor/prosemirror.vendor.js";
+import { repairSiblings } from "../model.js";
+import { createOriginIndex, installUndoOrigins } from "./origins.js";
+import { reduceRecovery, canonicalRevision, restoreKey, physicalKeyOf, authorKey, RECOVERED_PREFIX, parsePhysicalKey, parseGoneIntents } from "./recovery.js";
+import { moveBlocks } from "./moves.js";
+import { createBoardCommands } from "./board-commands.js";
+import { MOVE, BlockSelection } from "../blocks.js";
+
+const yIndexAt = (doc, holes, pos, visible) => yBefore(holes, tokenIndex(doc, new Map(), visible)[pos]);
+
+export function posAtY(doc, holes, tokens, y, visible = null) {
+  let lo = 0, hi = tokens;
+  while (lo < hi) { const mid = (lo + hi + 1) >> 1; if (yBefore(holes, mid) <= y) lo = mid; else hi = mid - 1; }
+  const idx = tokenIndex(doc, new Map(), visible);
+  let first = -1;
+  for (let p = 0; p < idx.length; p++) {
+    if (idx[p] < lo) continue;
+    if (idx[p] > lo) break;
+    if (first < 0) first = p;
+    if (doc.resolve(p).parent.inlineContent) return p;
+  }
+  return first < 0 ? doc.content.size : first;
+}
+
+export const shapeOf = (doc) => { const out = []; doc.forEach((b) => out.push([b.type.name, b.attrs.id, JSON.stringify(Object.fromEntries(attrKeys(b.type).map((k) => [k, b.attrs[k]]))), b.isTextblock || b.type.name === "table" ? JSON.stringify(b.content.toJSON()) : null])); return JSON.stringify(out); };
+export const bareShape = (doc) => { const out = []; doc.forEach((b) => out.push([b.type.name, JSON.stringify(Object.fromEntries(attrKeys(b.type).map((k) => [k, b.attrs[k]]))), b.isTextblock || b.type.name === "table" ? JSON.stringify(b.content.toJSON()) : null])); return JSON.stringify(out); };
+export function sameBareShape(a, b) {
+  if (a.childCount !== b.childCount) return false;
+  for (let i = 0; i < a.childCount; i++) {
+    const left = a.child(i), right = b.child(i);
+    if (left.type !== right.type) return false;
+    if (attrKeys(left.type).some((key) => !sameJson(left.attrs[key], right.attrs[key]))) return false;
+    if ((left.isTextblock || left.type.name === "table") && !left.content.eq(right.content)) return false;
+  }
+  return true;
+}
+
+const tableSpan = (doc, pos) => {
+  const $pos = doc.resolve(pos);
+  return $pos.depth && $pos.node(1).type.name === "table" ? [$pos.before(1), $pos.after(1)] : null;
+};
+
+export function docDiff(oldDoc, newDoc) {
+  let start = oldDoc.content.findDiffStart(newDoc.content);
+  if (start === null) return null;
+  let { a: endA, b: endB } = oldDoc.content.findDiffEnd(newDoc.content);
+  const overlap = start - Math.min(endA, endB);
+  if (overlap > 0) { endA += overlap; endB += overlap; }
+  const oneTextblock = (doc, end) => { const $start = doc.resolve(start); return $start.parent.isTextblock && $start.sameParent(doc.resolve(end)); };
+  if ((tableSpan(oldDoc, start) || tableSpan(oldDoc, endA)) && !(oneTextblock(oldDoc, endA) && oneTextblock(newDoc, endB))) {
+    start = tableSpan(oldDoc, start)?.[0] ?? start;
+    endA = tableSpan(oldDoc, endA)?.[1] ?? endA;
+    endB = tableSpan(newDoc, endB)?.[1] ?? endB;
+    return { start, endA, endB, tables: true };
+  }
+  return { start, endA, endB };
+}
+
+const cellPoint = (doc, pos) => {
+  const $pos = doc.resolve(pos);
+  if ($pos.depth !== 3 || $pos.parent.type.name !== "table_cell") return null;
+  return { table: $pos.node(1).attrs.id, row: $pos.node(2).attrs.id, col: $pos.parent.attrs.col, offset: $pos.parentOffset };
+};
+
+const cellAt = (doc, point) => {
+  let found = null;
+  doc.forEach((table, at) => {
+    if (found !== null || table.type.name !== "table" || table.attrs.id !== point.table) return;
+    table.forEach((row, rowAt) => {
+      if (found !== null || row.attrs.id !== point.row) return;
+      row.forEach((cell, cellAt) => {
+        if (found === null && cell.attrs.col === point.col) found = at + 2 + rowAt + cellAt + 1 + Math.min(point.offset, cell.content.size);
+      });
+    });
+  });
+  return found;
+};
+
+
+export function keepViewPos(derived, current = null) {
+  const previous = new Map();
+  current?.forEach((block) => { if (block.attrs.id) previous.set(block.attrs.id, block); });
+  const blocks = [];
+  derived.forEach((block) => blocks.push(block));
+  const positions = blocks.map((block) => ({ id: block.attrs.id, pos: previous.get(block.attrs.id)?.attrs.pos ?? block.attrs.pos }));
+  const changes = repairSiblings(positions, "b");
+  let changed = false;
+  const placed = blocks.map((block, index) => {
+    const pos = changes[index]?.pos ?? positions[index].pos;
+    let content = block.content;
+    if (block.type.name === "table") {
+      const rows = [];
+      block.forEach((row) => rows.push(row));
+      const rowPositions = rows.map((row) => ({ id: row.attrs.id, pos: row.attrs.pos }));
+      const rowChanges = repairSiblings(rowPositions, "r");
+      const placedRows = rows.map((row, i) => {
+        const rowPos = rowChanges[i]?.pos ?? rowPositions[i].pos;
+        return rowPos === row.attrs.pos ? row : row.type.create({ ...row.attrs, pos: rowPos }, row.content, row.marks);
+      });
+      if (placedRows.some((row, i) => row !== rows[i])) content = placedRows;
+    }
+    if (pos === block.attrs.pos && content === block.content) return block;
+    changed = true;
+    return block.type.create({ ...block.attrs, pos }, content, block.marks);
+  });
+  return changed ? derived.type.create(derived.attrs, placed) : derived;
+}
+
+const freezeDeep = (value) => {
+  if (value && typeof value === "object") {
+    for (const key of Object.keys(value)) freezeDeep(value[key]);
+    Object.freeze(value);
+  }
+  return value;
+};
+const detached = (value) => freezeDeep(JSON.parse(JSON.stringify(value)));
+
+const restoreIndexAt = (pd, sourceKey) => {
+  const target = parseKey(sourceKey);
+  let at = 0;
+  for (let it = pd.flow._start; it; it = it.right) {
+    if (it.id.client === target.client && it.id.clock === target.clock) return it.deleted ? at : at + it.length;
+    if (!it.deleted && it.countable) at += it.length;
+  }
+  return at;
+};
+
+const newestLocalMarker = (pd, blockId) => {
+  let found = null;
+  for (let it = pd.flow._start; it; it = it.right) {
+    if (it.id.client !== pd.ydoc.clientID || !(it.content instanceof Y.ContentEmbed) || it.content.embed?.b !== blockId) continue;
+    if (!found || it.id.clock > found.clock) found = it.id;
+  }
+  return found;
+};
+
+export function createBridge({ pd, onNotice = () => {}, ownedTokens = [], authorToken = null, stats = { groups: 0, mismatch: 0, renders: 0, first: null }, captureTimeout = 500 }) {
+  let view = null;
+  let w = walk(pd);
+  const origins = createOriginIndex(pd.origins);
+  const um = new Y.UndoManager([pd.flow, pd.attrs, pd.gone, pd.tableFields, pd.boardFields], {
+    trackedOrigins: new Set([LOCAL]),
+    captureTimeout,
+    captureTransaction: (tr) => tr.meta.get(HISTORY_META) !== false,
+    deleteFilter: (item) => {
+      if (item.parent !== pd.flow || !(item.content instanceof Y.ContentEmbed)) return true;
+      const source = origins.resolve(item.id);
+      return source.client !== item.id.client || source.clock !== item.id.clock || origins.boundaryOf(item.id)?.kind !== "copy";
+    },
+  });
+  const offOrigins = installUndoOrigins(pd, um, origins, (gone) => parseGoneIntents(gone).textDeletes);
+  const notified = new Set();
+  const localTokens = new Set(authorToken ? [...ownedTokens, authorToken] : ownedTokens);
+  let registerAuthor = authorToken ? () => {
+    const key = authorKey(pd.ydoc.clientID);
+    if (pd.origins.get(key) !== authorToken) pd.origins.set(key, authorToken);
+  } : null;
+  const dismissed = new Set();
+  const recoveryListeners = new Set();
+  let recoveryVersion = 0;
+  let recoveryMemo = null;
+  let recoverySignature = null;
+  const personalNotice = (record) => {
+    const owners = new Set();
+    for (const block of record.blocks) for (const run of block.runs) {
+      if (!run.displaced) continue;
+      const ownClient = parsePhysicalKey(run.source)?.client === pd.ydoc.clientID;
+      if (run.author && (ownClient || localTokens.has(run.author))) owners.add(run.author);
+      else if (ownClient) owners.add(null);
+    }
+    if (!owners.size) return null;
+    const authors = [...owners].filter(Boolean).sort();
+    return { kind: "recovered-change", source: record.source, revision: record.revision, blockId: record.blockId, author: authors[0] ?? null, authors };
+  };
+  const recoveryState = () => {
+    if (recoveryMemo && recoveryMemo.version === recoveryVersion) return recoveryMemo.snapshot;
+    const reduced = reduceRecovery(pd, { index: origins });
+    const recoverable = reduced.list.filter((record) => record.recoverable).map((record) => detached(record));
+    const notices = detached(recoverable.map((record) => personalNotice(record)).filter((notice) => notice && !dismissed.has(`${notice.source}\u0000${notice.revision}`)));
+    const snapshot = Object.freeze({ recoverable: Object.freeze(recoverable), notices: Object.freeze(notices) });
+    recoveryMemo = { version: recoveryVersion, snapshot };
+    return snapshot;
+  };
+  const recoverySignatureOf = (snapshot) => canonicalRevision({ recoverable: snapshot.recoverable.map((record) => [record.source, record.revision]), notices: snapshot.notices });
+  const bumpRecovery = () => {
+    recoveryVersion++;
+    const snapshot = recoveryState();
+    for (const notice of snapshot.notices) {
+      const key = `${notice.source}\u0000${notice.revision}`;
+      if (!notified.has(key)) { notified.add(key); onNotice(notice); }
+    }
+    if (!recoveryListeners.size) { recoverySignature = null; return; }
+    const signature = recoverySignatureOf(snapshot);
+    if (signature === recoverySignature) return;
+    recoverySignature = signature;
+    for (const listener of [...recoveryListeners]) listener(snapshot);
+  };
+  const refresh = () => {
+    w = walk(pd);
+    bumpRecovery();
+    return docOf(pd, w);
+  };
+  let saved = null;
+  const render = (own = false, fresh = null) => {
+    stats.renders++;
+    const keep = saved;
+    saved = null;
+    const derived = keepViewPos(fresh ?? refresh(), view.state.doc);
+    const d = docDiff(view.state.doc, derived);
+    if (!d) return;
+    const tr = view.state.tr.replace(d.start, d.endA, derived.slice(d.start, d.endB)).setMeta(REMOTE_META, true).setMeta("addToHistory", false);
+    if (own) tr.setMeta("yundo", true);
+    if (keep) {
+      const hiddenUnit = (y) => y >= 0 && w.holes.some((hole) => y >= yBefore(w.holes, hole.at) && y < yAfter(w.holes, hole.at));
+      const placeIn = (id, offset) => {
+        let found = null;
+        tr.doc.forEach((node, pos) => { if (found === null && node.attrs.id === id && node.isTextblock) found = pos + 1 + Math.min(offset, node.content.size); });
+        return found;
+      };
+      const at = (end) => {
+        const abs = Y.createAbsolutePositionFromRelativePosition(end.right, pd.ydoc);
+        if (!abs) return null;
+        const pos = posAtY(tr.doc, w.holes, w.tokens, abs.index, w.visible);
+        if (!end.block) return pos;
+        const $pos = tr.doc.resolve(pos);
+        if ($pos.depth && $pos.node(1).attrs.id === end.block.id) return pos;
+        const left = end.left ? Y.createAbsolutePositionFromRelativePosition(end.left, pd.ydoc) : null;
+        if (!hiddenUnit(abs.index) && !(left && hiddenUnit(left.index - 1))) return pos;
+        return placeIn(end.block.id, end.block.offset) ?? pos;
+      };
+      const anchor = at(keep.anchor), head = at(keep.head);
+      if (anchor !== null && head !== null) tr.setSelection(pmState.TextSelection.create(tr.doc, anchor, head));
+    } else if (d.tables && view.state.selection instanceof pmState.TextSelection) {
+      const anchor = cellPoint(view.state.doc, view.state.selection.anchor), head = cellPoint(view.state.doc, view.state.selection.head);
+      const a = anchor && cellAt(tr.doc, anchor), h = head && cellAt(tr.doc, head);
+      if (a !== null && a !== undefined && h !== null && h !== undefined) tr.setSelection(pmState.TextSelection.create(tr.doc, a, h));
+    }
+    view.dispatch(tr);
+  };
+  const onBefore = (t) => {
+    if (!view || t.origin === LOCAL || t.origin === um || saved) return;
+    const sel = view.state.selection;
+    if (!(sel instanceof pmState.TextSelection)) return;
+    if ([sel.$anchor, sel.$head].some((pos) => pos.depth && pos.node(1).type.name === "table")) return;
+    const end = ($pos) => {
+      const index = yIndexAt(view.state.doc, w.holes, $pos.pos, w.visible);
+      return {
+        right: Y.createRelativePositionFromTypeIndex(pd.flow, index),
+        left: index > 0 ? Y.createRelativePositionFromTypeIndex(pd.flow, index, -1) : null,
+        block: $pos.depth ? { id: $pos.node(1).attrs.id, offset: $pos.parentOffset } : null,
+      };
+    };
+    saved = { anchor: end(sel.$anchor), head: end(sel.$head) };
+  };
+  const onAfter = (t) => {
+    if (!view) { bumpRecovery(); return; }
+    if (t.origin === LOCAL) { saved = null; return; }
+    render(t.origin === um);
+  };
+  const portMove = (tr, move) => {
+    const result = moveBlocks({ pd, view, um, origins, render }, move);
+    if (result.status === "refused") {
+      stats.moveFallbacks = (stats.moveFallbacks ?? 0) + 1;
+      return false;
+    }
+    const sel = tr.selection;
+    if (sel instanceof pmState.TextSelection) return true;
+    const doc = view.state.doc;
+    let from = null, to = null;
+    doc.forEach((node, pos) => {
+      if (!move.ids.includes(node.attrs.id)) return;
+      if (from === null) from = pos;
+      to = pos + node.nodeSize;
+    });
+    if (from === null) return true;
+    const next = sel instanceof pmState.NodeSelection
+      ? pmState.NodeSelection.create(doc, from)
+      : sel.anchor <= sel.head ? new BlockSelection(doc.resolve(from), doc.resolve(to)) : new BlockSelection(doc.resolve(to), doc.resolve(from));
+    const reselect = view.state.tr.setSelection(next).setMeta(REMOTE_META, true).setMeta("addToHistory", false);
+    view.dispatch(tr.scrolledIntoView ? reselect.scrollIntoView() : reselect);
+    return true;
+  };
+  const board = createBoardCommands({ pd, um, origins, render: () => (view ? render() : refresh()) });
+  pd.ydoc.on("beforeTransaction", onBefore);
+  pd.ydoc.on("afterTransaction", onAfter);
+  return {
+    pd, stats, render, um, board,
+    attach(v) {
+      view = v;
+      w = walk(pd);
+    },
+    dispose() {
+      pd.ydoc.off("beforeTransaction", onBefore);
+      pd.ydoc.off("afterTransaction", onAfter);
+      offOrigins();
+      origins.dispose();
+      um.destroy();
+      recoveryListeners.clear();
+      view = null;
+    },
+    get walk() { return w; },
+    get recoverable() { return recoveryState().recoverable; },
+    get notices() { return recoveryState().notices; },
+    subscribeRecovery(listener) {
+      if (typeof listener !== "function") throw new TypeError("subscribeRecovery needs a listener");
+      recoveryListeners.add(listener);
+      const snapshot = recoveryState();
+      if (recoverySignature === null) recoverySignature = recoverySignatureOf(snapshot);
+      listener(snapshot);
+      return () => { recoveryListeners.delete(listener); };
+    },
+    dismiss(sourceKey, revision) {
+      dismissed.add(`${sourceKey}\u0000${revision}`);
+      bumpRecovery();
+    },
+    dispatch(tr) {
+      const move = tr.getMeta(MOVE);
+      if (move && portMove(tr, move)) return;
+      const { state, transactions } = view.state.applyTransaction(tr);
+      const local = transactions.filter((t) => t.docChanged && !t.getMeta(REMOTE_META));
+      view.updateState(state);
+      if (!local.length) return;
+      w = walk(pd);
+      const history = transactions.every((t) => t.getMeta("addToHistory") !== false);
+      const register = registerAuthor;
+      registerAuthor = null;
+      localGroup(pd, local, w, stats, um, history, register);
+      const derived = refresh();
+      if (!sameBareShape(derived, view.state.doc)) {
+        stats.mismatch++;
+        stats.first ??= { before: bareShape(local[0].before), pm: bareShape(view.state.doc), y: bareShape(derived) };
+      }
+      render(false, derived);
+    },
+    // Restore inserts the displaced source as a normal block found by its Yjs identity, with no
+    // provenance layer. Four edge cases are accepted because they are rare and lose no text
+    // (David, 2026-10-21): two people restoring one source at once with different formatting
+    // changes keep one person's formatting; undoing a Restore after a peer typed into it joins
+    // the peer's text onto the previous block; a formatting-only change to a moved block is not
+    // offered for recovery, only typed text is; a personal notice can name an author whose text
+    // someone else removed later. The root fix is the provenance design this replaced
+    // (e4-recovery-spec.md): keep each unit's original interval and each editor's independent
+    // intentions per source, and re-expose the removed marker in place as a virtual position
+    // instead of inserting a new block. Concurrent Restores then merge formatting intentions,
+    // Undo re-hides exactly the restored units, a mark-only change becomes an intention the
+    // list can offer, and a notice checks the surviving intervals before it names anyone.
+    restore(sourceKey, revision) {
+      const fresh = walk(pd, origins);
+      const record = reduceRecovery(pd, { index: origins, walked: fresh }).sources.get(sourceKey);
+      const visible = fresh.visible.find((seg) => seg.sourceKey === sourceKey || (seg.brk && physicalKeyOf(seg.brk) === sourceKey));
+      if (visible) return { status: "resolved", id: visible.id };
+      if (!record || record.revision !== revision) {
+        const notice = recoveryState().notices.find((candidate) => candidate.source === sourceKey) ?? null;
+        return { status: "stale", notice };
+      }
+      const blockId = `${RECOVERED_PREFIX}${sourceKey}`;
+      um.stopCapturing();
+      let marker = null;
+      pd.ydoc.transact(() => {
+        pd.gone.set(restoreKey(sourceKey, mintOp(pd)), { covers: record.removals.map((removal) => removal.key), baseline: { type: record.type, attrs: JSON.parse(JSON.stringify(record.attrs)) } });
+        pd.flow.insertEmbed(restoreIndexAt(pd, sourceKey), { b: blockId });
+        marker = newestLocalMarker(pd, blockId);
+        origins.recordBoundary(marker, { blockId, kind: "restore", recoveryOf: sourceKey });
+      }, LOCAL);
+      um.stopCapturing();
+      render();
+      if (!w.visible.some((seg) => seg.sourceKey === sourceKey && seg.id === blockId)) throw new Error(`Restore did not project ${blockId}`);
+      return { status: "restored", id: blockId };
+    },
+    moveBlocks(args) {
+      return moveBlocks({ pd, view, um, origins, render }, args);
+    },
+    undo() { return um.undo() !== null; },
+    redo() { return um.redo() !== null; },
+  };
+}

package/src/page/ybind/conversion.js

@@ -0,0 +1,26 @@
+import { cloneJson } from "../../live/ops.js";
+import { canon } from "../projection.js";
+import { migrateHybridValues, YMigrationError } from "./migrate.js";
+
+const PAGE = /^page(\.[0-9]+)?$/;
+
+export async function prepareHybridConversion(tags) {
+  try {
+    if (!Array.isArray(tags) || !tags.length) throw new YMigrationError("Expected named hybrid page tags");
+    const names = new Set();
+    const source = tags.map((tag) => {
+      if (!Array.isArray(tag) || tag.length !== 2 || typeof tag[0] !== "string" || !PAGE.test(tag[0]) || names.has(tag[0])) {
+        throw new YMigrationError("Expected unique page tag names");
+      }
+      names.add(tag[0]);
+      return [tag[0], cloneJson(tag[1])];
+    });
+    const value = migrateHybridValues(source.map(([, value]) => value));
+    const bytes = await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(canon(source)));
+    const baseline = Array.from(new Uint8Array(bytes), (byte) => byte.toString(16).padStart(2, "0")).join("");
+    return { baseline, value };
+  } catch (error) {
+    if (error instanceof YMigrationError) throw error;
+    throw new YMigrationError(`Cannot prepare hybrid conversion: ${error.message}`);
+  }
+}

package/src/page/ybind/core.js

@@ -0,0 +1,7 @@
+export * from "./layout.js";
+export * from "./marks.js";
+export * from "./walk.js";
+export * from "./doc.js";
+export * from "./decode.js";
+export * from "./migrate.js";
+export * from "./conversion.js";

package/src/page/ybind/decode.js

@@ -0,0 +1,208 @@
+import * as Y from "../../vendor/yjs.vendor.js";
+import { schema } from "../schema.js";
+import { markKey } from "../inline.js";
+import { ATOM, BREAK, DEFAULTS, blocksOfValues, runsOf } from "../projection.js";
+import { createPageDoc, attrKeys, defaultOf, sameJson, PAGE_ROOTS } from "./layout.js";
+import { resolveBoardFields } from "./board.js";
+import { resolveTableFields } from "./table.js";
+import { markName } from "./marks.js";
+import { walk } from "./walk.js";
+import { docFromValue, YDecodeError } from "./provider.js";
+import { parseGoneIntents, parsePhysicalKey, RecoveryError } from "./recovery.js";
+
+const copy = (value) => value && typeof value === "object" ? JSON.parse(JSON.stringify(value)) : value;
+const unsupported = (message) => { throw new YDecodeError("unsupported-content", message); };
+const hasContent = (root) => {
+  if (root._map) for (const item of root._map.values()) if (!item.deleted) return true;
+  for (let item = root._start; item; item = item.right) if (!item.deleted) return true;
+  return false;
+};
+const invalidOrigin = (message) => { throw new YDecodeError("invalid-content", message); };
+const ORIGIN_FIELDS = { span: ["length", "sourceClient", "sourceClock"], alias: ["sourceClient", "sourceClock"], boundary: ["blockId", "kind", "recoveryOf"] };
+const BOUNDARY_KINDS = ["copy", "removed", "restore"];
+const isClock = (value) => Number.isSafeInteger(value) && value >= 0;
+const isPlain = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const originId = (client, clock) => `${client}.${clock}`;
+const boundaryIdentity = (record) => JSON.stringify([record.blockId, record.kind, record.recoveryOf ?? null]);
+
+function validateFlow(pd) {
+  if (pd.flow._map.size) unsupported("The page flow must contain text and block markers");
+  for (let it = pd.flow._start; it; it = it.right) {
+    if (it.deleted) continue;
+    const c = it.content;
+    if (c instanceof Y.ContentString) continue;
+    if (c instanceof Y.ContentFormat) {
+      if (c.value !== null && !Object.hasOwn(schema.marks, markName(c.key))) unsupported(`Unsupported page mark: ${c.key}`);
+      continue;
+    }
+    if (c instanceof Y.ContentEmbed) {
+      const e = c.embed;
+      if (e && Object.keys(e).length === 1 && ((typeof e.b === "string" && e.b) || e.br === 1)) continue;
+    }
+    unsupported("Unsupported content in the page flow");
+  }
+  for (const [id, attrs] of pd.attrs) {
+    if (!(attrs instanceof Y.Map)) unsupported(`Unsupported attributes for page block: ${id}`);
+  }
+}
+
+const inFlow = (pd, key) => {
+  const id = typeof key === "string" ? parsePhysicalKey(key) : key;
+  if (!id) return false;
+  let item;
+  try { item = Y.getItem(pd.ydoc.store, id); } catch { return false; }
+  return item instanceof Y.Item && item.parent === pd.flow && item.id.clock <= id.clock && id.clock < item.id.clock + item.length;
+};
+const coverSource = (cover) => cover.charCodeAt(0) === 91 ? JSON.parse(cover)[1] : cover;
+function validateRecovery(pd) {
+  let intents;
+  try {
+    intents = parseGoneIntents(pd.gone, { strict: true });
+  } catch (error) {
+    if (error instanceof RecoveryError) throw new YDecodeError("invalid-content", error.message);
+    throw error;
+  }
+  for (const record of intents.textDeletes) {
+    const item = Y.getItem(pd.ydoc.store, { client: record.client, clock: record.clock });
+    if (!(item instanceof Y.Item) || item.parent !== pd.flow || item.id.clock > record.clock || record.clock + record.length > item.id.clock + item.length) {
+      throw new YDecodeError("invalid-content", `Invalid text-delete record: ${record.key}`);
+    }
+  }
+  const invalid = (message) => { throw new YDecodeError("invalid-content", message); };
+  for (const removal of intents.removals) {
+    if (!inFlow(pd, removal.source)) invalid(`Invalid removal source: ${removal.key}`);
+    if (removal.end !== null && !inFlow(pd, removal.end)) invalid(`Invalid removal end: ${removal.key}`);
+  }
+  for (const restore of intents.restores) {
+    if (!inFlow(pd, restore.sourceKey)) invalid(`Invalid restore source: ${restore.key}`);
+    for (const cover of restore.covers) if (!inFlow(pd, coverSource(cover))) invalid(`Invalid restore cover: ${restore.key}`);
+  }
+  for (const key of intents.copyActive) if (!inFlow(pd, key)) invalid(`Invalid copy-active record: ${key}`);
+  for (const key of intents.attrs.keys()) if (!inFlow(pd, key)) invalid(`Invalid attribute override: ${key}`);
+}
+
+function validateOrigins(pd) {
+  const aliases = new Map();
+  const boundaries = new Map();
+  const fieldsOf = (value, allowed, key) => {
+    if (!isPlain(value)) invalidOrigin(`Invalid origin record: ${key}`);
+    for (const field of Object.keys(value)) if (!allowed.includes(field)) invalidOrigin(`Unsupported origin field ${field} in ${key}`);
+  };
+  for (const [key, value] of pd.origins) {
+    if (typeof key !== "string" || key.charCodeAt(0) !== 91) invalidOrigin(`Malformed origin key: ${key}`);
+    let parts = null;
+    try { parts = JSON.parse(key); } catch { invalidOrigin(`Malformed origin key: ${key}`); }
+    if (!Array.isArray(parts) || typeof parts[0] !== "string") invalidOrigin(`Malformed origin key: ${key}`);
+    const kind = parts[0];
+    if (kind === "author") {
+      if (parts.length !== 2 || !isClock(parts[1])) invalidOrigin(`Malformed origin key: ${key}`);
+      if (typeof value !== "string" || !value) invalidOrigin(`Invalid author record: ${key}`);
+      continue;
+    }
+    if (!Object.hasOwn(ORIGIN_FIELDS, kind)) unsupported(`Unsupported origin record: ${key}`);
+    if (parts.length !== 3 || !isClock(parts[1]) || !isClock(parts[2])) invalidOrigin(`Malformed origin key: ${key}`);
+    fieldsOf(value, ORIGIN_FIELDS[kind], key);
+    if (kind === "span") {
+      if (!Number.isSafeInteger(value.length) || value.length < 1 || !isClock(value.sourceClient) || !isClock(value.sourceClock) || !isClock(value.sourceClock + value.length - 1)) invalidOrigin(`Invalid span record: ${key}`);
+      continue;
+    }
+    if (kind === "alias") {
+      if (!isClock(value.sourceClient) || !isClock(value.sourceClock)) invalidOrigin(`Invalid alias record: ${key}`);
+      aliases.set(originId(parts[1], parts[2]), { client: value.sourceClient, clock: value.sourceClock });
+      continue;
+    }
+    if (typeof value.blockId !== "string" || !value.blockId || !BOUNDARY_KINDS.includes(value.kind)) invalidOrigin(`Invalid boundary record: ${key}`);
+    if (value.recoveryOf !== undefined && !parsePhysicalKey(value.recoveryOf)) invalidOrigin(`Invalid boundary record: ${key}`);
+    boundaries.set(originId(parts[1], parts[2]), value);
+  }
+  const claimed = new Map();
+  for (const [key, record] of boundaries) {
+    let at = key;
+    const seen = new Set();
+    while (!seen.has(at)) {
+      seen.add(at);
+      const alias = aliases.get(at);
+      if (!alias) break;
+      at = originId(alias.client, alias.clock);
+    }
+    if (seen.has(at) && aliases.has(at)) invalidOrigin(`Cyclic boundary alias: ${key}`);
+    const previous = claimed.get(at);
+    if (previous && boundaryIdentity(previous) !== boundaryIdentity(record)) invalidOrigin(`Conflicting boundary values: ${key}`);
+    claimed.set(at, record);
+  }
+}
+
+function blockOf(pd, block, index) {
+  if (!Object.hasOwn(DEFAULTS, block.t)) unsupported(`Unsupported page block type: ${block.t}`);
+  const type = schema.nodes[block.t];
+  const attrs = pd.attrs.get(block.baseId);
+  const table = block.t === "table" && !block.fields ? resolveTableFields(pd.tableFields, block.baseId, { cols: attrs?.get("cols"), rows: attrs?.get("rows") }) : null;
+  const out = { t: block.t, pos: String(index + 1).padStart(8, "0") };
+  for (const key of attrKeys(type)) {
+    if (block.t === "board" && (key === "columns" || key === "cards")) continue;
+    const value = block.fields ? block.fields[key] : table && (key === "cols" || key === "rows") ? table[key] : attrs?.has(key) ? attrs.get(key) : defaultOf(type, key);
+    if (!sameJson(value, defaultOf(type, key))) out[key] = copy(value);
+  }
+  if (block.t === "table") out.rows = copy((block.fields ? block.fields.rows : table.rows) ?? {});
+  if (block.t === "board") Object.assign(out, block.fields ? { columns: copy(block.fields.columns ?? {}), cards: copy(block.fields.cards ?? {}) } : resolveBoardFields(pd.boardFields, block.baseId));
+  if (type.isTextblock) {
+    let text = "";
+    const units = [];
+    for (const run of block.runs) {
+      if (run.hole) continue;
+      if (run.br) {
+        if (block.t === "code_block") unsupported("A code block cannot contain a hard-break atom");
+        text += ATOM;
+        units.push(BREAK);
+      } else {
+        text += run.text;
+        const key = markKey([...run.marks].sort((a, b) => a.type.rank - b.type.rank));
+        for (let i = 0; i < run.text.length; i++) units.push(key);
+      }
+    }
+    out.c = text;
+    if (units.some(Boolean)) out.m = runsOf(units);
+  }
+  return out;
+}
+
+export function blocksFromYValue(value) {
+  const doc = docFromValue(value, { strict: true });
+  try {
+    for (const [name, root] of doc.share) if (!PAGE_ROOTS.includes(name) && hasContent(root)) unsupported(`Unsupported page root: ${name}`);
+    const pd = createPageDoc(doc);
+    validateFlow(pd);
+    resolveBoardFields(pd.boardFields);
+    resolveTableFields(pd.tableFields);
+    validateRecovery(pd);
+    validateOrigins(pd);
+    const visible = walk(pd).visible;
+    const reserved = new Set(visible.filter((block) => !block.implicit).map((block) => block.id));
+    const used = new Set();
+    return Object.fromEntries(visible.map((block, index) => {
+      let id = block.id;
+      if (used.has(id) || (block.implicit && reserved.has(id))) {
+        let copy = 2;
+        do { id = `${block.id}~${copy++}`; } while (used.has(id) || reserved.has(id));
+      }
+      used.add(id);
+      return [id, blockOf(pd, block, index)];
+    }));
+  } catch (error) {
+    if (error instanceof YDecodeError) throw error;
+    throw new YDecodeError("invalid-content", `Invalid Yjs page content: ${error.message}`);
+  } finally {
+    doc.destroy();
+  }
+}
+
+export function blocksFromPageValues(values) {
+  if (values.some((value) => !value || typeof value !== "object" || Array.isArray(value))) {
+    throw new YDecodeError("invalid-value", "Expected a page data object");
+  }
+  if (!values.some((value) => Object.hasOwn(value, "y") || Object.hasOwn(value, "v"))) return blocksOfValues(values);
+  if (values.length !== 1 || Object.hasOwn(values[0], "blocks") || Object.hasOwn(values[0], "deleted")) {
+    throw new YDecodeError("invalid-value", "A Yjs page must have one page tag without hybrid block data");
+  }
+  return blocksFromYValue(values[0]);
+}