@panphora/clayjs 1.13.0 → 1.14.0

package/src/page/ybind/recovery.js

@@ -0,0 +1,411 @@
+import * as Y from "../../vendor/yjs.vendor.js";
+import { schema } from "../schema.js";
+import { attrKeys, defaultOf, sameJson } from "./layout.js";
+import { marksAttrs, marksFromAttributes } from "./marks.js";
+import { createOriginIndex } from "./origins.js";
+import { createProjectionMap } from "./projection-map.js";
+import { walk } from "./walk.js";
+import { resolveTableFields } from "./table.js";
+import { resolveBoardFields } from "./board.js";
+
+export const REMOVE = "remove";
+export const RESTORE = "restore";
+export const COPY_ACTIVE = "copy-active";
+export const COPY_LOST = "copy-lost";
+export const ATTR = "attr";
+export const TEXT_DELETE = "text-delete";
+
+export class RecoveryError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RecoveryError";
+  }
+}
+
+const fail = (message) => { throw new RecoveryError(message); };
+const isClock = (value) => Number.isSafeInteger(value) && value >= 0;
+const isLength = (value) => Number.isSafeInteger(value) && value > 0;
+const DIGITS = /^(?:0|[1-9]\d*)$/;
+const isPlain = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const copy = (value) => (value === null || typeof value !== "object" ? value : JSON.parse(JSON.stringify(value)));
+const compare = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+const sortedList = (list) => [...list].sort(compare);
+
+export const physicalKeyOf = (id) => `${id.client}.${id.clock}`;
+export const authorKey = (client) => JSON.stringify(["author", client]);
+export const removeKey = (sourceKey, operationId) => JSON.stringify([REMOVE, sourceKey, operationId]);
+export const restoreKey = (sourceKey, operationId) => JSON.stringify([RESTORE, sourceKey, operationId]);
+export const copyActiveKey = (sourceKey) => JSON.stringify([COPY_ACTIVE, sourceKey]);
+export const copyLostKey = (sourceKey) => JSON.stringify([COPY_LOST, sourceKey]);
+export const textDeleteKey = (client, clock, operationId) => JSON.stringify([TEXT_DELETE, client, clock, operationId]);
+export const attrKey = (sourceKey, field) => JSON.stringify([ATTR, sourceKey, field]);
+
+export function parsePhysicalKey(key) {
+  if (typeof key !== "string") return null;
+  const dot = key.indexOf(".");
+  if (dot < 1 || dot === key.length - 1) return null;
+  const left = key.slice(0, dot), right = key.slice(dot + 1);
+  if (!DIGITS.test(left) || !DIGITS.test(right)) return null;
+  const client = Number(left), clock = Number(right);
+  return isClock(client) && isClock(clock) ? { client, clock } : null;
+}
+
+const checkFields = (value, allowed, key) => {
+  if (!isPlain(value)) fail(`Invalid gone record: ${key}`);
+  for (const field of Object.keys(value)) if (!allowed.includes(field)) fail(`Unsupported gone field ${field} in ${key}`);
+};
+
+const parseVector = (sv, key) => {
+  if (!Array.isArray(sv)) fail(`Invalid state vector in ${key}`);
+  const out = [];
+  let previous = -1;
+  for (const pair of sv) {
+    if (!Array.isArray(pair) || pair.length !== 2) fail(`Invalid state vector in ${key}`);
+    const [client, clock] = pair;
+    if (!isClock(client) || !isClock(clock) || client <= previous) fail(`Invalid state vector in ${key}`);
+    previous = client;
+    out.push([client, clock]);
+  }
+  return out;
+};
+
+const isRemovalKey = (key) => {
+  if (typeof key !== "string") return false;
+  if (key.charCodeAt(0) !== 91) return parsePhysicalKey(key) !== null;
+  let parts;
+  try { parts = JSON.parse(key); } catch { return false; }
+  if (!Array.isArray(parts) || !parsePhysicalKey(parts[1])) return false;
+  if (parts[0] === REMOVE) return parts.length === 3 && typeof parts[2] === "string" && parts[2] !== "";
+  return (parts[0] === COPY_ACTIVE || parts[0] === COPY_LOST) && parts.length === 2;
+};
+
+const recordOf = (value, key, out) => {
+  if (key.charCodeAt(0) === 91) {
+    let parts = null;
+    try { parts = JSON.parse(key); } catch { fail(`Malformed gone key: ${key}`); }
+    if (!Array.isArray(parts) || typeof parts[0] !== "string") fail(`Malformed gone key: ${key}`);
+    if (parts[0] === REMOVE) {
+      if (parts.length !== 3 || typeof parts[2] !== "string" || !parts[2]) fail(`Malformed gone key: ${key}`);
+      const source = parsePhysicalKey(parts[1]);
+      if (!source) fail(`Malformed gone key: ${key}`);
+      checkFields(value, ["blockId", "end", "sv"], key);
+      if (typeof value.blockId !== "string" || !value.blockId) fail(`Invalid removal record: ${key}`);
+      const end = value.end ?? null;
+      if (end !== null && !parsePhysicalKey(end)) fail(`Invalid removal record: ${key}`);
+      out.removals.push({ key, sourceKey: parts[1], source, operationId: parts[2], blockId: value.blockId, end, sv: parseVector(value.sv, key), legacy: false });
+      return;
+    }
+    if (parts[0] === RESTORE) {
+      if (parts.length !== 3 || typeof parts[2] !== "string" || !parts[2]) fail(`Malformed gone key: ${key}`);
+      if (!parsePhysicalKey(parts[1])) fail(`Malformed gone key: ${key}`);
+      checkFields(value, ["covers", "baseline"], key);
+      if (!Array.isArray(value.covers) || value.covers.some((cover) => !isRemovalKey(cover))) fail(`Invalid restore record: ${key}`);
+      const baseline = value.baseline ?? {};
+      checkFields(baseline, ["type", "attrs"], key);
+      if (typeof baseline.type !== "string" || !isPlain(baseline.attrs)) fail(`Invalid restore record: ${key}`);
+      out.restores.push({ key, sourceKey: parts[1], operationId: parts[2], covers: sortedList(value.covers), baseline: { type: baseline.type, attrs: copy(baseline.attrs) } });
+      return;
+    }
+    if (parts[0] === COPY_ACTIVE) {
+      if (parts.length !== 2 || !parsePhysicalKey(parts[1])) fail(`Malformed gone key: ${key}`);
+      if (value !== true) fail(`Invalid copy-active record: ${key}`);
+      out.copyActive.add(parts[1]);
+      return;
+    }
+    if (parts[0] === TEXT_DELETE) {
+      if (parts.length !== 4 || !isClock(parts[1]) || !isClock(parts[2]) || typeof parts[3] !== "string" || !parts[3]) fail(`Malformed gone key: ${key}`);
+      checkFields(value, ["length", "actor", "sv"], key);
+      if (!isLength(value.length) || !isClock(parts[2] + value.length - 1)) fail(`Invalid text-delete record: ${key}`);
+      if (!isClock(value.actor)) fail(`Invalid text-delete record: ${key}`);
+      out.textDeletes.push({ key, client: parts[1], clock: parts[2], length: value.length, actor: value.actor, sv: parseVector(value.sv, key) });
+      return;
+    }
+    if (parts[0] === ATTR) {
+      if (parts.length !== 3 || !parsePhysicalKey(parts[1]) || typeof parts[2] !== "string" || !parts[2]) fail(`Malformed gone key: ${key}`);
+      if (value === undefined) fail(`Invalid attribute override: ${key}`);
+      const fields = out.attrs.get(parts[1]) ?? new Map();
+      fields.set(parts[2], copy(value));
+      out.attrs.set(parts[1], fields);
+      return;
+    }
+    fail(`Unsupported gone record: ${key}`);
+  }
+  const source = parsePhysicalKey(key);
+  if (!source) fail(`Malformed gone key: ${key}`);
+  checkFields(value, ["b", "e"], key);
+  if (typeof value.b !== "string" || !value.b) fail(`Invalid gone record: ${key}`);
+  const end = value.e ?? null;
+  if (end !== null && !parsePhysicalKey(end)) fail(`Invalid gone record: ${key}`);
+  out.removals.push({ key, sourceKey: key, source, operationId: null, blockId: value.b, end, sv: [], legacy: true });
+};
+
+export function parseGoneIntents(gone, { strict = false } = {}) {
+  const out = { removals: [], restores: [], copyActive: new Set(), attrs: new Map(), textDeletes: [] };
+  gone.forEach((value, key) => {
+    try {
+      recordOf(value, key, out);
+    } catch (error) {
+      if (strict || !(error instanceof RecoveryError)) throw error;
+    }
+  });
+  return out;
+}
+
+const canonical = (value) => {
+  if (Array.isArray(value)) return value.map(canonical);
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const key of Object.keys(value).sort()) out[key] = canonical(value[key]);
+    return out;
+  }
+  return value;
+};
+
+export const canonicalRevision = (record) => JSON.stringify(canonical(record));
+
+const typeNode = (name) => schema.nodes[name] ?? schema.nodes.paragraph;
+
+const blockOf = (pd, id, overrides = null) => {
+  const map = pd.attrs.get(id);
+  const named = overrides?.get("t");
+  const base = (map && map.get("t")) || "paragraph";
+  const type = typeof named === "string" && schema.nodes[named] ? named : base;
+  const node = typeNode(type);
+  const attrs = {};
+  for (const key of attrKeys(node)) attrs[key] = copy(map && map.has(key) ? map.get(key) : defaultOf(node, key));
+  if (type === "table") Object.assign(attrs, copy(resolveTableFields(pd.tableFields, id, { cols: attrs.cols, rows: attrs.rows })));
+  if (type === "board") Object.assign(attrs, copy(resolveBoardFields(pd.boardFields, id)));
+  if (overrides) for (const [field, value] of overrides) if (field !== "t" && Object.hasOwn(attrs, field)) attrs[field] = copy(value);
+  return { id, type, attrs };
+};
+
+const overridesOf = (fields) => {
+  const out = {};
+  if (!fields) return out;
+  for (const field of [...fields.keys()].sort()) out[field] = copy(fields.get(field));
+  return out;
+};
+
+export const RECOVERED_PREFIX = "recovered:";
+export const recoveredSource = (id) => (typeof id === "string" && id.startsWith(RECOVERED_PREFIX) ? id.slice(RECOVERED_PREFIX.length) : null);
+
+export function recoveredRoot(sourceKey, removals, intents) {
+  const active = new Set(removals.map((removal) => removal.key));
+  let best = null;
+  for (const restore of intents.restores) {
+    if (restore.sourceKey !== sourceKey) continue;
+    const count = restore.covers.reduce((n, key) => n + (active.has(key) ? 1 : 0), 0);
+    if (!best || count > best.count || (count === best.count && compare(restore.key, best.restore.key) < 0)) best = { restore, count };
+  }
+  if (!best) return null;
+  const fields = intents.attrs.get(sourceKey);
+  const named = fields?.get("t");
+  const base = schema.nodes[best.restore.baseline.type] ? best.restore.baseline.type : "paragraph";
+  const type = typeof named === "string" && schema.nodes[named] ? named : base;
+  const node = typeNode(type);
+  const attrs = {};
+  for (const key of attrKeys(node)) {
+    if (fields && fields.has(key)) attrs[key] = copy(fields.get(key));
+    else if (Object.hasOwn(best.restore.baseline.attrs, key)) attrs[key] = copy(best.restore.baseline.attrs[key]);
+    else attrs[key] = copy(defaultOf(node, key));
+  }
+  return { type, attrs, key: best.restore.key };
+}
+
+const rawOf = (attrs) => {
+  const out = {};
+  for (const key of Object.keys(attrs).sort()) out[key] = copy(attrs[key]);
+  return out;
+};
+
+const displaced = (item, seen) => seen.some((vector) => item.clock >= (vector.get(item.client) ?? 0));
+
+const addClock = (spans, clock) => {
+  const last = spans[spans.length - 1];
+  if (last && clock <= last.end) {
+    if (clock === last.end) last.end = clock + 1;
+    return;
+  }
+  spans.push({ start: clock, end: clock + 1 });
+};
+
+const mergeClocks = (clocks) => {
+  const spans = [];
+  for (const clock of [...clocks].sort(compare)) addClock(spans, clock);
+  return spans;
+};
+
+const holdsClock = (spans, clock) => {
+  let lo = 0, hi = spans.length - 1;
+  while (lo <= hi) {
+    const mid = (lo + hi) >> 1;
+    const span = spans[mid];
+    if (clock < span.start) hi = mid - 1;
+    else if (clock >= span.end) lo = mid + 1;
+    else return true;
+  }
+  return false;
+};
+
+const visibleOriginIndex = (flow, walked, index) => {
+  const ranges = createProjectionMap(walked, flow.length).physicalRanges(0, walked.tokens);
+  const clocks = new Map();
+  const collect = (item, from, to) => {
+    for (let offset = from; offset < to; offset++) {
+      const source = index.resolve({ client: item.id.client, clock: item.id.clock + offset });
+      const list = clocks.get(source.client);
+      if (list) list.push(source.clock);
+      else clocks.set(source.client, [source.clock]);
+    }
+  };
+  let at = 0, cursor = 0;
+  for (let item = flow._start; item && cursor < ranges.length; item = item.right) {
+    if (item.deleted || !item.countable) continue;
+    const start = at;
+    at += item.length;
+    const content = item.content;
+    const isText = content instanceof Y.ContentString;
+    if (!isText && !(content instanceof Y.ContentEmbed)) continue;
+    if (!isText && content.embed.b !== undefined) continue;
+    while (cursor < ranges.length && ranges[cursor][1] <= start) cursor++;
+    let range = cursor;
+    while (range < ranges.length && ranges[range][0] < at) {
+      collect(item, Math.max(start, ranges[range][0]) - start, Math.min(at, ranges[range][1]) - start);
+      if (ranges[range][1] >= at) break;
+      range++;
+    }
+    cursor = range;
+  }
+  const spans = new Map();
+  for (const [client, list] of clocks) spans.set(client, mergeClocks(list));
+  return (client, clock) => {
+    const list = spans.get(client);
+    return list ? holdsClock(list, clock) : false;
+  };
+};
+
+const runOf = (index, item, seen, type, visible) => {
+  const source = index.resolve({ client: item.client, clock: item.clock });
+  const marks = item.kind === "text" ? marksAttrs(marksFromAttributes(item.raw, type)) : {};
+  const baseline = !displaced(item, seen);
+  return { client: item.client, clock: item.clock, length: item.length, sourceClient: source.client, sourceClock: source.clock, baseline, displaced: !baseline && !visible(source.client, source.clock), kind: item.kind, text: item.kind === "text" ? item.text : null, marks, raw: rawOf(item.raw) };
+};
+
+const pushRun = (runs, run) => {
+  const previous = runs[runs.length - 1];
+  if (previous && previous.kind === run.kind && previous.baseline === run.baseline && previous.displaced === run.displaced && previous.client === run.client && previous.clock + previous.length === run.clock && previous.sourceClient === run.sourceClient && previous.sourceClock + previous.length === run.sourceClock && sameJson(previous.marks, run.marks) && sameJson(previous.raw, run.raw)) {
+    previous.length += run.length;
+    if (previous.kind === "text") previous.text += run.text;
+    return;
+  }
+  runs.push(run);
+};
+
+const runOut = (run, authorOf) => ({
+  id: physicalKeyOf(run),
+  length: run.length,
+  source: physicalKeyOf({ client: run.sourceClient, clock: run.sourceClock }),
+  baseline: run.baseline,
+  displaced: run.displaced,
+  kind: run.kind,
+  ...(run.kind === "text" ? { text: run.text } : {}),
+  marks: run.marks,
+  raw: run.raw,
+  author: authorOf(run.sourceClient),
+});
+
+function sourceRecord(pd, index, sourceKey, removals, hidden, intents, visible, groups) {
+  const effective = (blockId, marker, overrides = null) => {
+    const boundary = index.boundaryOf(marker);
+    if (!boundary || boundary.blockId !== blockId || !boundary.recoveryOf) return blockOf(pd, blockId, overrides);
+    const root = recoveredRoot(boundary.recoveryOf, groups.get(boundary.recoveryOf) ?? [], intents);
+    const type = typeof overrides?.get("t") === "string" && schema.nodes[overrides.get("t")] ? overrides.get("t") : root?.type ?? "paragraph";
+    const attrs = {};
+    for (const key of attrKeys(typeNode(type))) attrs[key] = copy(overrides?.has(key) ? overrides.get(key) : root && Object.hasOwn(root.attrs, key) ? root.attrs[key] : defaultOf(typeNode(type), key));
+    return { id: blockId, type, attrs };
+  };
+  const authorOf = (client) => {
+    const token = pd.origins.get(authorKey(client));
+    return typeof token === "string" && token ? token : null;
+  };
+  const ordered = [...removals].sort((a, b) => compare(a.key, b.key));
+  const blockId = ordered[0].blockId;
+  const fields = intents.attrs.get(sourceKey);
+  const overrides = overridesOf(fields);
+  const root = effective(blockId, ordered[0].source, fields);
+  const seenByKey = new Map(ordered.map((removal) => [removal.key, new Map(removal.sv)]));
+  const items = new Map();
+  for (const removal of ordered) {
+    const entry = hidden.get(removal.key);
+    if (!entry) continue;
+    const seen = seenByKey.get(removal.key);
+    for (const item of entry.items) {
+      const found = items.get(item.id);
+      if (found) found.vectors.push(seen);
+      else items.set(item.id, { item, vectors: [seen] });
+    }
+  }
+  const stream = [...items.values()].sort((a, b) => a.item.at - b.item.at);
+  const blocks = [{ ...root, author: authorOf(index.resolve(ordered[0].source).client), runs: [] }];
+  let current = blocks[0];
+  for (const entry of stream) {
+    const item = entry.item;
+    if (item.kind === "marker") {
+      if (index.boundaryOf({ client: item.client, clock: item.clock })?.kind === "restore") continue;
+      if (!item.blockId || item.blockId === current.id) continue;
+      const boundary = effective(item.blockId, { client: item.client, clock: item.clock });
+      current = { ...boundary, author: authorOf(index.resolve({ client: item.client, clock: item.clock }).client), runs: [] };
+      blocks.push(current);
+      continue;
+    }
+    if (item.kind === "text") {
+      for (let offset = 0; offset < item.length; offset++) {
+        pushRun(current.runs, runOf(index, { ...item, clock: item.clock + offset, length: 1, text: item.text[offset] }, entry.vectors, current.type, visible));
+      }
+    } else pushRun(current.runs, runOf(index, item, entry.vectors, current.type, visible));
+  }
+  const out = {
+    source: sourceKey,
+    blockId,
+    type: root.type,
+    attrs: root.attrs,
+    author: blocks[0].author,
+    blocks: blocks.map((block) => ({ id: block.id, type: block.type, attrs: block.attrs, author: block.author, runs: block.runs.map((run) => runOut(run, authorOf)) })),
+    removals: ordered.map((removal) => ({ key: removal.key, operationId: removal.operationId, end: removal.end, sv: removal.sv })),
+    restores: intents.restores.filter((restore) => restore.covers.some((cover) => ordered.some((removal) => removal.key === cover))).sort((a, b) => compare(a.key, b.key)).map((restore) => ({ key: restore.key, covers: sortedList(restore.covers) })),
+    copyActive: intents.copyActive.has(sourceKey),
+    overrides,
+    recoverable: blocks.some((block) => block.runs.some((run) => run.displaced)),
+  };
+  return { ...out, revision: canonicalRevision(out) };
+}
+
+export function reduceRecovery(pd, options = {}) {
+  const index = options.index ?? createOriginIndex(pd.origins);
+  try {
+    const walked = options.walked ?? walk(pd, index);
+    const intents = options.intents ?? parseGoneIntents(pd.gone, { strict: options.strict === true });
+    const hidden = new Map();
+    for (const entry of walked.hidden ?? []) hidden.set(entry.key, entry);
+    const groups = new Map();
+    for (const removal of walked.removals ?? intents.removals) {
+      const list = groups.get(removal.sourceKey);
+      if (list) list.push(removal);
+      else groups.set(removal.sourceKey, [removal]);
+    }
+    let visibleIndex = null;
+    const visible = (client, clock) => {
+      if (!visibleIndex) visibleIndex = visibleOriginIndex(pd.flow, walked, index);
+      return visibleIndex(client, clock);
+    };
+    const sources = new Map();
+    for (const [sourceKey, removals] of groups) sources.set(sourceKey, sourceRecord(pd, index, sourceKey, removals, hidden, intents, visible, groups));
+    const list = [...sources.values()].sort((a, b) => {
+      const left = parsePhysicalKey(a.source), right = parsePhysicalKey(b.source);
+      return left.client - right.client || left.clock - right.clock;
+    });
+    return { sources, list, intents };
+  } finally {
+    if (!options.index) index.dispose();
+  }
+}

