@panphora/clayjs 1.13.0 → 1.14.0

package/src/page/ybind/doc.js

@@ -0,0 +1,58 @@
+import { schema } from "../schema.js";
+import { nodeFromBlock } from "../model.js";
+import { attrKeys, defaultOf } from "./layout.js";
+import { resolveBoardFields } from "./board.js";
+import { resolveTableFields } from "./table.js";
+import { attrKey } from "./recovery.js";
+
+export const fieldsOf = (pd, b, type) => {
+  const m = pd.attrs.get(b.baseId);
+  const out = {};
+  for (const k of attrKeys(type)) out[k] = m && m.has(k) ? m.get(k) : defaultOf(type, k);
+  if (type.name === "board") Object.assign(out, resolveBoardFields(pd.boardFields, b.baseId));
+  if (type.name === "table") Object.assign(out, resolveTableFields(pd.tableFields, b.baseId, { cols: out.cols, rows: out.rows }));
+  return out;
+};
+
+export function docOf(pd, w) {
+  const blocks = w.visible.map((b) => {
+    const type = schema.nodes[b.t] ?? schema.nodes.paragraph;
+    return { b, type, fields: { ...(b.fields ?? fieldsOf(pd, b, type)) } };
+  });
+  const byId = new Map(blocks.map((block) => [block.b.id, block]));
+  const rankOf = (block) => {
+    const item = block.b.recovered
+      ? pd.gone._map.get(attrKey(block.b.sourceKey, "parent"))
+      : pd.attrs.get(block.b.baseId)?._map.get("parent");
+    return item?.id ?? { clock: -1, client: -1 };
+  };
+  for (const start of byId.keys()) {
+    const positions = new Map(), chain = [];
+    let id = start;
+    while (byId.has(id) && !positions.has(id)) {
+      positions.set(id, chain.length);
+      chain.push(id);
+      id = byId.get(id).fields.parent;
+    }
+    if (!positions.has(id)) continue;
+    const cycle = chain.slice(positions.get(id));
+    const lowest = cycle.reduce((left, right) => {
+      const a = rankOf(byId.get(left)), b = rankOf(byId.get(right));
+      return a.clock < b.clock || (a.clock === b.clock && a.client < b.client) ? left : right;
+    });
+    byId.get(lowest).fields.parent = null;
+  }
+  const nodes = blocks.map(({ b, type, fields }) => {
+    const attrs = { id: b.id, pos: null, ...fields };
+    if (type.name === "table" && Object.keys(attrs.rows ?? {}).length) return nodeFromBlock(schema, b.id, { t: "table", ...attrs });
+    if (!type.isTextblock) return type.create(attrs);
+    const content = [];
+    for (const r of b.runs) {
+      if (r.hole) continue;
+      if (r.br) content.push(schema.nodes.hard_break.create());
+      else content.push(schema.text(r.text, r.marks));
+    }
+    return type.create(attrs, content);
+  });
+  return nodes.length ? schema.nodes.doc.create(null, nodes) : schema.nodes.doc.createAndFill();
+}

package/src/page/ybind/external.js