package/src/page/ybind/seed.js

@@ -0,0 +1,27 @@
+import * as Y from "../../vendor/yjs.vendor.js";
+import { schema } from "../schema.js";
+import { toBase64 } from "../../vendor/yjs.vendor.js";
+import { SEED, attrKeys, defaultOf, createPageDoc } from "./layout.js";
+import { insertTokens } from "./writer.js";
+
+export function seedFrom(pd, blocks) {
+  const tx = (fn) => pd.ydoc.transact(fn, SEED);
+  const toks = [];
+  for (const b of blocks) {
+    const type = b.t ?? "paragraph";
+    const attrs = Object.fromEntries(attrKeys(schema.nodes[type]).map((k) => [k, b.attrs?.[k] ?? defaultOf(schema.nodes[type], k)]));
+    toks.push({ k: "b", id: b.id, t: type, attrs });
+    if (b.text) for (const ch of b.text) toks.push({ k: "c", ch, mk: "", ma: {} });
+  }
+  insertTokens(pd, pd.flow.length, toks, tx);
+}
+
+export function seedValue(blocks) {
+  const doc = new Y.Doc();
+  doc.clientID = 1;
+  const y = {};
+  let n = 0;
+  doc.on("updateV2", (update) => { y[`seed-${String(n++).padStart(4, "0")}`] = toBase64(update); });
+  seedFrom(createPageDoc(doc), blocks);
+  return { v: 1, g: 0, y };
+}

package/src/page/ybind/table.js

@@ -0,0 +1,166 @@
+import { schema } from "../schema.js";
+import { marksOf } from "../inline.js";
+import { ATOM, BREAK, canon, unitsOf } from "../projection.js";
+import { cellText } from "../rich/cell.js";
+import { YDecodeError } from "./provider.js";
+
+export const TABLE_FIELDS = Object.freeze({ row: Object.freeze(["alive", "pos"]), col: Object.freeze(["alive", "name", "kind", "width", "pos"]) });
+const COL_FIELDS = ["name", "kind", "width", "pos"];
+const OPTIONAL = new Set(["kind", "width"]);
+const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const validId = (id) => typeof id === "string" && id.length > 0 && !["__proto__", "constructor", "prototype"].includes(id);
+const fail = (key) => { throw new YDecodeError("unsupported-content", `Unsupported table field: ${key}`); };
+const copy = (value) => (value === null || typeof value !== "object" ? value : JSON.parse(JSON.stringify(value)));
+
+export const tableKey = (tableId, kind, entityId, field) => JSON.stringify([tableId, kind, entityId, field]);
+
+export function validCell(value) {
+  if (typeof value === "string") return true;
+  if (!record(value) || Object.keys(value).sort().join(",") !== "c,m" || typeof value.c !== "string") return false;
+  if (!Array.isArray(value.m) || !value.m.every(Array.isArray)) return false;
+  const units = unitsOf(value.m, value.c.length);
+  if (!units) return false;
+  return units.every((key, i) => {
+    if (typeof key !== "string") return false;
+    if (key.startsWith("@")) return key === BREAK && value.c[i] === ATOM;
+    try { marksOf(schema, key); return true; } catch { return false; }
+  });
+}
+
+const validValue = (field, value) => {
+  if (field === "alive") return typeof value === "boolean";
+  if (field === "width") return value === null || (typeof value === "number" && Number.isFinite(value) && value > 0);
+  if (field === "kind") return value === null || typeof value === "string";
+  return typeof value === "string";
+};
+
+// Peers can each delete a different last column or row; a table must keep one,
+// so the first removed one by position stays until someone edits the table.
+function keepOne(live, dead) {
+  if (Object.keys(live).length) return;
+  const [first] = Object.keys(dead).sort((x, y) => {
+    const px = dead[x].pos ?? "", py = dead[y].pos ?? "";
+    return px !== py ? (px < py ? -1 : 1) : x < y ? -1 : x > y ? 1 : 0;
+  });
+  if (first) live[first] = dead[first];
+}
+
+export function resolveTableFields(fields, blockId = null, seed = null) {
+  const rows = new Map(), cols = new Map(), cells = new Map();
+  for (const [key, value] of fields) {
+    let tuple;
+    try { tuple = JSON.parse(key); } catch { fail(key); }
+    if (!Array.isArray(tuple) || tuple.length !== 4) fail(key);
+    const [owner, kind, entityId, field] = tuple;
+    if (!validId(owner) || !validId(entityId)) fail(key);
+    if (kind === "cell") {
+      if (!validId(field) || !validCell(value)) fail(key);
+    } else if (!Object.hasOwn(TABLE_FIELDS, kind) || !TABLE_FIELDS[kind].includes(field) || !validValue(field, value)) fail(key);
+    if (owner !== blockId) continue;
+    if (kind === "cell") {
+      const row = cells.get(entityId) ?? new Map();
+      row.set(field, value);
+      cells.set(entityId, row);
+      continue;
+    }
+    const bucket = kind === "row" ? rows : cols;
+    const entity = bucket.get(entityId) ?? {};
+    entity[field] = value;
+    bucket.set(entityId, entity);
+  }
+  const outCols = { ...(record(seed?.cols) ? seed.cols : {}) };
+  const outRows = { ...(record(seed?.rows) ? seed.rows : {}) };
+  const deadCols = {}, deadRows = {};
+  for (const [id, over] of cols) {
+    const col = record(outCols[id]) ? { ...outCols[id] } : {};
+    if (!Object.hasOwn(col, "pos")) col.pos = "";
+    if (!Object.hasOwn(col, "name")) col.name = "";
+    for (const field of COL_FIELDS) {
+      if (!Object.hasOwn(over, field)) continue;
+      if (over[field] === null) delete col[field];
+      else col[field] = over[field];
+    }
+    if (over.alive === false || (!Object.hasOwn(outCols, id) && over.alive !== true)) {
+      if (over.alive === false) deadCols[id] = col;
+      delete outCols[id];
+      continue;
+    }
+    outCols[id] = col;
+  }
+  for (const id of new Set([...rows.keys(), ...cells.keys()])) {
+    const over = rows.get(id) ?? {};
+    const row = { pos: "", cells: {}, ...(record(outRows[id]) ? outRows[id] : {}) };
+    if (Object.hasOwn(over, "pos")) row.pos = over.pos;
+    const own = cells.get(id);
+    if (own) row.cells = { ...(record(row.cells) ? row.cells : {}), ...Object.fromEntries([...own].map(([colId, value]) => [colId, copy(value)])) };
+    if (over.alive === false || (!Object.hasOwn(outRows, id) && over.alive !== true)) {
+      if (over.alive === false) deadRows[id] = row;
+      delete outRows[id];
+      continue;
+    }
+    outRows[id] = row;
+  }
+  keepOne(outCols, deadCols);
+  keepOne(outRows, deadRows);
+  return { cols: outCols, rows: outRows };
+}
+
+export function plainTable(table) {
+  const rows = {};
+  for (const [id, row] of Object.entries(table?.rows ?? {})) {
+    rows[id] = { ...row, cells: Object.fromEntries(Object.entries(record(row?.cells) ? row.cells : {}).map(([colId, value]) => [colId, cellText(value)])) };
+  }
+  return { cols: table?.cols ?? {}, rows };
+}
+
+const fieldOf = (entity, field) => entity?.[field] ?? (OPTIONAL.has(field) ? null : "");
+
+export function tableChanges(tableId, fields, seed, before, after) {
+  const out = [];
+  const stored = (key, fallback) => (fields.has(key) ? fields.get(key) : fallback);
+  const push = (key, value) => out.push([key, copy(value)]);
+  const beforeCols = before?.cols ?? {}, afterCols = after?.cols ?? {};
+  const beforeRows = before?.rows ?? {}, afterRows = after?.rows ?? {};
+  for (const id of new Set([...Object.keys(beforeCols), ...Object.keys(afterCols)])) {
+    const old = beforeCols[id], next = afterCols[id];
+    if (!next) {
+      if (old) push(tableKey(tableId, "col", id, "alive"), false);
+      continue;
+    }
+    if (!old || stored(tableKey(tableId, "col", id, "alive"), true) === false) push(tableKey(tableId, "col", id, "alive"), true);
+    for (const field of COL_FIELDS) {
+      const key = tableKey(tableId, "col", id, field);
+      const prior = old ? fieldOf(old, field) : stored(key, fieldOf(seed?.cols?.[id], field));
+      if (canon(prior) !== canon(fieldOf(next, field))) push(key, fieldOf(next, field));
+    }
+  }
+  for (const id of new Set([...Object.keys(beforeRows), ...Object.keys(afterRows)])) {
+    const old = beforeRows[id], next = afterRows[id];
+    if (!next) {
+      if (old) push(tableKey(tableId, "row", id, "alive"), false);
+      continue;
+    }
+    if (!old || stored(tableKey(tableId, "row", id, "alive"), true) === false) push(tableKey(tableId, "row", id, "alive"), true);
+    const posKey = tableKey(tableId, "row", id, "pos");
+    const pos = next.pos ?? "";
+    if (stored(posKey, seed?.rows?.[id]?.pos ?? "") !== pos) push(posKey, pos);
+    const cells = record(next.cells) ? next.cells : {};
+    for (const colId of Object.keys(afterCols)) {
+      const key = tableKey(tableId, "cell", id, colId);
+      const value = cells[colId] ?? "";
+      const prior = old && beforeCols[colId] ? old.cells?.[colId] ?? "" : stored(key, seed?.rows?.[id]?.cells?.[colId] ?? "");
+      if (canon(prior) !== canon(value)) push(key, value);
+    }
+  }
+  return out;
+}
+
+export function tableSeed(pd, id) {
+  const map = pd.attrs.get(id);
+  return { cols: map?.get("cols") ?? {}, rows: map?.get("rows") ?? {} };
+}
+
+export function writeTable(pd, id, before, after) {
+  const seed = tableSeed(pd, id);
+  for (const [key, value] of tableChanges(id, pd.tableFields, seed, before, after)) pd.tableFields.set(key, value);
+}