@@ -0,0 +1,190 @@
+import * as Y from "../../vendor/yjs.vendor.js";
+import { transform } from "../../vendor/prosemirror.vendor.js";
+import { schema } from "../schema.js";
+import { nodeFromBlock } from "../model.js";
+import { ATOM, BREAK, canon, normalizeText, renderBlocks, runsOf, unitsOf } from "../projection.js";
+import { writeBoard } from "./board.js";
+import { validCell, writeTable } from "./table.js";
+import { blocksFromYValue } from "./decode.js";
+import { docOf } from "./doc.js";
+import { createPageDoc, attrKeys, defaultOf, mintOp } from "./layout.js";
+import { createProjectionMap } from "./projection-map.js";
+import { docFromValue, enc, PART, YDecodeError } from "./provider.js";
+import { tokensOf, tokenIndex } from "./tokens.js";
+import { walk } from "./walk.js";
+import { applyRegion } from "./writer.js";
+
+const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+const fail = (message) => { throw new YDecodeError("invalid-content", message); };
+const same = (a, b) => canon(a) === canon(b);
+const copy = (value) => JSON.parse(JSON.stringify(value));
+const idOk = (id) => typeof id === "string" && id.length > 0 && !["__proto__", "constructor", "prototype"].includes(id);
+
+function jsonValue(value, seen = new Set()) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (!Array.isArray(value) && !record(value) || seen.has(value)) return false;
+  seen.add(value);
+  const valid = (Array.isArray(value) ? value : Object.values(value)).every((item) => jsonValue(item, seen));
+  seen.delete(value);
+  return valid;
+}
+
+function tableEntities(kind, value) {
+  if (!record(value)) return false;
+  return Object.entries(value).every(([id, item]) => {
+    if (!idOk(id) || !record(item) || typeof item.pos !== "string") return false;
+    if (kind === "cols") return typeof item.name === "string" && (item.kind === undefined || typeof item.kind === "string") && (item.width === undefined || (typeof item.width === "number" && Number.isFinite(item.width) && item.width > 0)) && Object.keys(item).every((key) => ["pos", "name", "kind", "width"].includes(key));
+    return record(item.cells) && Object.entries(item.cells).every(([col, cell]) => idOk(col) && validCell(cell)) && Object.keys(item).every((key) => ["pos", "cells"].includes(key));
+  });
+}
+
+function validAttr(type, key, value) {
+  if (key === "columns" || key === "cards") return type === "board" && record(value);
+  if (key === "cols" || key === "rows") return tableEntities(key, value);
+  if (key === "state") return record(value);
+  if (key === "sort" || key === "artifact") return value === null || record(value);
+  if (key === "series") return Array.isArray(value) && value.every((id) => typeof id === "string");
+  if (key === "width" || key === "size") return value === null || typeof value === "number" && value >= 0;
+  if (key === "level") return Number.isInteger(value) && value >= 1 && value <= 6;
+  if (key === "indent") return Number.isInteger(value) && value >= 0;
+  if (["parent", "owner", "due", "align", "mime", "source", "x", "highlight", "rev"].includes(key)) return value === null || typeof value === "string";
+  if (key === "checked" || key === "open") return typeof value === "boolean";
+  return typeof value === "string";
+}
+
+function boardEntities(kind, value) {
+  if (!record(value)) fail(`Expected board ${kind} as an object`);
+  for (const [id, item] of Object.entries(value)) {
+    if (!idOk(id) || !record(item)) fail(`Invalid board ${kind}: ${id}`);
+    const required = kind === "columns" ? ["pos", "name"] : ["pos", "col", "title"];
+    const allowed = kind === "columns" ? required : [...required, "owner", "due"];
+    if (Object.keys(item).some((key) => !allowed.includes(key)) || required.some((key) => typeof item[key] !== "string") ||
+      ["owner", "due"].some((key) => key in item && item[key] !== null && typeof item[key] !== "string")) fail(`Invalid board ${kind}: ${id}`);
+  }
+}
+
+function validateContent(change, block) {
+  if (!Object.hasOwn(change, "content")) return;
+  const content = change.content;
+  if (!schema.nodes[block.t].isTextblock || !record(content) || typeof content.c !== "string" || Object.keys(content).some((key) => key !== "c" && key !== "m")) fail(`Invalid content for block: ${change.id}`);
+  if (content.m !== undefined) {
+    const units = unitsOf(content.m, content.c.length);
+    if (!units || units.some((key, index) => typeof key !== "string" || (key.startsWith("@") && (key !== BREAK || content.c[index] !== ATOM)) || (block.t === "code_block" && key))) fail(`Invalid marks for block: ${change.id}`);
+  }
+}
+
+function validateChanges(changes, blocks) {
+  if (!Array.isArray(changes)) fail("Expected an array of block changes");
+  const seen = new Set();
+  return changes.map((change) => {
+    if (!record(change) || !idOk(change.id) || seen.has(change.id) || !Object.hasOwn(blocks, change.id) || Object.keys(change).some((key) => !["id", "content", "attrs"].includes(key)) || (!Object.hasOwn(change, "content") && !Object.hasOwn(change, "attrs")) || !jsonValue(change)) fail("Invalid block change");
+    seen.add(change.id);
+    const current = blocks[change.id];
+    const type = schema.nodes[current.t];
+    if (Object.hasOwn(change, "attrs") && (!record(change.attrs) || Object.entries(change.attrs).some(([key, value]) => !attrKeys(type).includes(key) || !validAttr(current.t, key, value)))) fail(`Invalid attributes for block: ${change.id}`);
+    validateContent(change, current);
+    if (current.t === "board") {
+      if (Object.hasOwn(change.attrs ?? {}, "columns")) boardEntities("columns", change.attrs.columns);
+      if (Object.hasOwn(change.attrs ?? {}, "cards")) boardEntities("cards", change.attrs.cards);
+    }
+    const next = { ...current, ...copy(change.attrs ?? {}) };
+    if (change.content) { next.c = change.content.c; delete next.m; if (change.content.m !== undefined) next.m = copy(change.content.m); }
+    try { nodeFromBlock(schema, change.id, next).check(); } catch (error) { fail(`Invalid block ${change.id}: ${error.message}`); }
+    return { id: change.id, current, next, content: Object.hasOwn(change, "content"), attrs: change.attrs ?? {} };
+  });
+}
+
+async function revisionOf(doc) {
+  const bytes = await globalThis.crypto.subtle.digest("SHA-256", Y.encodeStateAsUpdateV2(doc));
+  return Array.from(new Uint8Array(bytes), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+export const projection = Object.freeze({ ATOM, BREAK, canon, normalizeText, renderBlocks, runsOf });
+
+export async function readYValue(value) {
+  const doc = docFromValue(value, { strict: true });
+  try {
+    const blocks = blocksFromYValue(value);
+    return { blocks, revision: await revisionOf(doc) };
+  } finally { doc.destroy(); }
+}
+
+export async function writeYValue(value, { expectedRevision, changes } = {}) {
+  if (typeof expectedRevision !== "string" || !expectedRevision) throw new YDecodeError("missing-revision", "A page revision is required");
+  let source, request;
+  try { source = structuredClone(value); request = structuredClone(changes); }
+  catch { throw new YDecodeError("invalid-value", "The page write must contain cloneable data"); }
+  const { blocks, revision } = await readYValue(source);
+  if (expectedRevision !== revision) throw new YDecodeError("stale-revision", "The page revision has changed");
+  const edits = validateChanges(request, blocks);
+  const doc = docFromValue(source, { strict: true });
+  const pending = [];
+  const onUpdate = (bytes) => pending.push(bytes);
+  doc.on("updateV2", onUpdate);
+  try {
+    const pd = createPageDoc(doc);
+    const w = walk(pd);
+    const before = docOf(pd, w);
+    const locations = new Map();
+    before.forEach((node, offset) => locations.set(node.attrs.id, { node, offset }));
+    const tr = new transform.Transform(before);
+    const contentEdits = edits.filter((edit) => edit.content && (!same(edit.current.c, edit.next.c) || !same(edit.current.m, edit.next.m)))
+      .sort((a, b) => (locations.get(b.id)?.offset ?? -1) - (locations.get(a.id)?.offset ?? -1));
+    for (const edit of contentEdits) {
+      const found = locations.get(edit.id);
+      if (!found) fail(`Block is not directly editable: ${edit.id}`);
+      const nextNode = nodeFromBlock(schema, edit.id, edit.next);
+      tr.replaceWith(found.offset + 1, found.offset + found.node.nodeSize - 1, nextNode.content);
+    }
+    const after = new Map();
+    tr.doc.forEach((node, offset) => after.set(node.attrs.id, { node, offset }));
+    const oldTokens = tokensOf(before, new Map(), w.visible);
+    const newTokens = tokensOf(tr.doc, new Map(), w.visible);
+    const oldIndex = tokenIndex(before, new Map(), w.visible);
+    const newIndex = tokenIndex(tr.doc, new Map(), w.visible);
+    const sv = [...Y.decodeStateVector(Y.encodeStateVector(doc)).entries()].sort((a, b) => a[0] - b[0]);
+    const ctx = { pd, map: createProjectionMap(w, pd.flow.length), bt: oldTokens, tx: (fn) => fn(), copies: w.copies, fences: w.fences, sv, operationId: mintOp(pd), recovered: new Map(w.visible.filter((seg) => seg.recovered).map((seg) => [seg.id, seg.sourceKey])) };
+    doc.transact(() => {
+      for (const edit of contentEdits) {
+        const old = locations.get(edit.id), next = after.get(edit.id);
+        const start = oldIndex[old.offset + 1], end = oldIndex[old.offset + old.node.nodeSize - 1];
+        const nextStart = newIndex[next.offset + 1], nextEnd = newIndex[next.offset + next.node.nodeSize - 1];
+        applyRegion(ctx, start, oldTokens.slice(start, end), newTokens.slice(nextStart, nextEnd));
+      }
+      for (const edit of edits) {
+        const { id, current, next, attrs } = edit;
+        if (current.t === "board" && (Object.hasOwn(attrs, "columns") || Object.hasOwn(attrs, "cards"))) writeBoard(pd, id, current, next);
+        const table = current.t === "table" && !ctx.recovered.has(id) && pd.attrs.get(id)?.get("t") === "table";
+        if (table && (Object.hasOwn(attrs, "cols") || Object.hasOwn(attrs, "rows"))) writeTable(pd, id, current, next);
+        const map = pd.attrs.get(id);
+        for (const key of Object.keys(attrs)) {
+          if (current.t === "board" && (key === "columns" || key === "cards")) continue;
+          if (table && (key === "cols" || key === "rows")) continue;
+          const old = map?.has(key) ? map.get(key) : defaultOf(schema.nodes[current.t], key);
+          if (!same(old, next[key])) {
+            if (map) map.set(key, copy(next[key]));
+            else { const created = new Y.Map(); created.set("t", current.t); created.set(key, copy(next[key])); pd.attrs.set(id, created); }
+          }
+        }
+      }
+    });
+    const updates = {};
+    let index = 0;
+    for (const bytes of pending) {
+      const encoded = enc(bytes);
+      let key;
+      do { key = `e${doc.clientID.toString(36)}-${(index++).toString(36)}`; } while (Object.keys(source.y).some((existing) => existing === key || existing.startsWith(`${key}.`)));
+      if (encoded.length <= PART) updates[key] = encoded;
+      else {
+        const count = Math.ceil(encoded.length / PART);
+        for (let part = 0; part < count; part++) updates[`${key}.${part}.${count}`] = encoded.slice(part * PART, (part + 1) * PART);
+      }
+    }
+    const output = { ...source, y: { ...source.y, ...updates } };
+    const result = await readYValue(output);
+    return { value: output, updates, ...result };
+  } finally { doc.off("updateV2", onUpdate); doc.destroy(); }
+}
+
+export { seedPageFromArticle } from "./migrate.js";

package/src/page/ybind/group.js

@@ -0,0 +1,124 @@
+import * as Y from "../../vendor/yjs.vendor.js";
+import { transform } from "../../vendor/prosemirror.vendor.js";
+import { schema } from "../schema.js";
+import { insideTextblocks } from "../model.js";
+import { LOCAL, HISTORY_META, attrKeys, defaultOf, mintId, mintOp } from "./layout.js";
+import { tokensOf, tokenIndex, textTokenRange, projectionOf, yAfter, sameTok } from "./tokens.js";
+import { CHUNK_CHARS, insertTokens, applyRegion, markRange } from "./writer.js";
+import { walk } from "./walk.js";
+
+const { AddMarkStep, RemoveMarkStep, AttrStep, ReplaceStep, Mapping } = transform;
+
+const tableRange = (doc, from, to) => {
+  const start = doc.resolve(from), end = doc.resolve(to);
+  return [
+    start.depth && start.node(1).type.name === "table" ? start.before(1) : from,
+    end.depth && end.node(1).type.name === "table" ? end.after(1) : to,
+  ];
+};
+
+const touchesTable = (doc, from, to) => {
+  let found = false;
+  doc.nodesBetween(from, to, (node) => { if (node.type.name === "table") found = true; return !found && node.type.name !== "table"; });
+  return found;
+};
+
+export function localGroup(pd, transactions, w, stats, um = null, history = true, onFirstWrite = null) {
+  const first = () => { if (onFirstWrite) { const fn = onFirstWrite; onFirstWrite = null; fn(); } };
+  const steps = [], docs = [], maps = [];
+  for (const tr of transactions) tr.steps.forEach((s, i) => { steps.push(s); docs.push(tr.docs[i]); maps.push(s.getMap()); });
+  if (!steps.length) return;
+  const mapping = new Mapping(maps);
+  const sv = [...Y.decodeStateVector(Y.encodeStateVector(pd.ydoc)).entries()].sort((a, b) => a[0] - b[0]);
+  const operationId = mintOp(pd);
+  const d0 = docs[0], dm = transactions[transactions.length - 1].doc;
+  const visible = w.visible.length === 0 && d0.childCount === 1 && d0.firstChild.type.name === "paragraph"
+    ? [{ id: d0.firstChild.attrs.id, implicit: true, t: "paragraph", len: 0 }]
+    : w.visible;
+  const alias = new Map();
+  const implicit = [];
+  { let tok = 0; visible.forEach((s) => { if (s.implicit) implicit.push({ tok, id: s.id, t: s.t }); tok += s.len; }); }
+  implicit.sort((a, b) => b.tok - a.tok);
+  for (const m of implicit) { m.alias = mintId(pd); alias.set(m.id, m.alias); }
+  const holes = alias.size ? w.holes.map((h) => ({ at: h.at + implicit.filter((m) => m.tok < h.at).length, len: h.len })) : w.holes;
+  const projection = projectionOf(w.tokens + alias.size, holes, pd.flow.length + alias.size);
+  const regions = [];
+  const markSteps = [];
+  steps.forEach((step, i) => {
+    const mark = step instanceof AddMarkStep || step instanceof RemoveMarkStep;
+    if (mark && !touchesTable(docs[i], step.from, step.to)) { markSteps.push({ i, step }); return; }
+    const back = new Mapping(maps.slice(0, i)).invert();
+    const fwd = new Mapping(maps.slice(i + 1));
+    const ranges = [];
+    if (step instanceof AttrStep) ranges.push([step.pos, step.pos + 1, step.pos, step.pos + 1]);
+    else if (mark) ranges.push([step.from, step.to, step.from, step.to]);
+    else step.getMap().forEach((os, oe, ns, ne) => ranges.push([os, oe, ns, ne]));
+    for (const [os, oe, ns, ne] of ranges) {
+      const [oa, ob] = tableRange(d0, back.map(os, -1), back.map(oe, 1));
+      const [na, nb] = tableRange(dm, fwd.map(ns, -1), fwd.map(ne, 1));
+      regions.push({ oa, ob, na, nb });
+    }
+  });
+  regions.sort((x, y) => x.oa - y.oa || x.na - y.na);
+  const merged = [];
+  for (const r of regions) {
+    const last = merged[merged.length - 1];
+    if (last && (r.oa <= last.ob || r.na <= last.nb)) { last.ob = Math.max(last.ob, r.ob); last.nb = Math.max(last.nb, r.nb); }
+    else merged.push({ ...r });
+  }
+  const regional = !implicit.length && !markSteps.length && steps.every((step) => step instanceof ReplaceStep) && transactions.every(insideTextblocks);
+  const ia = regional ? null : tokenIndex(d0, alias, visible);
+  const ib = regional ? null : tokenIndex(dm, alias, visible);
+  const bt = regional ? [] : tokensOf(d0, alias, visible);
+  const at = regional ? [] : tokensOf(dm, alias, visible);
+  const pieces = regional ? merged.map((r) => ({ r, old: textTokenRange(d0, r.oa, r.ob), next: textTokenRange(dm, r.na, r.nb) })) : null;
+  const span = regional ? pieces.reduce((n, p) => n + p.next.end - p.next.start, 0) : merged.reduce((n, r) => n + (ib[r.nb] - ib[r.na]), 0);
+  const chunked = span > CHUNK_CHARS;
+  const tx = chunked ? (fn) => pd.ydoc.transact((tr) => { tr.meta.set(HISTORY_META, history); first(); fn(); }, LOCAL) : (fn) => fn();
+  const ctx = { pd, map: projection, bt, tx, copies: w.copies, fences: w.fences, sv, operationId, recovered: new Map(w.visible.filter((seg) => seg.recovered).map((seg) => [seg.id, seg.sourceKey])) };
+  const sig = (toks) => toks.filter((t) => t.k === "b").map((t) => `${t.id}|${t.t}|${JSON.stringify(t.attrs)}`).join("\n");
+  const structural = !regional && (markSteps.length > 0 || sig(bt) !== sig(at));
+  const write = () => {
+    for (const m of implicit) {
+      insertTokens(pd, yAfter(w.holes, m.tok), [{ k: "b", id: m.alias, t: m.t, attrs: Object.fromEntries(attrKeys(schema.nodes[m.t]).map((kk) => [kk, defaultOf(schema.nodes[m.t], kk)])) }], tx);
+    }
+    for (let q = merged.length - 1; q >= 0; q--) {
+      if (regional) {
+        const { r, old, next } = pieces[q];
+        const oldSurvives = old.tokens.map((token, j) => {
+          const left = mapping.mapResult(r.oa + j, 1);
+          const right = mapping.mapResult(r.oa + j + 1, -1);
+          const k = left.pos - r.na;
+          return !left.deleted && !right.deleted && right.pos === left.pos + 1 && k >= 0 && k < next.tokens.length && sameTok(token, next.tokens[k]);
+        });
+        applyRegion(ctx, old.start, old.tokens, next.tokens, oldSurvives);
+      } else {
+        const r = merged[q];
+        const ta = ia[r.oa], tb = ia[r.ob];
+        applyRegion(ctx, ta, bt.slice(ta, tb), at.slice(ib[r.na], ib[r.nb]));
+      }
+    }
+    const markWalk = markSteps.length ? walk(pd) : null;
+    const markCtx = markWalk ? { ...ctx, map: projectionOf(markWalk.tokens, markWalk.holes, pd.flow.length) } : null;
+    for (const { i, step } of markSteps) {
+      const fwd = new Mapping(maps.slice(i + 1));
+      const from = ib[fwd.map(step.from, 1)], to = ib[fwd.map(step.to, -1)];
+      if (to <= from) continue;
+      const name = step.mark.type.name;
+      const val = step instanceof AddMarkStep ? (step.mark.attrs && Object.keys(step.mark.attrs).length ? { ...step.mark.attrs } : true) : null;
+      tx(() => markRange(markCtx, from, to, name, val, at));
+    }
+  };
+  um?.stopCapturing();
+  const timeout = um?.captureTimeout;
+  if (um) um.captureTimeout = Infinity;
+  try {
+    if (chunked) write();
+    else pd.ydoc.transact((tr) => { tr.meta.set(HISTORY_META, history); first(); write(); }, LOCAL);
+  } finally {
+    if (um) um.captureTimeout = timeout;
+    um?.stopCapturing();
+  }
+  stats.groups++;
+  stats.lastGroup = { chunked, structural, regional, span };
+}

package/src/page/ybind/index.js

@@ -0,0 +1,12 @@
+export * from "./core.js";
+export * from "./tokens.js";
+export * from "./writer.js";
+export * from "./group.js";
+export * from "./bridge.js";
+export * from "./seed.js";
+export * from "./origins.js";
+export * from "./recovery.js";
+export * from "./moves.js";
+export * from "./binding.js";
+export { authorIdentity } from "./author.js";
+export * from "./provider.js";

package/src/page/ybind/layout.js

@@ -0,0 +1,27 @@
+import * as Y from "../../vendor/yjs.vendor.js";
+import { REMOTE } from "../model.js";
+
+export const LOCAL = "page-local";
+export const NET = "page-net";
+export const SEED = "page-seed";
+export const REMOTE_META = REMOTE;
+export const HISTORY_META = Symbol("page-history");
+export const PAGE_ROOTS = Object.freeze(["flow", "attrs", "gone", "boardFields", "tableFields", "origins"]);
+
+const SKIP = new Set(["id", "pos"]);
+export const attrKeys = (type) => [...Object.keys(type.spec.attrs || {}).filter((k) => !SKIP.has(k)), ...(type.name === "table" ? ["rows"] : [])];
+export const defaultOf = (type, k) => type.name === "table" && k === "rows" ? {} : type.spec.attrs[k].default;
+export const sameJson = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+export const idKey = (id) => `${id.client}.${id.clock}`;
+export const parseKey = (k) => { const i = k.indexOf("."); return { client: +k.slice(0, i), clock: +k.slice(i + 1) }; };
+export const isHigh = (u) => u >= 0xd800 && u <= 0xdbff;
+export const isLow = (u) => u >= 0xdc00 && u <= 0xdfff;
+
+let opCounter = 0;
+export const mintOp = (pd) => `${pd.ydoc.clientID.toString(36)}-${(opCounter++).toString(36)}`;
+let idCounter = 0;
+export const mintId = (pd) => `b${pd.ydoc.clientID.toString(36)}${(idCounter++).toString(36)}`;
+
+export function createPageDoc(ydoc = new Y.Doc()) {
+  return { ydoc, flow: ydoc.getText("flow"), attrs: ydoc.getMap("attrs"), gone: ydoc.getMap("gone"), boardFields: ydoc.getMap("boardFields"), tableFields: ydoc.getMap("tableFields"), origins: ydoc.getMap("origins") };
+}

package/src/page/ybind/marks.js

@@ -0,0 +1,18 @@
+import { schema } from "../schema.js";
+
+export const markName = (k) => k.split("!")[0].split("~")[0];
+export const isCancel = (k) => k.includes("!");
+export const marksAttrs = (marks) => { const o = {}; for (const m of marks) o[m.type.name] = m.attrs && Object.keys(m.attrs).length ? { ...m.attrs } : true; return o; };
+export const marksKey = (marks) => marks.map((m) => m.type.name + (m.attrs && Object.keys(m.attrs).length ? JSON.stringify(m.attrs) : "")).sort().join("|");
+export function marksFromAttributes(a, blockType) {
+  if (blockType === "code_block") return [];
+  const best = new Map();
+  const cancelled = new Set();
+  for (const k of Object.keys(a)) if (isCancel(k) && a[k]) cancelled.add(k.split("!")[0]);
+  for (const k of Object.keys(a).sort()) {
+    const v = a[k];
+    if (v === null || v === undefined || isCancel(k) || cancelled.has(k)) continue;
+    best.set(markName(k), v);
+  }
+  return [...best].filter(([n]) => schema.marks[n]).map(([n, v]) => schema.marks[n].create(v === true ? null : v));
+}

package/src/page/ybind/migrate.js

@@ -0,0 +1,152 @@
+import * as Y from "../../vendor/yjs.vendor.js";
+import { schema } from "../schema.js";
+import { nodeFromBlock } from "../model.js";
+import { flatten, marksOf } from "../inline.js";
+import { ATOM, BREAK, DEFAULTS, blocksOfValues, orderedIds, unitsOf, runsOf, canon, hash64, parseModel } from "../projection.js";
+import { blockFromItem } from "../adopt.js";
+import { createPageDoc, attrKeys, defaultOf, SEED } from "./layout.js";
+import { blocksFromYValue } from "./decode.js";
+import { PART, enc } from "./provider.js";
+import { boardKey } from "./board.js";
+
+export class YMigrationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "YMigrationError";
+    this.code = "invalid-source";
+  }
+}
+
+const fail = (message) => { throw new YMigrationError(message); };
+const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const copy = (value) => JSON.parse(canon(value));
+
+function sourceBlocks(values) {
+  if (!Array.isArray(values) || !values.length) fail("Expected at least one hybrid page value");
+  for (const value of values) {
+    if (!record(value) || !record(value.blocks) || Object.keys(value).some((key) => key !== "blocks" && key !== "deleted")) fail("Expected a hybrid page value with blocks and optional deleted ids");
+    if (value.deleted != null && !record(value.deleted)) fail("Invalid hybrid page tombstones");
+    for (const [id, block] of Object.entries(value.blocks)) {
+      if (!value.deleted?.[id] && (!id || id === "__proto__" || !record(block))) fail(`Invalid hybrid page block: ${id}`);
+      if (!value.deleted?.[id] && (/^~|~\d+$/).test(id)) fail(`Reserved hybrid page block id: ${id}`);
+    }
+  }
+  return blocksOfValues(values);
+}
+
+function normalizeBlock(id, block, index) {
+  if (!Object.hasOwn(DEFAULTS, block.t)) fail(`Unsupported hybrid block type: ${block.t}`);
+  const type = schema.nodes[block.t];
+  const fields = attrKeys(type);
+  const allowed = new Set(["t", "pos", "c", "m", ...fields, ...(block.t === "table" ? ["rows"] : [])]);
+  for (const key of Object.keys(block)) if (!allowed.has(key)) fail(`Unsupported field on block ${id}: ${key}`);
+  const out = { t: block.t, pos: String(index + 1).padStart(8, "0") };
+  for (const key of fields) {
+    const value = block[key] === undefined ? defaultOf(type, key) : block[key];
+    if (canon(value) !== canon(defaultOf(type, key))) out[key] = copy(value);
+  }
+  if (block.t === "table") {
+    if (block.rows !== undefined && !record(block.rows)) fail(`Invalid table rows: ${id}`);
+    out.rows = copy(block.rows ?? {});
+  }
+  if (!type.isTextblock) {
+    if (block.c != null && block.c !== "" && !(Array.isArray(block.c) && !block.c.length)) fail(`Unexpected text on block: ${id}`);
+    if (block.m != null && !(Array.isArray(block.m) && !block.m.length)) fail(`Unexpected marks on block: ${id}`);
+    return out;
+  }
+  if (block.c != null && typeof block.c !== "string" && !Array.isArray(block.c)) fail(`Invalid text on block: ${id}`);
+  if (typeof block.c === "string" && block.m != null) {
+    const units = unitsOf(block.m, block.c.length);
+    if (!units) fail(`Invalid mark runs on block: ${id}`);
+    for (let i = 0; i < units.length; i++) {
+      const key = units[i];
+      if (typeof key !== "string") fail(`Invalid mark key on block: ${id}`);
+      if (key.startsWith("@") && (key !== BREAK || block.c[i] !== ATOM)) fail(`Unsupported inline atom on block: ${id}`);
+      if (block.t === "code_block" && key) fail(`Unsupported formatting in code block: ${id}`);
+    }
+  } else if (block.m != null) fail(`Mark runs require flat text on block: ${id}`);
+  const node = nodeFromBlock(schema, id, block);
+  node.check();
+  const { c, m } = flatten(node.content);
+  out.c = c;
+  if (m.some(Boolean)) out.m = runsOf(m);
+  return out;
+}
+
+export function buildPageValue(values, clientID) {
+  let doc;
+  try {
+    const source = sourceBlocks(values);
+    const ids = orderedIds(source);
+    const blocks = Object.fromEntries(ids.map((id, index) => [id, normalizeBlock(id, source[id], index)]));
+    doc = new Y.Doc();
+    doc.clientID = clientID;
+    const pd = createPageDoc(doc);
+    let op = 0;
+    doc.transact(() => {
+      for (const id of ids) {
+        const block = blocks[id];
+        const { pos, c, m, ...fields } = block;
+        if (block.t === "board") { delete fields.columns; delete fields.cards; }
+        pd.attrs.set(id, new Y.Map(Object.entries(copy(fields))));
+        if (block.t === "board") {
+          for (const [columnId, column] of Object.entries(block.columns ?? {})) {
+            pd.boardFields.set(boardKey(id, "column", columnId, "alive"), true);
+            for (const field of ["name", "pos"]) pd.boardFields.set(boardKey(id, "column", columnId, field), column[field] ?? "");
+          }
+          for (const [cardId, card] of Object.entries(block.cards ?? {})) {
+            pd.boardFields.set(boardKey(id, "card", cardId, "alive"), true);
+            for (const field of ["title", "owner", "due"]) if (card[field] !== undefined) pd.boardFields.set(boardKey(id, "card", cardId, field), card[field]);
+            pd.boardFields.set(boardKey(id, "card", cardId, "placement"), { columnId: card.col ?? "", pos: card.pos ?? "" });
+          }
+        }
+        pd.flow.insertEmbed(pd.flow.length, { b: id }, {});
+        if (!c) continue;
+        let offset = 0;
+        for (const [length, key] of runsOf(unitsOf(m, c.length) ?? Array(c.length).fill(""))) {
+          if (key === BREAK) {
+            for (let i = 0; i < length; i++) pd.flow.insertEmbed(pd.flow.length, { br: 1 }, {});
+          } else {
+            const attrs = Object.fromEntries(marksOf(schema, key).map((mark) => [`${mark.type.name}~${clientID}-m${(op++).toString(36)}`, Object.keys(mark.attrs).length ? copy(mark.attrs) : true]));
+            pd.flow.insert(pd.flow.length, c.slice(offset, offset + length), attrs);
+          }
+          offset += length;
+        }
+      }
+    }, SEED);
+    const text = enc(Y.encodeStateAsUpdateV2(doc));
+    const count = Math.ceil(text.length / PART);
+    const y = count <= 1 ? { seed: text } : Object.fromEntries(Array.from({ length: count }, (_, i) => [`seed.${i}.${count}`, text.slice(i * PART, (i + 1) * PART)]));
+    const value = { v: 1, g: 0, y };
+    if (canon(blocksFromYValue(value)) !== canon(blocks)) fail("Hybrid page data cannot be represented without loss");
+    return value;
+  } catch (error) {
+    if (error instanceof YMigrationError) throw error;
+    throw new YMigrationError(`Cannot migrate hybrid page: ${error.message}`);
+  } finally {
+    doc?.destroy();
+  }
+}
+
+export function migrateHybridValues(values) {
+  return buildPageValue(values, 1);
+}
+
+// A page's merge state rebuilt from its article alone. The client id comes from the content,
+// so every rebuild of the same article is byte-identical (two tabs converge) and rebuilds of
+// different articles never share Yjs item ids.
+export function seedClientId(blocks) {
+  const id = parseInt(hash64(`page-seed:v1:${canon(blocks)}`).slice(0, 8), 16) >>> 0;
+  return id < 2 ? id + 2 : id;
+}
+
+export function seedPageFromArticle(article) {
+  const items = parseModel(article, { seed: article.getAttribute("data-rev") ?? "" });
+  const blocks = {};
+  items.forEach((item, i) => {
+    const block = blockFromItem(item, null);
+    block.pos = String(i + 1).padStart(8, "0");
+    blocks[item.id] = block;
+  });
+  return buildPageValue([{ blocks }], seedClientId(blocks));
+}