@panphora/clayjs 1.17.0 → 1.18.1

package/dist/server/core.cjs

@@ -31176,6 +31176,8 @@ module.exports = __toCommonJS(server_core_exports);
 // src/server/rooms/index.js
 var rooms_exports = {};
 __export(rooms_exports, {
+  COMPACTION: () => COMPACTION,
+  COMPACTOR: () => COMPACTOR,
   LIVE_LIMITS: () => LIVE_LIMITS,
   PAGE_FORMAT: () => PAGE_FORMAT,
   PAGE_FORMAT_EXTENSION: () => PAGE_FORMAT_EXTENSION,
@@ -31187,6 +31189,7 @@ __export(rooms_exports, {
   RANGE_LIMIT: () => RANGE_LIMIT,
   RECEIPT_LIMIT: () => RECEIPT_LIMIT,
   REFUSED_MS: () => REFUSED_MS,
+  ROOM_ERROR_STATUS: () => ROOM_ERROR_STATUS,
   applyOp: () => applyOp,
   applyOps: () => applyOps,
   applyTracked: () => applyTracked,
@@ -31203,6 +31206,7 @@ __export(rooms_exports, {
   coalesce: () => coalesce,
   composePage: () => composePage,
   contains: () => contains2,
+  createPageCompactor: () => createPageCompactor,
   createRooms: () => createRooms,
   descendants: () => descendants,
   diffOps: () => diffOps,
@@ -31220,6 +31224,7 @@ __export(rooms_exports, {
   makePageTransition: () => makePageTransition,
   overlaps: () => overlaps,
   pageBaseline: () => pageBaseline,
+  pageCompactionWorkerUrl: () => pageCompactionWorkerUrl,
   pageFormatFloor: () => pageFormatFloor,
   pageLineageLost: () => pageLineageLost,
   pageRev: () => pageRev,
@@ -36588,8 +36593,8 @@ function filterParsed(selector, elements, options) {
   }
   for (let i = 0; i < filteredSelectors.length && (found === null || found === void 0 ? void 0 : found.size) !== elements.length; i++) {
     const filteredSelector = filteredSelectors[i];
-    const missing = found ? elements.filter((e19) => isTag2(e19) && !found.has(e19)) : elements;
-    if (missing.length === 0)
+    const missing2 = found ? elements.filter((e19) => isTag2(e19) && !found.has(e19)) : elements;
+    if (missing2.length === 0)
       break;
     const filtered = filterBySelector(filteredSelector, elements, options);
     if (filtered.length) {
@@ -52343,8 +52348,8 @@ function Aa(r44, e19, t, n, i) {
     let O2 = r44.input.lastSelectionTime > Date.now() - 50 ? r44.input.lastSelectionOrigin : null, I2 = rr(r44, O2);
     if (I2 && !r44.state.selection.eq(I2)) {
       if (B && me && r44.input.lastKeyCode === 13 && Date.now() - 100 < r44.input.lastKeyCodeTime && r44.someProp("handleKeyDown", (xo2) => xo2(r44, Be(13, "Enter")))) return;
-      let H = r44.state.tr.setSelection(I2);
-      O2 == "pointer" ? H.setMeta("pointer", true) : O2 == "key" && H.scrollIntoView(), s && H.setMeta("composition", s), r44.dispatch(H);
+      let H2 = r44.state.tr.setSelection(I2);
+      O2 == "pointer" ? H2.setMeta("pointer", true) : O2 == "key" && H2.scrollIntoView(), s && H2.setMeta("composition", s), r44.dispatch(H2);
     }
     return;
   }
@@ -52386,8 +52391,8 @@ function Aa(r44, e19, t, n, i) {
   let N2 = p.start, re2 = p.endA, De2 = (O2) => {
     let I2 = O2 || r44.state.tr.replace(N2, re2, f.doc.slice(p.start - f.from, p.endB - f.from));
     if (f.sel) {
-      let H = Yi(r44, I2.doc, f.sel);
-      H && !(B && r44.composing && H.empty && (p.start != p.endB || r44.input.lastChromeDelete < Date.now() - 100) && (H.head == N2 || H.head == I2.mapping.map(re2) - 1) || G && H.empty && H.head == N2) && I2.setSelection(H);
+      let H2 = Yi(r44, I2.doc, f.sel);
+      H2 && !(B && r44.composing && H2.empty && (p.start != p.endB || r44.input.lastChromeDelete < Date.now() - 100) && (H2.head == N2 || H2.head == I2.mapping.map(re2) - 1) || G && H2.empty && H2.head == N2) && I2.setSelection(H2);
     }
     return s && I2.setMeta("composition", s), I2.scrollIntoView();
   }, Pt2;
@@ -52400,7 +52405,7 @@ function Aa(r44, e19, t, n, i) {
     Pt2.type == "add" ? O2.addMark(N2, re2, Pt2.mark) : O2.removeMark(N2, re2, Pt2.mark), r44.dispatch(O2);
   } else if (m2.parent.child(m2.index()).isText && m2.index() == g2.index() - (g2.textOffset ? 0 : 1)) {
     let O2 = m2.parent.textBetween(m2.parentOffset, g2.parentOffset), I2 = () => De2(r44.state.tr.insertText(O2, N2, re2));
-    r44.someProp("handleTextInput", (H) => H(r44, N2, re2, O2, I2)) || r44.dispatch(I2());
+    r44.someProp("handleTextInput", (H2) => H2(r44, N2, re2, O2, I2)) || r44.dispatch(I2());
   } else r44.dispatch(De2());
   else r44.dispatch(De2());
 }
@@ -53806,6 +53811,7 @@ function safeHref(raw) {
   if (/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(s)) return `mailto:${s}`;
   return null;
 }
+var safeSrc = (s) => s && /^data:image\/(png|jpeg|gif|webp);/i.test(s) && s.length <= 21e5 ? s : safeHref(s);
 function safeFileHref(raw) {
   if (typeof raw !== "string") return null;
   const href = safeHref(raw);
@@ -53828,7 +53834,15 @@ var schema = new Qr.Schema({
       group: "block",
       content: "inline*",
       defining: true,
-      attrs: { ...block, level: { default: 2 } },
+      attrs: {
+        ...block,
+        level: { default: 2 },
+        pageIcon: { default: null },
+        pageCoverSrc: { default: null },
+        pageCoverAlt: { default: "" },
+        pageCoverX: { default: 50 },
+        pageCoverY: { default: 50 }
+      },
       toDOM: (n) => [`h${n.attrs.level}`, ref(n), 0]
     },
     list_item: {
@@ -53873,8 +53887,8 @@ var schema = new Qr.Schema({
     toggle: {
       group: "block",
       content: "inline*",
-      attrs: { ...block, open: { default: false } },
-      toDOM: (n) => ["div", ref(n, { class: "page-toggle", "data-open": n.attrs.open ? "true" : "false" }), 0]
+      attrs: { ...block, open: { default: false }, level: { default: null } },
+      toDOM: (n) => ["div", ref(n, { class: "page-toggle", "data-open": n.attrs.open ? "true" : "false", ...n.attrs.level ? { "data-level": String(n.attrs.level) } : {} }), 0]
     },
     divider: {
       group: "block",
@@ -53882,6 +53896,14 @@ var schema = new Qr.Schema({
       attrs: block,
       toDOM: (n) => ["hr", ref(n)]
     },
+    // A table of contents holds no headings: its entries are derived from the document
+    // whenever it is drawn, so a rename, a move or a deletion needs no repair here.
+    toc: {
+      group: "block",
+      atom: true,
+      attrs: { ...block, maxLevel: { default: null } },
+      toDOM: (n) => ["div", ref(n, { class: "page-toc", "data-type": "toc", ...n.attrs.maxLevel ? { "data-max-level": String(n.attrs.maxLevel) } : {} })]
+    },
     image: {
       group: "block",
       atom: true,
@@ -54348,13 +54370,15 @@ function ticks(min, max, count) {
   for (let n = Math.ceil(min / step); n <= Math.floor(max / step); n++) out.push(Number((n * step).toPrecision(12)));
   return out.length ? out : [Number(min.toFixed(2)), Number(max.toFixed(2))];
 }
+var missing = (chart, reason) => ({ state: "missing", reason, sourceId: chart.source ?? null, title: chart.title ?? "" });
 function chartModel(chart, table) {
-  if (!table) return { state: "missing", reason: "table" };
+  if (!table) return missing(chart, "table");
   const cols = table.cols ?? [];
   const rows = table.rows ?? [];
   const x3 = cols.find((col) => col.id === chart.x);
-  if (!x3 || !chart.series?.length || chart.series.some((id) => !cols.some((col) => col.id === id))) return { state: "missing", reason: "column" };
-  const series = chart.series.map((id, index2) => {
+  if (!x3 || !chart.series?.length || chart.series.some((id) => !cols.some((col) => col.id === id))) return missing(chart, "column");
+  const plotted = chart.type === "pie" ? chart.series.slice(0, 1) : chart.series;
+  const series = plotted.map((id, index2) => {
     const col = cols.find((item) => item.id === id);
     const points2 = rows.map((row, rowIndex) => ({
       id: `${chart.id}:${row.id}:${id}`,
@@ -54392,8 +54416,60 @@ function chartModel(chart, table) {
     domain: [min, max]
   };
 }
+var PIE = { width: 560, height: 232, cx: 150, cy: 116, radius: 84 };
+var PIE_COLOURS = 6;
+var pieHeight = (rows) => Math.max(PIE.height, 54 + (rows - 1) * 36 + 24);
+function chartCaption(series) {
+  const valid = series.points.filter((point) => point.value !== null);
+  return `${series.name}: ${valid.length ? `${fmt(valid[0].value)} to ${fmt(valid.at(-1).value)}` : "no values"}`;
+}
+function pieSlices(model) {
+  const series = model.series[0];
+  if (!series) return [];
+  const positive = series.points.filter((point) => point.value !== null && point.value > 0);
+  const total = positive.reduce((sum, point) => sum + point.value, 0);
+  if (!total) return [];
+  const points = positive.length <= PIE_COLOURS ? positive : [
+    ...positive.slice(0, PIE_COLOURS - 1),
+    { id: `${positive[0].id.split(":")[0]}:other`, xLabel: "Other", value: positive.slice(PIE_COLOURS - 1).reduce((sum, point) => sum + point.value, 0), highlight: positive.slice(PIE_COLOURS - 1).some((point) => point.highlight) }
+  ];
+  let angle = -Math.PI / 2;
+  return points.map((point, index2) => {
+    const fraction = point.value / total;
+    const slice2 = { point, color: `var(--chart-${index2 % 6 + 1})`, fraction, percent: Math.round(fraction * 100), from: angle, to: angle + fraction * Math.PI * 2 };
+    angle = slice2.to;
+    return slice2;
+  });
+}
+function renderPie(model, slices, width) {
+  const box = pieHeight(slices.length);
+  const height = fmt(width * box / PIE.width);
+  const caption = model.series[0] ? chartCaption(model.series[0]) : "no values";
+  const parts = [`<svg xmlns="http://www.w3.org/2000/svg" role="img" width="${width}" height="${height}" viewBox="0 0 ${PIE.width} ${box}">`, `<title>${esc(model.title)}</title>`, `<desc>${esc(caption)}</desc>`];
+  if (!slices.length) parts.push(`<text x="${PIE.width / 2}" y="${PIE.cy}" text-anchor="middle">No positive values to chart</text>`);
+  slices.forEach((slice2) => {
+    const point = ` data-point="${esc(slice2.point.id)}"${slice2.point.highlight ? ' data-highlight="true"' : ""}`;
+    if (slice2.fraction >= 0.999) {
+      parts.push(`<circle${point} cx="${PIE.cx}" cy="${PIE.cy}" r="${PIE.radius}" fill="${slice2.color}"/>`);
+      return;
+    }
+    const x1 = fmt(PIE.cx + PIE.radius * Math.cos(slice2.from));
+    const y1 = fmt(PIE.cy + PIE.radius * Math.sin(slice2.from));
+    const x22 = fmt(PIE.cx + PIE.radius * Math.cos(slice2.to));
+    const y2 = fmt(PIE.cy + PIE.radius * Math.sin(slice2.to));
+    parts.push(`<path${point} d="M ${PIE.cx} ${PIE.cy} L ${x1} ${y1} A ${PIE.radius} ${PIE.radius} 0 ${slice2.fraction > 0.5 ? 1 : 0} 1 ${x22} ${y2} Z" fill="${slice2.color}" stroke="var(--page-bg)" stroke-width="2"/>`);
+  });
+  slices.forEach((slice2, index2) => {
+    const yy = fmt(54 + index2 * 36);
+    const point = ` data-point="${esc(slice2.point.id)}"${slice2.point.highlight ? ' data-highlight="true"' : ""}`;
+    parts.push(`<g${point}><rect x="290" y="${fmt(54 + index2 * 36 - 10)}" width="11" height="11" fill="${slice2.color}"/><text x="310" y="${yy}">${esc(slice2.point.xLabel)}</text><text x="530" y="${yy}" text-anchor="end">${fmt(slice2.point.value)} (${slice2.percent}%)</text></g>`);
+  });
+  parts.push("</svg>");
+  return parts.join("");
+}
 function renderChartSvg(model, { width = 640, height = 320, narrow = false } = {}) {
   if (model.state === "missing") return `<svg xmlns="http://www.w3.org/2000/svg" role="img" width="${width}" height="80" viewBox="0 0 ${width} 80"><title>Chart source missing</title><text x="12" y="44">Chart source missing</text></svg>`;
+  if (model.type === "pie") return renderPie(model, pieSlices(model), width);
   const margin = { left: 52, right: 72, top: 28, bottom: 48 };
   const plotW = Math.max(1, width - margin.left - margin.right);
   const plotH = Math.max(1, height - margin.top - margin.bottom);
@@ -54402,10 +54478,7 @@ function renderChartSvg(model, { width = 640, height = 320, narrow = false } = {
   const n = model.xLabels.length;
   const x3 = (index2) => margin.left + (n <= 1 ? plotW / 2 : index2 * plotW / (n - 1));
   const parts = [`<svg xmlns="http://www.w3.org/2000/svg" role="img" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">`, `<title>${esc(model.title)}</title>`];
-  const caption = model.series.map((item) => {
-    const valid = item.points.filter((point) => point.value !== null);
-    return `${item.name}: ${valid.length ? `${fmt(valid[0].value)} to ${fmt(valid.at(-1).value)}` : "no values"}`;
-  }).join("; ");
+  const caption = model.series.map(chartCaption).join("; ");
   parts.push(`<desc>${esc(caption)}</desc>`);
   for (const tick of narrow ? model.narrowTicks : model.yTicks) {
     const yy = fmt(y2(tick));
@@ -54474,13 +54547,14 @@ var STRUCTURAL = /* @__PURE__ */ new Set(["id", "t", "parent", "c", "m"]);
 var knownType = (t) => Object.hasOwn(DEFAULTS, t);
 var DEFAULTS = {
   paragraph: { parent: null },
-  heading: { parent: null, level: 2 },
+  heading: { parent: null, level: 2, pageIcon: null, pageCoverSrc: null, pageCoverAlt: "", pageCoverX: 50, pageCoverY: 50 },
   list_item: { parent: null, kind: "bullet", indent: 0, checked: false, owner: null, due: null },
   callout: { parent: null },
   quote: { parent: null },
   code_block: { parent: null, lang: "" },
-  toggle: { parent: null, open: false },
+  toggle: { parent: null, open: false, level: null },
   divider: { parent: null },
+  toc: { parent: null, maxLevel: null },
   image: { parent: null, src: "", alt: "", caption: "", width: null, align: null },
   file: { parent: null, src: "", name: "", size: null, mime: null },
   table: { parent: null, cols: {}, sort: null },
@@ -54490,6 +54564,39 @@ var DEFAULTS = {
   preserved: { parent: null, html: "" }
 };
 var TEXT = /* @__PURE__ */ new Set(["paragraph", "heading", "list_item", "callout", "quote", "code_block", "toggle"]);
+var TOC_LABEL = "Table of contents";
+var TOC_ANCHOR = "page-block-";
+var blockAnchor = (id) => `${TOC_ANCHOR}${b64url(String(id ?? ""))}`;
+var TOC_MAX_LEVEL = 3;
+var tocLevel = (item) => item.t === "heading" ? Math.min(6, Math.max(1, Number.isInteger(item.level) ? item.level : 2)) : item.t === "toggle" && (item.level === 1 || item.level === 2 || item.level === 3) ? item.level : 0;
+var tocTitle = (item) => item.t === "heading" && (item.level ?? 2) === 1 && (item.parent ?? null) === null;
+var tocMax = (value) => Number.isInteger(value) && value >= 1 && value <= 6 ? value : TOC_MAX_LEVEL;
+var tocText = (item) => String(item.c ?? "").replace(/[\s\uFFFC]+/gu, " ").trim() || "Untitled";
+function tocEntries(model, maxLevel = TOC_MAX_LEVEL) {
+  const max = tocMax(maxLevel);
+  const title = model.find(tocTitle) ?? null;
+  const out = [];
+  for (const item of model) {
+    const level3 = tocLevel(item);
+    if (!item.id || !level3 || level3 > max || item === title) continue;
+    out.push({ id: item.id, level: level3, text: tocText(item) });
+  }
+  return out;
+}
+function tocHtml(item, model) {
+  const entries = tocEntries(model, item.maxLevel);
+  const root2 = { level: 0, children: [] };
+  const stack = [root2];
+  for (const entry of entries) {
+    while (stack.length > 1 && stack[stack.length - 1].level >= entry.level) stack.pop();
+    const node = { ...entry, children: [] };
+    stack[stack.length - 1].children.push(node);
+    stack.push(node);
+  }
+  const list = (nodes) => `<ul>${nodes.map((node) => `<li><a href="#${blockAnchor(node.id)}">${escText(node.text)}</a>${node.children.length ? list(node.children) : ""}</li>`).join("")}</ul>`;
+  const level3 = item.maxLevel == null ? "" : ` data-max-level="${escAttr(item.maxLevel)}"`;
+  return `<nav aria-label="${TOC_LABEL}" data-type="toc" data-id="${escAttr(item.id ?? "")}"${level3}>${entries.length ? list(root2.children) : ""}</nav>`;
+}
 var same = (a, b2) => canon(a) === canon(b2);
 function orderedIds(map2) {
   return Object.keys(map2).sort((x3, y2) => {
@@ -54674,6 +54781,7 @@ var omitDefaults = (t, fields) => {
   for (const [k2, v3] of Object.entries(fields)) if (!(k2 in DEFAULTS[t]) || !same(v3, DEFAULTS[t][k2])) out[k2] = v3;
   return out;
 };
+var focal = (v3) => Math.min(100, Math.max(0, Number.isFinite(+v3) && v3 !== null && v3 !== "" ? +v3 : 50));
 var columnWidth = (value) => typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.round(value) : null;
 function cellModel(value) {
   if (value === null || typeof value !== "object" || typeof value.c !== "string") return normalizeText(cellText(value), null).c;
@@ -54712,9 +54820,10 @@ var recordOfItem = (item) => {
   const { t, parent: _p, id: _i3, ...fields } = item;
   return { t, ...fields };
 };
+var VISIBLE = { table: /* @__PURE__ */ new Set(["rows"]) };
 var extrasOfItem = (item) => {
   const out = {};
-  for (const [k2, v3] of Object.entries(item)) if (!STRUCTURAL.has(k2) && !(knownType(item.t) && Object.hasOwn(DEFAULTS[item.t], k2))) out[k2] = v3;
+  for (const [k2, v3] of Object.entries(item)) if (!STRUCTURAL.has(k2) && !VISIBLE[item.t]?.has(k2) && !(knownType(item.t) && Object.hasOwn(DEFAULTS[item.t], k2))) out[k2] = v3;
   return Object.keys(out).length ? envelopeOf(out) : "";
 };
 var extrasOfBlock = (t, b2) => {
@@ -54738,7 +54847,8 @@ function projectOne({ id, b: b2, t, parent: parent2, indent }) {
   for (const k2 of Object.keys(extras)) delete attrs[k2];
   const fields = { ...attrs, parent: parent2 };
   if (t === "list_item") fields.indent = indent;
-  if (t === "heading") fields.level = clampLevel(attrs.level ?? 2);
+  if (t === "heading") Object.assign(fields, { level: clampLevel(attrs.level ?? 2), pageCoverSrc: safeSrc(fields.pageCoverSrc ?? null), pageCoverX: focal(fields.pageCoverX), pageCoverY: focal(fields.pageCoverY) });
+  if (t === "toggle") fields.level = toggleLevel(attrs.level);
   if (t === "image" && fields.width != null) fields.width = widthOf(String(fields.width));
   if (t === "image") fields.align = alignOf(fields.align);
   if (t === "image" && typeof fields.caption === "string") fields.caption = normalizeText(fields.caption, null).c;
@@ -54766,7 +54876,21 @@ function projectOne({ id, b: b2, t, parent: parent2, indent }) {
   }
   return item;
 }
+function knownRecordItem(id, record5, parent2) {
+  const { t } = record5;
+  const malformed = new SyntaxError(`page: an envelope names the known block type ${t}`);
+  if (TEXT.has(t) ? record5.c != null && typeof record5.c !== "string" : record5.c != null || record5.m != null) throw malformed;
+  let item;
+  try {
+    item = projectOne({ id, b: record5, t, parent: parent2, indent: 0 });
+  } catch {
+    throw malformed;
+  }
+  const fields = DEFAULTS[t];
+  return Object.fromEntries(Object.entries(item).filter(([k2]) => k2 === "id" || k2 === "t" || STRUCTURAL.has(k2) || k2 === "rows" || Object.hasOwn(fields, k2)));
+}
 var clampLevel = (l) => Math.min(6, Math.max(1, Number.isInteger(l) ? l : 2));
+var toggleLevel = (l) => l === 1 || l === 2 || l === 3 ? l : null;
 var widthOf = (s) => /^\d+$/.test(s) ? Number(s) : s;
 var alignOf = (a) => a === "left" || a === "right" ? a : null;
 function project(blocks) {
@@ -54828,7 +54952,9 @@ function renderInline(c, m2, marksEnvelopes = true) {
   return html3;
 }
 var inlineOf = (item) => renderInline(item.c ?? "", item.m);
+var titleHtml = (item) => `<header${attr2("data-id", item.id)} data-page-heading="1"${extrasOfItem(item)}>${item.pageCoverSrc ? `<img data-page-cover${attr2("src", item.pageCoverSrc)}${attr2("alt", item.pageCoverAlt ?? "")} style="object-position:${item.pageCoverX ?? 50}% ${item.pageCoverY ?? 50}%">` : ""}${item.pageIcon ? `<span data-page-icon aria-hidden="true">${escText(item.pageIcon)}</span>` : ""}<h1>${inlineOf(item)}</h1></header>`;
 var toolData = (item) => item.artifact || item.rev || item.state && Object.keys(item.state).length ? `<script type="application/json" data-tool>${canon({ artifact: item.artifact ?? null, rev: item.rev ?? null, state: item.state ?? {} }).replace(/</g, "\\u003c")}</script>` : "";
+var headerId = (tableId, colId) => `${tableId}-${colId}`;
 var cellHtml = (cell) => typeof cell === "string" ? escText(cell) : cell && typeof cell === "object" ? renderInline(String(cell.c ?? ""), cell.m) : "";
 var dataAttrs = (obj) => Object.entries(obj).map(([k2, v3]) => attr2(`data-${k2}`, v3)).join("");
 function renderLeaf(item, clean, tables) {
@@ -54857,9 +54983,12 @@ function renderLeaf(item, clean, tables) {
       return `<div${at2} data-type="file"${attr2("data-src", item.src ?? "")}${attr2("data-name", item.name ?? "")}${attr2("data-size", item.size ?? null)}${attr2("data-mime", item.mime ?? null)}><a${attr2("href", href)} rel="noopener noreferrer">${escText(item.name || "file")}</a></div>`;
     }
     case "table": {
-      const head = item.cols.map((c) => `<th${attr2("data-col", c.id)}${attr2("data-kind", c.kind ?? null)}${attr2("data-width", c.width ?? null)}${attr2("style", c.width ? `width:${c.width}px` : null)}>${escText(c.name)}</th>`).join("");
-      const body = item.rows.map((r44) => `<tr${attr2("data-id", r44.id)}>${item.cols.map((c) => `<td>${cellHtml(r44.cells[c.id])}</td>`).join("")}</tr>`).join("\n");
-      return `<table${at2}${attr2("data-sort", item.sort != null ? JSON.stringify(item.sort) : null)}>
+      const head = item.cols.map((c) => {
+        const sorted = item.sort?.col === c.id ? item.sort.dir === "desc" ? "descending" : "ascending" : null;
+        return `<th${attr2("data-col", c.id)}${attr2("id", headerId(item.id, c.id))}${attr2("data-kind", c.kind ?? null)}${attr2("data-width", c.width ?? null)}${attr2("style", c.width ? `width:${c.width}px` : null)} scope="col"${attr2("aria-sort", sorted)}>${escText(c.name)}</th>`;
+      }).join("");
+      const body = item.rows.map((r44) => `<tr${attr2("data-id", r44.id)}>${item.cols.map((c) => `<td${attr2("headers", headerId(item.id, c.id))}>${cellHtml(r44.cells[c.id])}</td>`).join("")}</tr>`).join("\n");
+      return `<table${at2} aria-label="Table"${attr2("data-sort", item.sort != null ? JSON.stringify(item.sort) : null)}>
 <thead><tr>${head}</tr></thead>
 <tbody>
 ${body}
@@ -54911,9 +55040,10 @@ function fragmentCleaner(doc) {
 function renderModel(model, { fallbackOf = () => "", clean = RAW } = {}) {
   const lines = [];
   const tables = new Map(model.filter((item) => item.t === "table").map((item) => [item.id, item]));
+  const title = model.find(tocTitle) ?? null;
   const stack = [null];
   const lists = [];
-  const add2 = (s) => {
+  const add3 = (s) => {
     if (lists.length) lines[lines.length - 1] += s;
     else lines.push(s);
   };
@@ -54928,7 +55058,7 @@ function renderModel(model, { fallbackOf = () => "", clean = RAW } = {}) {
     const parent2 = item.parent ?? null;
     while (stack.length > 1 && stack[stack.length - 1] !== parent2) {
       closeLists();
-      add2("</details>");
+      add3("</details>");
       stack.pop();
     }
     if (item.t !== "list_item") closeLists();
@@ -54936,35 +55066,44 @@ function renderModel(model, { fallbackOf = () => "", clean = RAW } = {}) {
       const d = item.indent ?? 0;
       const tag = item.kind === "ordered" ? "ol" : "ul";
       while (lists.length > d + 1) {
-        add2(`</li></${lists[lists.length - 1]}>`);
+        add3(`</li></${lists[lists.length - 1]}>`);
         lists.pop();
       }
       if (lists.length === d + 1) {
-        add2(lists[d] === tag ? "</li>" : `</li></${lists[d]}>`);
+        add3(lists[d] === tag ? "</li>" : `</li></${lists[d]}>`);
         if (lists[d] !== tag) lists.pop();
       }
       if (lists.length < d + 1) {
-        add2(`<${tag}>`);
+        add3(`<${tag}>`);
         lists.push(tag);
       }
       const box = item.kind === "check" ? `<input type="checkbox" disabled${item.checked ? " checked" : ""}>` : "";
-      add2(`<li${attr2("data-id", item.id)}${attr2("data-owner", item.owner ?? null)}${attr2("data-due", item.due ?? null)}${extrasOfItem(item)}>${box}${inlineOf(item)}`);
+      add3(`<li${attr2("data-id", item.id)}${attr2("data-owner", item.owner ?? null)}${attr2("data-due", item.due ?? null)}${extrasOfItem(item)}>${box}${inlineOf(item)}`);
       continue;
     }
     if (item.t === "toggle") {
-      add2(`<details${attr2("data-id", item.id)}${extrasOfItem(item)}${item.open ? " open" : ""}><summary>${inlineOf(item)}</summary>`);
+      const h = toggleLevel(item.level);
+      add3(`<details${attr2("data-id", item.id)}${extrasOfItem(item)}${item.open ? " open" : ""}>${h ? `<summary><h${h}>${inlineOf(item)}</h${h}></summary>` : `<summary>${inlineOf(item)}</summary>`}`);
       stack.push(item.id);
       continue;
     }
     if (item.t === "tool") {
-      add2(`<section${attr2("data-id", item.id)} data-type="tool">${toolData(item)}${clean.fallback(fallbackOf(item.id))}</section>`);
+      add3(`<section${attr2("data-id", item.id)} data-type="tool">${toolData(item)}${clean.fallback(fallbackOf(item.id))}</section>`);
+      continue;
+    }
+    if (item.t === "toc") {
+      add3(tocHtml(item, model));
+      continue;
+    }
+    if (item === title && (item.pageIcon || item.pageCoverSrc)) {
+      add3(titleHtml(item));
       continue;
     }
-    add2(renderLeaf(item, clean, tables));
+    add3(renderLeaf(item, clean, tables));
   }
   closeLists();
   while (stack.length > 1) {
-    add2("</details>");
+    add3("</details>");
     stack.pop();
   }
   return lines.join("\n");
@@ -55084,7 +55223,11 @@ function parseArticle(article) {
     const P3 = { parent: parent2 };
     const record5 = envelopeAt(el3);
     if (record5 && typeof record5.t === "string") {
-      if (knownType(record5.t) || record5.t === "opaque_block") throw new SyntaxError(`page: an envelope names the known block type ${record5.t}`);
+      if (record5.t === "opaque_block") throw new SyntaxError(`page: an envelope names the known block type ${record5.t}`);
+      if (knownType(record5.t)) {
+        items.push(knownRecordItem(idOf(el3), record5, parent2));
+        return;
+      }
       const { t, ...fields } = record5;
       items.push({ id: idOf(el3), t, parent: parent2, ...fields });
       return;
@@ -55092,6 +55235,13 @@ function parseArticle(article) {
     const onlyImage = tag === "P" && el3.children.length === 1 && el3.children[0].tagName === "IMG" && !el3.textContent.trim();
     if (tag === "P" && !onlyImage) return push(el3, "paragraph", parent2, { ...omitDefaults("paragraph", P3), ...tf2(el3) });
     if (/^H[1-6]$/.test(tag)) return push(el3, "heading", parent2, { ...omitDefaults("heading", { ...P3, level: +tag[1] }), ...tf2(el3) });
+    if (tag === "HEADER" && el3.getAttribute("data-page-heading") === ENVELOPE) {
+      const icon = el3.querySelector(":scope > [data-page-icon]");
+      const cover = el3.querySelector(":scope > img");
+      const [, x3, y2] = /object-position:\s*([-\d.]+)%\s+([-\d.]+)%/.exec(cover?.getAttribute("style") ?? "") ?? [];
+      const cover0 = cover ? { pageCoverSrc: safeSrc(cover.getAttribute("src")), pageCoverAlt: cover.getAttribute("alt") ?? "", pageCoverX: focal(x3), pageCoverY: focal(y2) } : {};
+      return push(el3, "heading", parent2, { ...omitDefaults("heading", { ...P3, level: 1, pageIcon: icon ? icon.textContent : null, ...cover0 }), ...tf2(el3.querySelector(":scope > h1")) });
+    }
     if (tag === "ASIDE") return push(el3, "callout", parent2, { ...omitDefaults("callout", P3), ...tf2(el3) });
     if (tag === "BLOCKQUOTE") return push(el3, "quote", parent2, { ...omitDefaults("quote", P3), ...tf2(el3) });
     if (tag === "PRE") {
@@ -55099,11 +55249,16 @@ function parseArticle(article) {
       return push(el3, "code_block", parent2, { ...omitDefaults("code_block", { ...P3, lang: el3.getAttribute("data-lang") || "" }), c: (code || el3).textContent });
     }
     if (tag === "HR") return push(el3, "divider", parent2, omitDefaults("divider", P3));
+    if (tag === "NAV" && el3.getAttribute("aria-label") === TOC_LABEL) {
+      const maxLevel = +(el3.getAttribute("data-max-level") ?? 0);
+      return push(el3, "toc", parent2, omitDefaults("toc", { ...P3, maxLevel: maxLevel >= 1 && maxLevel <= 6 ? maxLevel : null }));
+    }
     if (tag === "UL" || tag === "OL") return list(el3, parent2, 0);
     if (tag === "DETAILS") {
       const summary = el3.querySelector(":scope > summary");
+      const head = summary?.querySelector(":scope > h1, :scope > h2, :scope > h3");
       const at2 = items.length;
-      push(el3, "toggle", parent2, { ...omitDefaults("toggle", { ...P3, open: el3.hasAttribute("open") }), ...tf2(summary) });
+      push(el3, "toggle", parent2, { ...omitDefaults("toggle", { ...P3, open: el3.hasAttribute("open"), level: head ? Number(head.tagName[1]) : null }), ...tf2(summary) });
       const body = el3.ownerDocument.createElement("div");
       for (const n of [...el3.childNodes]) if (n !== summary) body.appendChild(n.cloneNode(true));
       walk2(body, { ref: at2 });
@@ -55170,9 +55325,9 @@ function parseArticle(article) {
     const columns = [], cards = [];
     for (const div of el3.querySelectorAll(":scope > div[data-col], :scope > div")) {
       const col = div.getAttribute("data-col");
-      const missing = div.hasAttribute("data-missing");
-      const ref2 = missing ? { id: col } : { id: col, name: text3(div.querySelector(":scope > h4")) };
-      if (!missing) columns.push(ref2);
+      const missing2 = div.hasAttribute("data-missing");
+      const ref2 = missing2 ? { id: col } : { id: col, name: text3(div.querySelector(":scope > h4")) };
+      if (!missing2) columns.push(ref2);
       for (const li3 of div.querySelectorAll(":scope > ul > li")) {
         cards.push({ id: li3.getAttribute("data-id"), colRef: ref2, title: text3(li3), ...li3.hasAttribute("data-owner") ? { owner: li3.getAttribute("data-owner") } : {}, ...li3.hasAttribute("data-due") ? { due: li3.getAttribute("data-due") } : {} });
       }
@@ -55667,6 +55822,7 @@ var _e2 = (e19, t, n = 0) => {
     n < e19.length && _e2(e19, t, n + 1);
   }
 };
+var nr2 = (e19) => e19;
 var Se2 = (e19, t) => {
   if (e19 === t) return true;
   if (e19 == null || t == null || e19.constructor !== t.constructor && (e19.constructor || Object) !== (t.constructor || Object)) return false;
@@ -55733,13 +55889,24 @@ var ys2 = ws2("production");
 var Do2 = Gt2 && ms2(process.env.FORCE_COLOR, ["true", "1", "2"]);
 var xs2 = Do2 || !sr2("--no-colors") && !ws2("no-color") && (!Gt2 || process.stdout.isTTY) && (!Gt2 || sr2("--color") || Ee2("COLORTERM") !== null || (Ee2("TERM") || "").includes("color"));
 var bs2 = (e19) => new Uint8Array(e19);
+var To2 = (e19) => {
+  let t = "";
+  for (let n = 0; n < e19.byteLength; n++) t += ge2(e19[n]);
+  return btoa(t);
+};
+var vo2 = (e19) => Buffer.from(e19.buffer, e19.byteOffset, e19.byteLength).toString("base64");
 var Vo2 = (e19) => {
   let t = atob(e19), n = bs2(t.length);
   for (let r44 = 0; r44 < t.length; r44++) n[r44] = t.charCodeAt(r44);
   return n;
 };
 var Oo2 = (e19) => new Uint8Array(Buffer.from(e19, "base64"));
+var No2 = en2 ? To2 : vo2;
 var Lo2 = en2 ? Vo2 : Oo2;
+var ks2 = (e19) => {
+  let t = bs2(e19.byteLength);
+  return t.set(e19), t;
+};
 var ir2 = class {
   constructor(t, n) {
     this.left = t, this.right = n;
@@ -56372,6 +56539,44 @@ var At2 = class {
     return w2(this.restDecoder);
   }
 };
+var H = class extends At2 {
+  readLeftID() {
+    return m(w2(this.restDecoder), w2(this.restDecoder));
+  }
+  readRightID() {
+    return m(w2(this.restDecoder), w2(this.restDecoder));
+  }
+  readClient() {
+    return w2(this.restDecoder);
+  }
+  readInfo() {
+    return St2(this.restDecoder);
+  }
+  readString() {
+    return ht2(this.restDecoder);
+  }
+  readParentInfo() {
+    return w2(this.restDecoder) === 1;
+  }
+  readTypeRef() {
+    return w2(this.restDecoder);
+  }
+  readLen() {
+    return w2(this.restDecoder);
+  }
+  readAny() {
+    return Ft2(this.restDecoder);
+  }
+  readBuf() {
+    return ks2(F2(this.restDecoder));
+  }
+  readJSON() {
+    return JSON.parse(ht2(this.restDecoder));
+  }
+  readKey() {
+    return ht2(this.restDecoder);
+  }
+};
 var Cn2 = class {
   constructor(t) {
     this.dsCurrVal = 0, this.restDecoder = t;
@@ -56680,6 +56885,19 @@ var Fr2 = (e19, t, n, r44 = j2) => {
   let s = V2(t);
   ai2(s, e19, n, new r44(s));
 };
+var Ac = (e19, t, n = /* @__PURE__ */ new Map()) => {
+  $r2(e19, t.store, n), tt2(e19, ci2(t.store));
+};
+var Ic = (e19, t = new Uint8Array([0]), n = new X2()) => {
+  let r44 = ui2(t);
+  Ac(n, e19, r44);
+  let s = [n.toUint8Array()];
+  if (e19.store.pendingDs && s.push(e19.store.pendingDs), e19.store.pendingStructs && s.push(bi2(e19.store.pendingStructs.update, t)), s.length > 1) {
+    if (n.constructor === ct2) return Gc(s.map((i, o) => o === 0 ? i : Xc(i)));
+    if (n.constructor === X2) return Tn2(s);
+  }
+  return s[0];
+};
 var hi2 = (e19) => {
   let t = /* @__PURE__ */ new Map(), n = w2(e19.restDecoder);
   for (let r44 = 0; r44 < n; r44++) {
@@ -56930,11 +57148,17 @@ var et2 = class {
     return this.curr;
   }
 };
+var qc = (e19, t = j2) => {
+  let n = [], r44 = new t(V2(e19)), s = new et2(r44, false);
+  for (let i = s.curr; i !== null; i = s.next()) n.push(i);
+  return { structs: n, ds: ot2(r44) };
+};
 var Le2 = class {
   constructor(t) {
     this.currClient = 0, this.startClock = 0, this.written = 0, this.encoder = t, this.clientStructs = [];
   }
 };
+var Gc = (e19) => Tn2(e19, H, ct2);
 var zc = (e19, t = ee2, n = j2) => {
   let r44 = new t(), s = new et2(new n(V2(e19)), false), i = s.curr;
   if (i !== null) {
@@ -56989,6 +57213,21 @@ var Tn2 = (e19, t = j2, n = X2) => {
   let l = r44.map((a) => ot2(a)), h = te2(l);
   return tt2(o, h), o.toUint8Array();
 };
+var bi2 = (e19, t, n = j2, r44 = X2) => {
+  let s = ui2(t), i = new r44(), o = new Le2(i), c = new n(V2(e19)), l = new et2(c, false);
+  for (; l.curr; ) {
+    let a = l.curr, u = a.id.client, d = s.get(u) || 0;
+    if (l.curr.constructor === N) {
+      l.next();
+      continue;
+    }
+    if (a.id.clock + a.length > d) for (dt2(o, a, it2(d - a.id.clock, 0)), l.next(); l.curr && l.curr.id.client === u; ) dt2(o, l.curr, 0), l.next();
+    else for (; l.curr && l.curr.id.client === u && l.curr.id.clock + l.curr.length <= d; ) l.next();
+  }
+  qr2(o);
+  let h = ot2(c);
+  return tt2(i, h), i.toUint8Array();
+};
 var ki2 = (e19) => {
   e19.written > 0 && (e19.clientStructs.push({ written: e19.written, restEncoder: q2(e19.encoder.restEncoder) }), e19.encoder.restEncoder = kt2(), e19.written = 0);
 };
@@ -57004,6 +57243,14 @@ var qr2 = (e19) => {
     g(t, r44.written), Rt2(t, r44.restEncoder);
   }
 };
+var Bn2 = (e19, t, n, r44) => {
+  let s = new n(V2(e19)), i = new et2(s, false), o = new r44(), c = new Le2(o);
+  for (let h = i.curr; h !== null; h = i.next()) dt2(c, t(h), 0);
+  qr2(c);
+  let l = ot2(s);
+  return tt2(o, l), o.toUint8Array();
+};
+var Xc = (e19) => Bn2(e19, nr2, j2, ct2);
 var ni2 = "You must not compute changes after the event-handler fired.";
 var ne2 = class {
   constructor(t, n) {
@@ -58735,9 +58982,14 @@ ji2[qi2] = true;
 var NET = "page-net";
 var PAGE_ROOTS = Object.freeze(["flow", "attrs", "gone", "boardFields", "tableFields", "origins"]);
 var SKIP = /* @__PURE__ */ new Set(["id", "pos"]);
-var attrKeys = (type) => [...Object.keys(type.spec.attrs || {}).filter((k2) => !SKIP.has(k2)), ...type.name === "table" ? ["rows"] : []];
+var KEYS = /* @__PURE__ */ new WeakMap();
+var attrKeys = (type) => {
+  let keys = KEYS.get(type);
+  if (!keys) KEYS.set(type, keys = Object.freeze([...Object.keys(type.spec.attrs || {}).filter((k2) => !SKIP.has(k2)), ...type.name === "table" ? ["rows"] : []]));
+  return keys;
+};
 var defaultOf = (type, k2) => type.name === "table" && k2 === "rows" ? {} : type.spec.attrs[k2].default;
-var sameJson = (a, b2) => JSON.stringify(a) === JSON.stringify(b2);
+var sameJson = (a, b2) => a === b2 || JSON.stringify(a) === JSON.stringify(b2);
 var idKey = (id) => `${id.client}.${id.clock}`;
 var parseKey = (k2) => {
   const i = k2.indexOf(".");
@@ -58774,6 +59026,16 @@ var boundaryRecord = (value) => {
   return value.recoveryOf === void 0 ? { blockId: value.blockId, kind: value.kind } : { blockId: value.blockId, kind: value.kind, recoveryOf: value.recoveryOf };
 };
 var sameBoundary = (a, b2) => a.blockId === b2.blockId && a.kind === b2.kind && a.recoveryOf === b2.recoveryOf;
+var markerKey = (key) => {
+  let parts;
+  try {
+    parts = JSON.parse(key);
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(parts) || parts.length !== 3 || parts[0] !== "boundary" && parts[0] !== "alias") return null;
+  return isClock(parts[1]) && isClock(parts[2]) ? parts : null;
+};
 var recordKey = (key) => {
   if (typeof key !== "string" || key.charCodeAt(0) !== 91) return null;
   let parts;
@@ -58789,6 +59051,7 @@ var recordKey = (key) => {
 function createOriginIndex(origins) {
   const spans = /* @__PURE__ */ new Map();
   const aliases2 = /* @__PURE__ */ new Map();
+  const aliasClocks = /* @__PURE__ */ new Map();
   const boundaries = /* @__PURE__ */ new Map();
   const lower = (list, clock) => {
     let lo3 = 0, hi3 = list.length;
@@ -58799,13 +59062,61 @@ function createOriginIndex(origins) {
     }
     return lo3;
   };
+  const lowerClock = (list, clock) => {
+    let lo3 = 0, hi3 = list.length;
+    while (lo3 < hi3) {
+      const mid = lo3 + hi3 >> 1;
+      if (list[mid] < clock) lo3 = mid + 1;
+      else hi3 = mid;
+    }
+    return lo3;
+  };
+  const markAlias = (client, clock, present) => {
+    const list = aliasClocks.get(client) ?? [];
+    const at2 = lowerClock(list, clock);
+    const there = list[at2] === clock;
+    if (present && !there) list.splice(at2, 0, clock);
+    else if (!present && there) list.splice(at2, 1);
+    if (list.length) aliasClocks.set(client, list);
+    else aliasClocks.delete(client);
+  };
+  const markerRecords = [];
+  const markerEntries = /* @__PURE__ */ new Map();
+  const markerCounts = /* @__PURE__ */ new Map();
+  const markerClocks = /* @__PURE__ */ new Map();
+  const trackMarker = (key, live) => {
+    let entry = markerEntries.get(key);
+    if (entry === void 0) {
+      const parts = markerKey(key);
+      entry = parts ? { kind: parts[0], client: parts[1], clock: parts[2], live: false } : null;
+      markerEntries.set(key, entry);
+      if (entry) markerRecords.push(entry);
+    }
+    if (!entry || entry.live === live) return;
+    entry.live = live;
+    const counts = markerCounts.get(entry.client) ?? markerCounts.set(entry.client, /* @__PURE__ */ new Map()).get(entry.client);
+    const list = markerClocks.get(entry.client) ?? markerClocks.set(entry.client, []).get(entry.client);
+    const n = (counts.get(entry.clock) ?? 0) + (live ? 1 : -1);
+    if (n) counts.set(entry.clock, n);
+    else counts.delete(entry.clock);
+    const at2 = lowerClock(list, entry.clock);
+    if (live && n === 1) list.splice(at2, 0, entry.clock);
+    else if (!live && n === 0) list.splice(at2, 1);
+    if (!list.length) {
+      markerClocks.delete(entry.client);
+      markerCounts.delete(entry.client);
+    }
+  };
   const apply2 = (key, value) => {
+    trackMarker(key, value !== void 0);
     const parts = recordKey(key);
     if (!parts) return;
     const [kind, client, clock] = parts;
     if (kind === "alias") {
-      if (value && isClock(value.sourceClient) && isClock(value.sourceClock)) aliases2.set(idKey2(client, clock), { client: value.sourceClient, clock: value.sourceClock });
+      const valid = Boolean(value && isClock(value.sourceClient) && isClock(value.sourceClock));
+      if (valid) aliases2.set(idKey2(client, clock), { client: value.sourceClient, clock: value.sourceClock });
       else aliases2.delete(idKey2(client, clock));
+      markAlias(client, clock, valid);
       return;
     }
     if (kind === "boundary") {
@@ -58823,13 +59134,17 @@ function createOriginIndex(origins) {
     if (list.length) spans.set(client, list);
     else spans.delete(client);
   };
-  for (const [key, value] of origins) apply2(key, value);
+  for (const key of origins._map.keys()) apply2(key, origins.get(key));
   const observer = (event) => {
     for (const key of event.keysChanged) apply2(key, origins.get(key));
   };
   origins.observe(observer);
+  const hasAlias = (client, clock) => {
+    const list = aliasClocks.get(client);
+    return list !== void 0 && list[lowerClock(list, clock)] === clock;
+  };
   const resolve = (id) => {
-    const alias = aliases2.get(idKey2(id.client, id.clock));
+    const alias = hasAlias(id.client, id.clock) ? aliases2.get(idKey2(id.client, id.clock)) : void 0;
     if (alias) return { client: alias.client, clock: alias.clock };
     const list = spans.get(id.client);
     if (!list) return { client: id.client, clock: id.clock };
@@ -58847,8 +59162,44 @@ function createOriginIndex(origins) {
     if (offset >= record5.length) return { client: id.client, clock: id.clock };
     return { client: record5.sourceClient, clock: record5.sourceClock + offset };
   };
+  const resolveRange = (client, clock, length) => {
+    const out = [];
+    const push = (sourceClient, sourceClock, size) => {
+      const last2 = out[out.length - 1];
+      if (last2 && last2.client === sourceClient && last2.clock + last2.length === sourceClock) last2.length += size;
+      else out.push({ client: sourceClient, clock: sourceClock, length: size });
+    };
+    const list = spans.get(client) ?? [];
+    const marks = aliasClocks.get(client) ?? [];
+    const end2 = clock + length;
+    let s = lower(list, clock + 1) - 1, a = lowerClock(marks, clock), at2 = clock;
+    while (at2 < end2) {
+      if (a < marks.length && marks[a] === at2) {
+        const target = aliases2.get(idKey2(client, at2));
+        push(target.client, target.clock, 1);
+        at2 += 1;
+        a += 1;
+      } else {
+        let stop = end2;
+        if (a < marks.length && marks[a] < stop) stop = marks[a];
+        if (s + 1 < list.length && list[s + 1].clock < stop) stop = list[s + 1].clock;
+        const span2 = s >= 0 ? list[s] : null;
+        if (span2 && at2 < span2.clock + span2.length) {
+          stop = Math.min(stop, span2.clock + span2.length);
+          push(span2.sourceClient, span2.sourceClock + at2 - span2.clock, stop - at2);
+        } else push(client, at2, stop - at2);
+        at2 = stop;
+      }
+      while (s + 1 < list.length && list[s + 1].clock <= at2) s += 1;
+    }
+    return out;
+  };
   const boundaryOf = (id) => {
     if (!id || !isClock(id.client) || !isClock(id.clock)) return null;
+    if (!hasAlias(id.client, id.clock)) {
+      const record6 = boundaries.get(idKey2(id.client, id.clock));
+      return record6 ? { ...record6 } : null;
+    }
     let key = idKey2(id.client, id.clock);
     const seen = /* @__PURE__ */ new Set();
     while (!seen.has(key)) {
@@ -58917,13 +59268,19 @@ function createOriginIndex(origins) {
     const previous = boundaryRecord(existing);
     if (!previous || !sameBoundary(previous, record5)) throw conflicting(key);
   };
+  const markers = () => {
+    for (const t of origins.doc?._transactionCleanups ?? []) if (t.changed.has(origins)) return null;
+    return { records: markerRecords, clocks: markerClocks };
+  };
   return {
     origins,
     resolve,
+    resolveRange,
     recordSpans,
     recordAlias,
     recordBoundary,
     boundaryOf,
+    markers,
     get size() {
       return origins.size;
     },
@@ -58935,7 +59292,13 @@ function createOriginIndex(origins) {
 
 // src/page/ybind/parts.js
 var PART_KEY = /^(.+)\.(\d+)\.(\d+)$/;
-var BASE64 = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}(?:==)?|[A-Za-z0-9+/]{3}=?)?$/;
+var NOT_BASE64 = /[^A-Za-z0-9+/]/;
+function isBase64(text4) {
+  const pad = text4.endsWith("==") ? 2 : text4.endsWith("=") ? 1 : 0;
+  const body = text4.length - pad;
+  if (NOT_BASE64.test(pad ? text4.slice(0, body) : text4)) return false;
+  return pad ? body % 4 + pad === 4 : body % 4 !== 1;
+}
 function entriesOf2(y2) {
   const whole = [];
   const parts = /* @__PURE__ */ new Map();
@@ -58957,6 +59320,75 @@ function entriesOf2(y2) {
   return whole;
 }
 
+// src/page/ybind/containment.js
+function merged(map2) {
+  for (const [client, list] of map2) {
+    list.sort((a, b2) => a[0] - b2[0]);
+    const out = [];
+    for (const range of list) {
+      const last2 = out[out.length - 1];
+      if (last2 && range[0] <= last2[1]) {
+        if (range[1] > last2[1]) last2[1] = range[1];
+      } else out.push([range[0], range[1]]);
+    }
+    map2.set(client, out);
+  }
+  return map2;
+}
+var add2 = (map2, client, from, to3) => {
+  if (to3 <= from) return;
+  const list = map2.get(client);
+  if (list) list.push([from, to3]);
+  else map2.set(client, [[from, to3]]);
+};
+function rangesOf(update2) {
+  const { structs, ds: ds3 } = qc(update2);
+  const items = /* @__PURE__ */ new Map();
+  for (const struct of structs) if (!(struct instanceof N)) add2(items, struct.id.client, struct.id.clock, struct.id.clock + struct.length);
+  const deletes = /* @__PURE__ */ new Map();
+  for (const [client, list] of ds3.clients) for (const { clock, len } of list) add2(deletes, client, clock, clock + len);
+  return { items: merged(items), deletes: merged(deletes) };
+}
+function unite(list) {
+  if (list.length === 1) return list[0];
+  const items = /* @__PURE__ */ new Map();
+  const deletes = /* @__PURE__ */ new Map();
+  for (const ranges of list) {
+    for (const [client, spans] of ranges.items) for (const [from, to3] of spans) add2(items, client, from, to3);
+    for (const [client, spans] of ranges.deletes) for (const [from, to3] of spans) add2(deletes, client, from, to3);
+  }
+  return { items: merged(items), deletes: merged(deletes) };
+}
+function inside(spans, from, to3) {
+  if (!spans) return false;
+  let lo3 = 0, hi3 = spans.length - 1;
+  while (lo3 <= hi3) {
+    const mid = lo3 + hi3 >> 1;
+    const span2 = spans[mid];
+    if (from < span2[0]) hi3 = mid - 1;
+    else if (from >= span2[1]) lo3 = mid + 1;
+    else return to3 <= span2[1];
+  }
+  return false;
+}
+function within(state, ranges) {
+  if (state.complete === false) return false;
+  for (const [client, spans] of ranges.items) for (const [from, to3] of spans) if (!inside(state.items.get(client), from, to3)) return false;
+  for (const [client, spans] of ranges.deletes) for (const [from, to3] of spans) if (!inside(state.deletes.get(client), from, to3)) return false;
+  return true;
+}
+function docRanges(doc) {
+  if (doc.store.pendingStructs || doc.store.pendingDs) return { complete: false };
+  const items = /* @__PURE__ */ new Map();
+  for (const [client, structs] of doc.store.clients) {
+    const last2 = structs[structs.length - 1];
+    add2(items, client, 0, last2.id.clock + last2.length);
+  }
+  const deletes = /* @__PURE__ */ new Map();
+  for (const [client, list] of ci2(doc.store).clients) for (const { clock, len } of list) add2(deletes, client, clock, clock + len);
+  return { complete: true, items, deletes: merged(deletes) };
+}
+
 // src/page/ybind/recovery-proof.js
 var encoder = typeof TextEncoder === "function" ? new TextEncoder() : null;
 
@@ -59006,7 +59438,7 @@ function docFromValue(value, { strict = false } = {}) {
   try {
     for (const [key, value2] of entries) {
       const text4 = strict ? value2.replace(/[\t\n\f\r ]/g, "") : value2;
-      if (strict && !BASE64.test(text4)) throw new YDecodeError("invalid-update", `Invalid base64 in Yjs update: ${key}`);
+      if (strict && !isBase64(text4)) throw new YDecodeError("invalid-update", `Invalid base64 in Yjs update: ${key}`);
       Fr2(d, dec(text4), NET);
     }
     if (strict && (d.store.pendingStructs || d.store.pendingDs)) {
@@ -59061,8 +59493,8 @@ function resolveBoardFields(fields, blockId = null) {
   const columns = pick(groups, "column", columnOf, true);
   const cards = pick(groups, "card", cardOf, true);
   const columnIds = orderedIds(columns);
-  const missing = [...new Set(Object.values(cards).map((card) => card.col))].filter((id) => !Object.hasOwn(columns, id)).sort();
-  const cardIds = [...columnIds, ...missing].flatMap((columnId) => orderedIds(Object.fromEntries(Object.entries(cards).filter(([, card]) => card.col === columnId))));
+  const missing2 = [...new Set(Object.values(cards).map((card) => card.col))].filter((id) => !Object.hasOwn(columns, id)).sort();
+  const cardIds = [...columnIds, ...missing2].flatMap((columnId) => orderedIds(Object.fromEntries(Object.entries(cards).filter(([, card]) => card.col === columnId))));
   return {
     columns: Object.fromEntries(columnIds.map((id) => [id, columns[id]])),
     cards: Object.fromEntries(cardIds.map((id) => [id, cards[id]]))
@@ -59109,9 +59541,75 @@ function keepOne(live, dead) {
   });
   if (first2) live[first2] = dead[first2];
 }
+function tableFieldOwner(key, value) {
+  let tuple;
+  try {
+    tuple = JSON.parse(key);
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(tuple) || tuple.length !== 4) return null;
+  const [owner, kind, entityId, field] = tuple;
+  if (!validId2(owner) || !validId2(entityId)) return null;
+  if (kind === "cell") return validId2(field) && validCell(value) ? owner : null;
+  return Object.hasOwn(TABLE_FIELDS, kind) && TABLE_FIELDS[kind].includes(field) && validValue(field, value) ? owner : null;
+}
+var fieldIndexes = /* @__PURE__ */ new WeakMap();
+var fieldIndexOf = (fields) => {
+  const known = fieldIndexes.get(fields);
+  if (known) return known;
+  const entries = /* @__PURE__ */ new Map(), byOwner = /* @__PURE__ */ new Map(), invalid = /* @__PURE__ */ new Set();
+  const apply2 = (key) => {
+    let entry = entries.get(key);
+    if (!entry) {
+      let tuple = null;
+      try {
+        tuple = JSON.parse(key);
+      } catch {
+        tuple = null;
+      }
+      const owner = Array.isArray(tuple) && tuple.length === 4 && validId2(tuple[0]) ? tuple[0] : null;
+      entry = { key, tuple, live: false, value: void 0 };
+      entries.set(key, entry);
+      if (owner !== null) (byOwner.get(owner) ?? byOwner.set(owner, []).get(owner)).push(entry);
+    }
+    entry.live = fields.has(key);
+    entry.value = entry.live ? fields.get(key) : void 0;
+    if (entry.live && tableFieldOwner(key, entry.value) === null) invalid.add(key);
+    else invalid.delete(key);
+  };
+  for (const key of fields._map.keys()) apply2(key);
+  fields.observe((event) => {
+    for (const key of event.keysChanged) apply2(key);
+  });
+  const index2 = {
+    owned(blockId) {
+      for (const t of fields.doc._transactionCleanups) for (const key of t.changed.get(fields) ?? []) apply2(key);
+      return invalid.size ? null : byOwner.get(blockId) ?? [];
+    }
+  };
+  fieldIndexes.set(fields, index2);
+  return index2;
+};
+var ownedFields = (fields, blockId) => blockId !== null && fields instanceof se2 && fields.doc ? fieldIndexOf(fields).owned(blockId) : null;
 function resolveTableFields(fields, blockId = null, seed = null) {
   const rows = /* @__PURE__ */ new Map(), cols = /* @__PURE__ */ new Map(), cells = /* @__PURE__ */ new Map();
-  for (const [key, value] of fields) {
+  const take = (kind, entityId, field, value) => {
+    if (kind === "cell") {
+      const row = cells.get(entityId) ?? /* @__PURE__ */ new Map();
+      row.set(field, value);
+      cells.set(entityId, row);
+      return;
+    }
+    const bucket = kind === "row" ? rows : cols;
+    const entity = bucket.get(entityId) ?? {};
+    entity[field] = value;
+    bucket.set(entityId, entity);
+  };
+  const owned = ownedFields(fields, blockId);
+  if (owned) {
+    for (const entry of owned) if (entry.live) take(entry.tuple[1], entry.tuple[2], entry.tuple[3], entry.value);
+  } else for (const [key, value] of fields) {
     let tuple;
     try {
       tuple = JSON.parse(key);
@@ -59125,16 +59623,7 @@ function resolveTableFields(fields, blockId = null, seed = null) {
       if (!validId2(field) || !validCell(value)) fail2(key);
     } else if (!Object.hasOwn(TABLE_FIELDS, kind) || !TABLE_FIELDS[kind].includes(field) || !validValue(field, value)) fail2(key);
     if (owner !== blockId) continue;
-    if (kind === "cell") {
-      const row = cells.get(entityId) ?? /* @__PURE__ */ 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);
+    take(kind, entityId, field, value);
   }
   const outCols = { ...record2(seed?.cols) ? seed.cols : {} };
   const outRows = { ...record2(seed?.rows) ? seed.rows : {} };
@@ -59190,7 +59679,7 @@ function marksFromAttributes(a, blockType) {
   const marks = [];
   let unknown = null;
   for (const [n, v3] of best) {
-    if (schema.marks[n] && (!NATIVE_NAMES.has(n) || nativeAttrs(n, v3))) marks.push(schema.marks[n].create(v3 === true ? null : v3));
+    if (schema.marks[n] && (!NATIVE_NAMES.has(n) || nativeAttrs(n, v3 === true ? {} : v3))) marks.push(schema.marks[n].create(v3 === true ? null : v3));
     else (unknown ??= {})[n] = v3;
   }
   if (unknown) {
@@ -59327,15 +59816,112 @@ var recordOf2 = (value, key, out) => {
   if (end2 !== null && !parsePhysicalKey(end2)) fail3(`Invalid gone record: ${key}`);
   out.removals.push({ key, sourceKey: key, source, operationId: null, blockId: value.b, end: end2, sv: [], legacy: true });
 };
-function parseGoneIntents(gone, { strict = false } = {}) {
-  const out = { removals: [], restores: [], copyActive: /* @__PURE__ */ new Set(), attrs: /* @__PURE__ */ new Map(), textDeletes: [] };
-  gone.forEach((value, key) => {
-    try {
-      recordOf2(value, key, out);
-    } catch (error) {
-      if (strict || !(error instanceof RecoveryError)) throw error;
+var emptyIntents = () => ({ removals: [], restores: [], copyActive: /* @__PURE__ */ new Set(), attrs: /* @__PURE__ */ new Map(), textDeletes: [] });
+var frozen = (value) => {
+  if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
+    for (const key of Object.keys(value)) frozen(value[key]);
+    Object.freeze(value);
+  }
+  return value;
+};
+var parsedRecord = (value, key) => {
+  const out = emptyIntents();
+  try {
+    recordOf2(value, key, out);
+  } catch (error) {
+    if (!(error instanceof RecoveryError)) throw error;
+    return null;
+  }
+  for (const list of [out.removals, out.restores, out.textDeletes]) for (const record5 of list) frozen(record5);
+  for (const fields of out.attrs.values()) for (const fieldValue of fields.values()) frozen(fieldValue);
+  return out;
+};
+var parsedGone = /* @__PURE__ */ new WeakMap();
+var foldRecord = (out, record5) => {
+  for (const removal of record5.removals) out.removals.push(removal);
+  for (const restore of record5.restores) out.restores.push(restore);
+  for (const textDelete of record5.textDeletes) out.textDeletes.push(textDelete);
+  for (const sourceKey of record5.copyActive) out.copyActive.add(sourceKey);
+  for (const [sourceKey, fields] of record5.attrs) {
+    const into = out.attrs.get(sourceKey) ?? /* @__PURE__ */ new Map();
+    for (const [field, fieldValue] of fields) into.set(field, fieldValue);
+    out.attrs.set(sourceKey, into);
+  }
+};
+var goneIndexes = /* @__PURE__ */ new WeakMap();
+var goneIndexOf = (gone) => {
+  const known = goneIndexes.get(gone);
+  if (known) return known;
+  const entries = /* @__PURE__ */ new Map();
+  let totals = null;
+  let added = [];
+  const update2 = (key) => {
+    const live = gone.has(key);
+    const value = live ? gone.get(key) : void 0;
+    const entry = entries.get(key);
+    if (entry && entry.live === live && entry.value === value) return;
+    const record5 = live ? parsedRecord(value, key) : null;
+    if (!entry) {
+      const next2 = { live, value, record: record5 };
+      entries.set(key, next2);
+      if (live && record5 && totals) added.push(record5);
+      return;
+    }
+    entry.live = live;
+    entry.value = value;
+    entry.record = record5;
+    totals = null;
+  };
+  for (const key of gone._map.keys()) update2(key);
+  gone.observe((event) => {
+    for (const key of event.keysChanged) update2(key);
+  });
+  const index2 = {
+    intents() {
+      for (const t of gone.doc._transactionCleanups) for (const key of t.changed.get(gone) ?? []) update2(key);
+      if (!totals) {
+        totals = emptyIntents();
+        for (const entry of entries.values()) if (entry.record) foldRecord(totals, entry.record);
+        added = [];
+      } else if (added.length) {
+        for (const record5 of added) foldRecord(totals, record5);
+        added = [];
+      }
+      return {
+        removals: totals.removals.slice(),
+        restores: totals.restores.slice(),
+        copyActive: new Set(totals.copyActive),
+        attrs: new Map([...totals.attrs].map(([sourceKey, fields]) => [sourceKey, new Map(fields)])),
+        textDeletes: totals.textDeletes.slice()
+      };
     }
+  };
+  goneIndexes.set(gone, index2);
+  return index2;
+};
+function parseGoneIntents(gone, { strict = false, kept = true } = {}) {
+  const out = emptyIntents();
+  if (strict) {
+    gone.forEach((value, key) => recordOf2(value, key, out));
+    return out;
+  }
+  if (kept && gone instanceof se2 && gone.doc) return goneIndexOf(gone).intents();
+  if (!kept) {
+    gone.forEach((value, key) => {
+      const record5 = parsedRecord(value, key);
+      if (record5) foldRecord(out, record5);
+    });
+    return out;
+  }
+  const previous = parsedGone.get(gone) ?? /* @__PURE__ */ new Map();
+  const parsed2 = /* @__PURE__ */ new Map();
+  gone.forEach((value, key) => {
+    const hit = previous.get(key);
+    const entry = hit && hit.value === value ? hit : { value, record: parsedRecord(value, key) };
+    parsed2.set(key, entry);
+    if (entry.record) foldRecord(out, entry.record);
   });
+  parsedGone.set(gone, parsed2);
   return out;
 }
 var typeNode = (name) => schema.nodes[name] ?? schema.nodes.paragraph;
@@ -59408,8 +59994,19 @@ function walkFlow(pd, index2) {
   const liveSources = new Set(liveBySource.keys());
   const movedSources = /* @__PURE__ */ new Set();
   const retired = [];
+  const copyBoundary = (client, clock) => {
+    const sourceKey = `${client}.${clock}`;
+    const record5 = index2.boundaryOf({ client, clock });
+    if (!record5 || record5.kind !== "copy") return;
+    if (intents.copyActive.has(sourceKey)) {
+      if (record5.recoveryOf) movedSources.add(record5.recoveryOf);
+    } else if (liveSources.has(sourceKey)) retired.push({ key: copyActiveKey(sourceKey), sourceKey, source: { client, clock }, operationId: null, blockId: record5.blockId, end: null, sv: [], legacy: false, implicit: true });
+  };
+  const markers = index2.markers?.() ?? null;
   const candidateSets = /* @__PURE__ */ new Map();
-  for (const key of pd.origins.keys()) {
+  if (markers) {
+    for (const entry of markers.records) if (entry.live && entry.kind === "boundary") copyBoundary(entry.client, entry.clock);
+  } else for (const key of pd.origins.keys()) {
     let parts;
     try {
       parts = JSON.parse(key);
@@ -59419,15 +60016,7 @@ function walkFlow(pd, index2) {
     if (!Array.isArray(parts) || parts.length !== 3 || parts[0] !== "boundary" && parts[0] !== "alias") continue;
     const [, client, clock] = parts;
     if (!Number.isSafeInteger(client) || client < 0 || !Number.isSafeInteger(clock) || clock < 0) continue;
-    if (parts[0] === "boundary") {
-      const sourceKey = `${client}.${clock}`;
-      const record5 = index2.boundaryOf({ client, clock });
-      if (record5 && record5.kind === "copy") {
-        if (intents.copyActive.has(sourceKey)) {
-          if (record5.recoveryOf) movedSources.add(record5.recoveryOf);
-        } else if (liveSources.has(sourceKey)) retired.push({ key: copyActiveKey(sourceKey), sourceKey, source: { client, clock }, operationId: null, blockId: record5.blockId, end: null, sv: [], legacy: false, implicit: true });
-      }
-    }
+    if (parts[0] === "boundary") copyBoundary(client, clock);
     const clocks = candidateSets.get(client) ?? candidateSets.set(client, /* @__PURE__ */ new Set()).get(client);
     clocks.add(clock);
   }
@@ -59489,7 +60078,7 @@ function walkFlow(pd, index2) {
     for (const key of restore.covers) set.add(key);
   }
   const recoveredMarkers = /* @__PURE__ */ new Map();
-  for (let it3 = pd.flow._start; it3; it3 = it3.right) {
+  if (restoredSources.size) for (let it3 = pd.flow._start; it3; it3 = it3.right) {
     if (it3.deleted) continue;
     const source = it3.content instanceof wt2 ? markerSource(it3, it3.content.embed && it3.content.embed.b) : null;
     if (source === null) continue;
@@ -59507,9 +60096,14 @@ function walkFlow(pd, index2) {
   const segs = [];
   const orphans = [];
   const hidden = [];
-  const fences = [];
+  const fences = [], stops = [];
   let cur = null, prevId = "start", hiding = null, at2 = 0;
   const cattrs = {};
+  let styled = null;
+  const fmt2 = () => {
+    for (const key in cattrs) return { ...cattrs };
+    return null;
+  };
   const typeOf = (id) => {
     const m2 = pd.attrs.get(id);
     return m2 && m2.get("t") || "paragraph";
@@ -59524,12 +60118,16 @@ function walkFlow(pd, index2) {
     const id = `recovered:${sourceKey}`;
     const t = root2 ? root2.type : "paragraph";
     const opaque = !Object.hasOwn(schema.nodes, t);
-    cur = { kind: "b", id, baseId: id, brk: { client: it3.id.client, clock: it3.id.clock }, implicit: false, runs: [], len: 1, atom: !opaque && !schema.nodes[t]?.isTextblock, opaque, recovered: true, restored: !moved, sourceKey, t, fields: root2 ? root2.attrs : null };
+    const f = fmt2();
+    if (cur) cur.fmtOut = f;
+    cur = { kind: "b", id, baseId: id, brk: { client: it3.id.client, clock: it3.id.clock }, implicit: false, runs: [], len: 1, atom: !opaque && !schema.nodes[t]?.isTextblock, opaque, recovered: true, restored: !moved, sourceKey, t, fields: root2 ? root2.attrs : null, fmtIn: f, fmtOut: null };
     segs.push(cur);
     prevId = id;
   };
   const open = (id, brk, implicit) => {
-    cur = { kind: "b", id, baseId: id, brk, implicit, runs: [], len: implicit ? 0 : 1, atom: false, items: !implicit && (markerCount.get(id) ?? 0) > 1 ? [] : null };
+    const f = fmt2();
+    if (cur) cur.fmtOut = f;
+    cur = { kind: "b", id, baseId: id, brk, implicit, runs: [], len: implicit ? 0 : 1, atom: false, items: !implicit && (markerCount.get(id) ?? 0) > 1 ? [] : null, fmtIn: f, fmtOut: null };
     if (!implicit) {
       cur.t = typeOf(id);
       cur.opaque = !Object.hasOwn(schema.nodes, cur.t);
@@ -59551,15 +60149,15 @@ function walkFlow(pd, index2) {
     if (a.legacy && a.text) orphans.push({ key: a.key, id: a.blockId, text: a.text, h: hashText(a.text) });
     hidden.push({ key: a.key, sourceKey: a.sourceKey, blockId: a.blockId, end: a.end, sv: a.sv, at: a.at, live: a.live, items: a.items });
   };
-  const matchesEnd = (it3, end2) => {
-    if (covers(it3, end2)) return true;
+  const matchesEnd = (it3, end2, after2 = -1) => {
+    if (covers(it3, end2) && end2.clock > after2) return true;
     return markerIdsWithin(it3).some((id) => {
-      if (!pd.origins.has(aliasKey(id.client, id.clock))) return false;
+      if (id.clock <= after2 || !pd.origins.has(aliasKey(id.client, id.clock))) return false;
       const resolved = index2.resolve(id);
       return resolved.client === end2.client && resolved.clock === end2.clock;
     });
   };
-  const markerClocks = new Map([...candidateSets].map(([client, clocks]) => [client, [...clocks].sort((a, b2) => a - b2)]));
+  const markerClocks = markers ? markers.clocks : new Map([...candidateSets].map(([client, clocks]) => [client, [...clocks].sort((a, b2) => a - b2)]));
   const markerIdsWithin = (it3) => {
     const clocks = markerClocks.get(it3.id.client) ?? [];
     let lo3 = 0, hi3 = clocks.length;
@@ -59572,6 +60170,14 @@ function walkFlow(pd, index2) {
     for (let i = lo3; i < clocks.length && clocks[i] < it3.id.clock + it3.length; i++) ids.push({ client: it3.id.client, clock: clocks[i] });
     return ids;
   };
+  const deletedEdgesIn = (it3, after2 = -1) => it3.deleted ? markerIdsWithin(it3).flatMap((id) => {
+    if (id.clock <= after2) return [];
+    const sourceKey = idKey(index2.resolve(id));
+    const record5 = index2.boundaryOf(id);
+    if (!record5 || record5.kind !== "removed" && record5.kind !== "copy" || liveSources.has(sourceKey)) return [];
+    return [{ blockId: record5.blockId, sourceKey }];
+  }) : [];
+  const endsIn = (it3, a, { deletedEdges, boundary = false, edge, after: after2 = -1 }) => a.end ? matchesEnd(it3, a.end, after2) : a.implicit ? boundary || deletedEdges.some((e19) => e19.sourceKey !== a.sourceKey) : boundary && edge !== a.blockId || deletedEdges.some((e19) => e19.blockId !== a.blockId);
   const proj = [];
   const endsOf = (removal) => ({ blockId: removal.blockId, end: removal.end ? parseKey(removal.end) : null, implicit: removal.implicit === true, sourceKey: removal.sourceKey });
   for (let it3 = pd.flow._start; it3; it3 = it3.right) {
@@ -59580,13 +60186,8 @@ function walkFlow(pd, index2) {
     if (hiding || proj.length) {
       const edge = !it3.deleted && it3.content instanceof wt2 ? it3.content.embed.b : void 0;
       const boundary = edge !== void 0 && boundarySource(it3, edge) === null;
-      const deletedEdges = it3.deleted ? markerIdsWithin(it3).flatMap((id) => {
-        const sourceKey = idKey(index2.resolve(id));
-        const record5 = index2.boundaryOf(id);
-        if (!record5 || record5.kind !== "removed" || liveSources.has(sourceKey)) return [];
-        return [{ blockId: record5.blockId, sourceKey }];
-      }) : [];
-      const ends = (a) => a.end ? matchesEnd(it3, a.end) : a.implicit ? boundary || deletedEdges.some((e19) => e19.sourceKey !== a.sourceKey) : boundary && edge !== a.blockId || deletedEdges.some((e19) => e19.blockId !== a.blockId);
+      const deletedEdges = deletedEdgesIn(it3);
+      const ends = (a) => endsIn(it3, a, { deletedEdges, boundary, edge });
       if (hiding) {
         const keep = [];
         for (const a of hiding.active) {
@@ -59603,6 +60204,7 @@ function walkFlow(pd, index2) {
     }
     const removals2 = removalStarts.get(it3);
     if (removals2) {
+      if (it3.deleted) stops.push({ client: it3.id.client, clock: it3.id.clock, len: it3.length });
       if (!hiding && exposed(removals2[0].sourceKey)) {
         if (!it3.deleted) hideUnit(it3.length);
         proj.push({ active: removals2.map(endsOf), sourceKey: removals2[0].sourceKey, root: null });
@@ -59611,14 +60213,20 @@ function walkFlow(pd, index2) {
       if (!hiding && it3.deleted) fences.push({ client: it3.id.client, clock: it3.id.clock });
       for (const removal of removals2) {
         const a = { legacy: false, implicit: removal.implicit === true, key: removal.key, sourceKey: removal.sourceKey, blockId: removal.blockId, end: removal.end ? parseKey(removal.end) : null, sv: removal.sv, at: here, live: !it3.deleted, items: [] };
+        const after2 = it3.deleted && covers(it3, removal.source) ? removal.source.clock : null;
+        if (after2 !== null && endsIn(it3, a, { deletedEdges: deletedEdgesIn(it3, after2), after: after2 })) {
+          settle(a);
+          continue;
+        }
         if (hiding) hiding.active.push(a);
         else hiding = { active: [a], len: 0, resume: cur };
       }
-      if (!it3.deleted) hiding.len += it3.length;
+      if (hiding && !it3.deleted) hiding.len += it3.length;
       continue;
     }
     const start = starts.get(it3);
     if (start) {
+      if (it3.deleted) stops.push({ client: it3.id.client, clock: it3.id.clock, len: it3.length });
       if (!hiding && exposed(start.key)) {
         if (!it3.deleted) hideUnit(it3.length);
         proj.push({ active: [{ blockId: start.blockId, end: start.end }], sourceKey: start.key, root: null });
@@ -59635,6 +60243,7 @@ function walkFlow(pd, index2) {
     if (c instanceof C2) {
       if (c.value === null) delete cattrs[c.key];
       else cattrs[c.key] = c.value;
+      styled = null;
       continue;
     }
     if (hiding) {
@@ -59685,8 +60294,12 @@ function walkFlow(pd, index2) {
     }
     if (c instanceof nt2) {
       if (!cur || cur.atom) open(`~${prevId}`, null, true);
-      const marks = marksFromAttributes(cattrs, cur.t);
-      cur.runs.push({ text: c.str, marks, mk: marksKey(marks) });
+      const code = cur.t === "code_block";
+      if (!styled || styled.code !== code) {
+        const marks = marksFromAttributes(cattrs, cur.t);
+        styled = { code, marks, mk: marksKey(marks) };
+      }
+      cur.runs.push({ text: c.str, marks: styled.marks, mk: styled.mk });
       if (cur.items) cur.items.push({ at: here, id: idKey(it3.id), client: it3.id.client, clock: it3.id.clock, length: it3.length, kind: "text", text: c.str, blockId: null, raw: { ...cattrs } });
       cur.len += c.str.length;
     }
@@ -59695,6 +60308,7 @@ function walkFlow(pd, index2) {
     for (const a of hiding.active) settle(a);
     flush();
   }
+  if (cur) cur.fmtOut = fmt2();
   const groups = /* @__PURE__ */ new Map();
   for (const s of segs) {
     if (s.kind !== "b" || s.implicit) continue;
@@ -59741,7 +60355,7 @@ function walkFlow(pd, index2) {
     }
     tokens += s.len;
   }
-  return { visible, holes, orphans, tokens, copies, hidden, removals: lostCopies.length ? [...removals, ...lostCopies] : removals, fences };
+  return { visible, holes, orphans, tokens, copies, hidden, removals: lostCopies.length ? [...removals, ...lostCopies] : removals, fences, stops };
 }
 
 // src/page/ybind/decode.js
@@ -60070,16 +60684,16 @@ var REGISTRY = {
     "pos"
   ]
 };
-var frozen = null;
+var frozen2 = null;
 function floorZero() {
-  if (!frozen) {
-    frozen = Object.freeze({
+  if (!frozen2) {
+    frozen2 = Object.freeze({
       types: Object.freeze([...REGISTRY.types]),
       marks: Object.freeze([...REGISTRY.marks]),
       fields: Object.freeze([...REGISTRY.fields])
     });
   }
-  return frozen;
+  return frozen2;
 }
 var CODE2 = /^[A-Za-z]$/;
 function newerMark(key) {
@@ -60815,8 +61429,8 @@ function align(baseRoot, sideRoot, o) {
   const keysAgree = (b2, s) => {
     const kb = baseId(b2);
     if (!kb) return true;
-    const ks2 = sideId(s);
-    return !ks2 || kb === ks2;
+    const ks3 = sideId(s);
+    return !ks3 || kb === ks3;
   };
   const nameB = (u) => {
     const k2 = baseKey(u);
@@ -60935,8 +61549,8 @@ function align(baseRoot, sideRoot, o) {
       for (const u of unitsOf3(bEl)) {
         const t = map2.get(u);
         if (!t || identityPaired.has(u)) continue;
-        const within2 = isEl3(t) ? sEl.contains(t) : sEl.contains(t.nodes[0]);
-        if (!within2) continue;
+        const within3 = isEl3(t) ? sEl.contains(t) : sEl.contains(t.nodes[0]);
+        if (!within3) continue;
         drop(u, t);
         if (isEl3(u)) walk2(u, t);
       }
@@ -60963,12 +61577,12 @@ function align(baseRoot, sideRoot, o) {
       alignKids(b2, s);
     }
   }
-  function within(el3, list) {
+  function within2(el3, list) {
     if (codeLike(el3)) return;
     for (const u of unitsOf3(el3))
       if (isEl3(u)) {
         list.push(u);
-        within(u, list);
+        within2(u, list);
       }
   }
   function alignKids(bEl, sEl) {
@@ -61008,7 +61622,7 @@ function align(baseRoot, sideRoot, o) {
       if (!map2.has(u)) {
         if (isEl3(u)) {
           unpairedBase.push(u);
-          within(u, unpairedBase);
+          within2(u, unpairedBase);
           openB = true;
         }
         continue;
@@ -61018,7 +61632,7 @@ function align(baseRoot, sideRoot, o) {
     for (const u of sUnits)
       if (!reverse.has(u) && isEl3(u)) {
         unpairedSide.push(u);
-        within(u, unpairedSide);
+        within2(u, unpairedSide);
         openS = true;
       }
     if (openB && openS) slotParents.push([bEl, sEl]);
@@ -61233,15 +61847,15 @@ function align(baseRoot, sideRoot, o) {
       if (map2.has(b2) || !isEl3(b2) || codeLike(b2)) continue;
       const bucket = buckets.get(meta(b2).sig);
       if (!bucket || !bucket.length) continue;
-      const bi2 = posB.get(b2);
-      let near = bucket.filter((c) => !reverse.has(c.el)).map((c) => ({ c, d: Math.abs(c.index - bi2) }));
+      const bi3 = posB.get(b2);
+      let near = bucket.filter((c) => !reverse.has(c.el)).map((c) => ({ c, d: Math.abs(c.index - bi3) }));
       near.sort((x3, y2) => x3.d - y2.d);
       if (near.length > NEAREST_WINDOW) near = near.slice(0, NEAREST_WINDOW);
       for (const { c, d } of near) {
         if (!keysAgree(b2, c.el)) continue;
         const sc2 = score(b2, c.el);
         if (sc2 && sc2.coef >= 0.5)
-          cands.push({ b: b2, s: c.el, coef: sc2.coef, share: sc2.share, d, bi: bi2 });
+          cands.push({ b: b2, s: c.el, coef: sc2.coef, share: sc2.share, d, bi: bi3 });
       }
     }
     cands.sort(
@@ -61331,9 +61945,9 @@ function align(baseRoot, sideRoot, o) {
       return null;
     };
     return (b2, s) => {
-      const bi2 = posB.get(b2), si3 = posS.get(s);
-      if (bi2 === si3) return true;
-      const ab = anchor(bUnits, bi2, (u) => map2.has(u)), as2 = anchor(sUnits, si3, (u) => reverse.has(u));
+      const bi3 = posB.get(b2), si3 = posS.get(s);
+      if (bi3 === si3) return true;
+      const ab = anchor(bUnits, bi3, (u) => map2.has(u)), as2 = anchor(sUnits, si3, (u) => reverse.has(u));
       return ab ? map2.get(ab) === as2 : !as2;
     };
   }
@@ -61569,12 +62183,12 @@ function myers(a, b2, maxD) {
 function wordsFirst(a, b2, maxD) {
   const brk = (t) => t.k === BREAK3;
   if (!a.some(brk) && !b2.some(brk)) return myers(a, b2, maxD);
-  const ai3 = [], bi2 = [];
+  const ai3 = [], bi3 = [];
   for (let i = 0; i < a.length; i++) if (!brk(a[i])) ai3.push(i);
-  for (let i = 0; i < b2.length; i++) if (!brk(b2[i])) bi2.push(i);
+  for (let i = 0; i < b2.length; i++) if (!brk(b2[i])) bi3.push(i);
   const top = myers(
     ai3.map((i) => a[i]),
-    bi2.map((i) => b2[i]),
+    bi3.map((i) => b2[i]),
     maxD
   );
   if (!top) return null;
@@ -61591,7 +62205,7 @@ function wordsFirst(a, b2, maxD) {
   };
   for (const [op, i, j3] of top) {
     if (op !== 0) continue;
-    if (!gapTo(ai3[i], bi2[j3])) return null;
+    if (!gapTo(ai3[i], bi3[j3])) return null;
     ops.push([0, x3, y2]);
     x3++;
     y2++;
@@ -61893,11 +62507,11 @@ function sharesFew(a, b2) {
   return inter / Math.min(na3.length, nb.length) < REWRITE_SHARE;
 }
 var keysOf = (h, B3) => {
-  const ks2 = /* @__PURE__ */ new Set();
-  for (const t of h.toks) if (typeof t.k !== "string") ks2.add(t.k.el);
+  const ks3 = /* @__PURE__ */ new Set();
+  for (const t of h.toks) if (typeof t.k !== "string") ks3.add(t.k.el);
   for (let i = h.bs; i < h.be; i++)
-    if (typeof B3[i].k !== "string") ks2.add(B3[i].k.el);
-  return ks2;
+    if (typeof B3[i].k !== "string") ks3.add(B3[i].k.el);
+  return ks3;
 };
 var sameToks = (a, b2) => a.length === b2.length && a.every((t, i) => t.k === b2[i].k);
 function merge3Tokens(B3, L3, R3, policy = "remote") {
@@ -62017,9 +62631,9 @@ function merge3Tokens(B3, L3, R3, policy = "remote") {
     units.forEach((u, i) => {
       for (const [og, info] of groups) {
         if (find4(i) === find4(og) || !(info.L && info.R)) continue;
-        const inside = u.bs < info.be && u.be > info.bs;
+        const inside2 = u.bs < info.be && u.be > info.bs;
         const textInsertAtEdge = isInsert(u) && hasText(u) && (u.bs === info.be || u.bs === info.bs);
-        if ((inside || textInsertAtEdge) && union(i, og)) grew = true;
+        if ((inside2 || textInsertAtEdge) && union(i, og)) grew = true;
       }
     });
   }
@@ -62062,9 +62676,9 @@ function merge3Tokens(B3, L3, R3, policy = "remote") {
   const rank = (e19) => e19.kind === "R" ? 1 : 0;
   emitUnits.sort((a, b2) => {
     if (a.bs !== b2.bs) return a.bs - b2.bs;
-    const ai3 = a.bs === a.be, bi2 = b2.bs === b2.be;
-    if (ai3 !== bi2) return ai3 ? -1 : 1;
-    if (ai3 && bi2 && a.kind !== "conflict" && b2.kind !== "conflict") {
+    const ai3 = a.bs === a.be, bi3 = b2.bs === b2.be;
+    if (ai3 !== bi3) return ai3 ? -1 : 1;
+    if (ai3 && bi3 && a.kind !== "conflict" && b2.kind !== "conflict") {
       const at3 = a.u.toks, bt3 = b2.u.toks;
       const allOpen = (t) => t.length && t.every((x3) => x3.kind === "open");
       const allClose = (t) => t.length && t.every((x3) => x3.kind === "close");
@@ -62157,8 +62771,8 @@ function merge3Tokens(B3, L3, R3, policy = "remote") {
   for (const seg of segments) {
     if (seg.source === "base") {
       seg.toks = seg.toks.map((t, i) => {
-        const bi2 = seg.bs + i;
-        const lt3 = cosL.get(bi2), rt3 = cosR.get(bi2);
+        const bi3 = seg.bs + i;
+        const lt3 = cosL.get(bi3), rt3 = cosR.get(bi3);
         const pick2 = lt3 && rt3 ? policy === "remote" ? rt3 : lt3 : lt3 || rt3 || t;
         return pick2 === t ? t : { ...pick2, cosmetic: true };
       });
@@ -62381,11 +62995,11 @@ function compileOccurrenceMap({
     const length = run.to - run.from;
     if (!charge(length)) return fallback("work-limit");
     for (let k2 = 0; k2 < length; k2++) {
-      const bi2 = run.from + k2, si3 = run.target + k2;
+      const bi3 = run.from + k2, si3 = run.target + k2;
       budget.comparisons++;
-      if (base.text[bi2] !== side.text[si3])
+      if (base.text[bi3] !== side.text[si3])
         return fallback("unequal-occurrence");
-      const ba2 = base.atomAt.get(bi2), sa3 = side.atomAt.get(si3);
+      const ba2 = base.atomAt.get(bi3), sa3 = side.atomAt.get(si3);
       if (!!ba2 !== !!sa3 || ba2 && baseAtomKey(ba2) !== sideAtomKey(sa3))
         return fallback("different-atom");
     }
@@ -62451,27 +63065,27 @@ function boundaryOccurrences({
       last2.to++;
     else runs.push({ from, to: from + 1, target, destination, kind });
   };
-  let bi2 = 0, si3 = 0, changedBoundary = false;
+  let bi3 = 0, si3 = 0, changedBoundary = false;
   try {
-    while (bi2 < base.text.length || si3 < side.text.length) {
-      if (bi2 < base.text.length && si3 < side.text.length && base.text[bi2] === side.text[si3]) {
-        const ba2 = base.atomAt.get(bi2), sa3 = side.atomAt.get(si3);
+    while (bi3 < base.text.length || si3 < side.text.length) {
+      if (bi3 < base.text.length && si3 < side.text.length && base.text[bi3] === side.text[si3]) {
+        const ba2 = base.atomAt.get(bi3), sa3 = side.atomAt.get(si3);
         if (!!ba2 !== !!sa3 || ba2 && baseOf2(sa3.el) !== ba2.el)
           return { status: "none" };
-        append3(bi2++, si3++);
+        append3(bi3++, si3++);
         continue;
       }
-      if (!soft(base.text, bi2) && !soft(side.text, si3))
+      if (!soft(base.text, bi3) && !soft(side.text, si3))
         return { status: "none" };
-      const bs3 = bi2, ss3 = si3;
-      while (soft(base.text, bi2)) bi2++;
+      const bs3 = bi3, ss3 = si3;
+      while (soft(base.text, bi3)) bi3++;
       while (soft(side.text, si3)) si3++;
-      const bt3 = base.text.slice(bs3, bi2), st3 = side.text.slice(ss3, si3);
+      const bt3 = base.text.slice(bs3, bi3), st3 = side.text.slice(ss3, si3);
       if (bt3.includes(BREAK3) || st3.includes(BREAK3)) changedBoundary = true;
       let tail = 0;
-      while (tail < bi2 - bs3 && tail < si3 - ss3 && base.text[bi2 - tail - 1] === side.text[si3 - tail - 1])
+      while (tail < bi3 - bs3 && tail < si3 - ss3 && base.text[bi3 - tail - 1] === side.text[si3 - tail - 1])
         tail++;
-      for (let k2 = tail; k2 > 0; k2--) append3(bi2 - k2, si3 - k2);
+      for (let k2 = tail; k2 > 0; k2--) append3(bi3 - k2, si3 - k2);
     }
   } catch (error) {
     if (error === exhausted)
@@ -62955,9 +63569,9 @@ var offsets = (toks) => {
 function sideDiff(fs3, bToks, sToks, d) {
   const bOff = offsets(bToks), sOff = offsets(sToks);
   const hunks = [];
-  let bi2 = 0, si3 = 0;
+  let bi3 = 0, si3 = 0;
   for (const h of d.hunks) {
-    si3 += h.bs - bi2;
+    si3 += h.bs - bi3;
     const ste = si3 + h.toks.length;
     hunks.push({
       bs: bOff[h.bs],
@@ -62969,7 +63583,7 @@ function sideDiff(fs3, bToks, sToks, d) {
       lead: !!h.lead
     });
     si3 = ste;
-    bi2 = h.be;
+    bi3 = h.be;
   }
   const respell = /* @__PURE__ */ new Map();
   for (const c of d.cosmetic) respell.set(c.bi, c.tok.raw);
@@ -63282,8 +63896,8 @@ function mergeInline(o) {
   const byTwin = !!(L3 && L3.reverse && L3.map && R3 && R3.reverse && R3.map);
   const atomizers = { base: null, local: null, remote: null };
   if (!o.prepared && byTwin && o.moveIn) {
-    const within = (nodes2) => (x3) => nodes2.some((n2) => n2 === x3 || n2.nodeType === 1 && n2.contains(x3));
-    const inL = within(o.local), inR = within(o.remote), inB = within(o.base);
+    const within2 = (nodes2) => (x3) => nodes2.some((n2) => n2 === x3 || n2.nodeType === 1 && n2.contains(x3));
+    const inL = within2(o.local), inR = within2(o.remote), inB = within2(o.base);
     const moved = /* @__PURE__ */ new Set();
     const visit = (el3) => {
       if (!MARK_TAGS.has(el3.tagName)) return;
@@ -63303,8 +63917,8 @@ function mergeInline(o) {
   }
   const skip = { base: /* @__PURE__ */ new Set(), local: /* @__PURE__ */ new Set(), remote: /* @__PURE__ */ new Set() };
   if (!o.prepared && byTwin && o.moveIn) {
-    const within = (nodes2) => (x3) => nodes2.some((n2) => n2 === x3 || n2.nodeType === 1 && n2.contains(x3));
-    const inL = within(o.local), inR = within(o.remote);
+    const within2 = (nodes2) => (x3) => nodes2.some((n2) => n2 === x3 || n2.nodeType === 1 && n2.contains(x3));
+    const inL = within2(o.local), inR = within2(o.remote);
     for (const a of flatten2(o.base, { ...o, atomize: atomizers.base }).atoms) {
       const lt3 = L3.map.get(a.el), rt3 = R3.map.get(a.el);
       const outL = !!lt3 && !inL(lt3), outR = !!rt3 && !inR(rt3);
@@ -64878,7 +65492,7 @@ function planLineage({
     const p = n.parentNode;
     return p && p.nodeType === 11 ? hostOf.get(p) || null : p;
   };
-  const inside = (x3, M3) => {
+  const inside2 = (x3, M3) => {
     for (let n = x3; n; n = up(n)) if (n === M3) return true;
     return false;
   };
@@ -64923,7 +65537,7 @@ function planLineage({
           for (const o of outs) {
             if (o === LOST || !inTree.has(o)) return "output-not-placed";
             if (!M3) return "survives-elsewhere";
-            if (!inside(o, M3)) return "escaped";
+            if (!inside2(o, M3)) return "escaped";
             owned.push(o);
           }
         } else if (!covered && !decided && !decidedAt(c) && !segLocal.has(c))
@@ -65120,7 +65734,7 @@ function planNativeTransfers({
   for (const side of ["local", "remote"]) {
     const removed = /* @__PURE__ */ new Map(), inserted = /* @__PURE__ */ new Map();
     let hasReplacement = false;
-    const add2 = (map2, text4, h) => {
+    const add3 = (map2, text4, h) => {
       if (map2.has(text4)) map2.set(text4, null);
       else map2.set(text4, h);
     };
@@ -65130,10 +65744,10 @@ function planNativeTransfers({
       if (h.bs < h.be && h.text === "") {
         const text4 = B3.slice(h.bs, h.be);
         if (!charge(text4.length * 2)) return null;
-        if (/\S/.test(text4)) add2(removed, text4, h);
+        if (/\S/.test(text4)) add3(removed, text4, h);
       } else if (h.bs === h.be && /\S/.test(h.text)) {
         if (!charge(h.text.length * 2)) return null;
-        add2(inserted, h.text, h);
+        add3(inserted, h.text, h);
       } else if (h.bs < h.be) hasReplacement = true;
     }
     for (const [text4, deletion] of removed) {
@@ -65237,16 +65851,16 @@ function planNativeTransfers({
   }
   const maps = {};
   for (const side of ["local", "remote"]) {
-    let bi2 = 0, si3 = 0;
+    let bi3 = 0, si3 = 0;
     const retained = [];
     for (const h of hunks[side]) {
       if (!charge(1)) return null;
-      if (h.bs > bi2) retained.push({ from: bi2, to: h.bs, target: si3 });
-      bi2 = h.be;
+      if (h.bs > bi3) retained.push({ from: bi3, to: h.bs, target: si3 });
+      bi3 = h.be;
       si3 = h.se;
     }
-    if (bi2 < flats.base.text.length)
-      retained.push({ from: bi2, to: flats.base.text.length, target: si3 });
+    if (bi3 < flats.base.text.length)
+      retained.push({ from: bi3, to: flats.base.text.length, target: si3 });
     const moved = transfers.filter((event) => event.side === side).map((event) => ({
       from: event.bs,
       to: event.be,
@@ -65608,7 +66222,7 @@ function mergeObjects(base, local, remote, opts, path, keyPath) {
     ...Object.keys(remote)
   ]);
   for (const key of keys) {
-    const merged = mergePresence(
+    const merged2 = mergePresence(
       has3(base, key) ? base[key] : MISSING,
       has3(local, key) ? local[key] : MISSING,
       has3(remote, key) ? remote[key] : MISSING,
@@ -65616,7 +66230,7 @@ function mergeObjects(base, local, remote, opts, path, keyPath) {
       keySegment(path, key),
       childKeyPath(keyPath, key)
     );
-    if (merged !== MISSING) setKey(result, key, merged);
+    if (merged2 !== MISSING) setKey(result, key, merged2);
   }
   return result;
 }
@@ -65707,7 +66321,7 @@ function mergeArrays(base, local, remote, opts, path, keyPath) {
   const baseMap = toMap(baseArr);
   const localMap = toMap(local);
   const remoteMap = toMap(remote);
-  const merged = /* @__PURE__ */ new Map();
+  const merged2 = /* @__PURE__ */ new Map();
   const allIds = /* @__PURE__ */ new Set([
     ...baseMap.keys(),
     ...localMap.keys(),
@@ -65722,16 +66336,16 @@ function mergeArrays(base, local, remote, opts, path, keyPath) {
       segments.get(id),
       keyPath
     );
-    if (value !== MISSING) merged.set(id, value);
+    if (value !== MISSING) merged2.set(id, value);
   }
   const order2 = [];
   for (const item of remote) {
     const id = idOf(item);
-    if (merged.has(id)) order2.push(id);
+    if (merged2.has(id)) order2.push(id);
   }
   for (let i = 0; i < local.length; i++) {
     const id = idOf(local[i]);
-    if (!merged.has(id) || order2.includes(id)) continue;
+    if (!merged2.has(id) || order2.includes(id)) continue;
     let insertAt = 0;
     for (let j3 = i - 1; j3 >= 0; j3--) {
       const prevIndex = order2.indexOf(idOf(local[j3]));
@@ -65742,7 +66356,7 @@ function mergeArrays(base, local, remote, opts, path, keyPath) {
     }
     order2.splice(insertAt, 0, id);
   }
-  return order2.map((id) => merged.get(id));
+  return order2.map((id) => merged2.get(id));
 }
 function resolveOptions(options) {
   const keyPaths = /* @__PURE__ */ new Map();
@@ -65805,17 +66419,17 @@ function mergeScriptText(baseText, localText, remoteText, options = {}) {
   if (local === MISSING) return { text: remoteText, warnings, conflicts };
   if (remote === MISSING) return { text: localText, warnings, conflicts };
   const base = tryParse(baseText, "base");
-  const merged = mergeJson(base === MISSING ? void 0 : base, local, remote, {
+  const merged2 = mergeJson(base === MISSING ? void 0 : base, local, remote, {
     ...options,
     onConflict: (c) => {
       conflicts.push(c);
       options.onConflict?.(c);
     }
   });
-  if (deepEqual(merged, remote))
+  if (deepEqual(merged2, remote))
     return { text: remoteText, warnings, conflicts };
-  if (deepEqual(merged, local)) return { text: localText, warnings, conflicts };
-  return { text: serializeLike(merged, remoteText), warnings, conflicts };
+  if (deepEqual(merged2, local)) return { text: localText, warnings, conflicts };
+  return { text: serializeLike(merged2, remoteText), warnings, conflicts };
 }
 
 // node_modules/hyper-morph/src/recovery-dom.js
@@ -65930,7 +66544,7 @@ function createRecovery(ctx) {
     const order2 = /* @__PURE__ */ new Map();
     const outOwners = /* @__PURE__ */ new WeakMap();
     let seq = 0;
-    const add2 = (src, n) => {
+    const add3 = (src, n) => {
       let list = outputs.get(src);
       if (!list) outputs.set(src, list = []);
       list.push(n);
@@ -65941,8 +66555,8 @@ function createRecovery(ctx) {
       if (p && !p.pinned)
         for (const v3 of [p.base, p.local, p.remote]) {
           if (!v3) continue;
-          if (Array.isArray(v3)) for (const x3 of v3) add2(x3, n);
-          else add2(v3, n);
+          if (Array.isArray(v3)) for (const x3 of v3) add3(x3, n);
+          else add3(v3, n);
         }
       if (isTemplate(n)) {
         outOwners.set(n.content, n);
@@ -66361,7 +66975,7 @@ function createRecovery(ctx) {
       return `${prefix}:${n}`;
     };
     const text4 = (rec, meta) => {
-      let U3, bs3, be3, encoding = "plain", base, local, remote, merged, anchor;
+      let U3, bs3, be3, encoding = "plain", base, local, remote, merged2, anchor;
       const runSide = (u, k0, k1, sd, bk) => {
         if (!u) {
           const g2 = gapIn(bk, sd);
@@ -66391,7 +67005,7 @@ function createRecovery(ctx) {
         remote = runSide(rRun, c.rs, c.re, "remote", bRun);
         const mv = node ? node.nodeValue : "";
         const pt3 = (k2) => node ? { kind: "text", node, offset: k2 } : gapOut(bRun);
-        merged = link(
+        merged2 = link(
           plain4(
             mv,
             c.ms,
@@ -66418,7 +67032,7 @@ function createRecovery(ctx) {
         local = whole(rec.local, p.local, "local");
         remote = whole(rec.remote, p.remote, "remote");
         const s = wholeSpanOut(el3);
-        merged = link(
+        merged2 = link(
           plain4(rec.resolved, 0, rec.resolved.length, s, s),
           { kind: "wholeStart", node: el3 },
           { kind: "wholeEnd", node: el3 },
@@ -66449,7 +67063,7 @@ function createRecovery(ctx) {
         const v3 = rec.resolved;
         const pt3 = (k2) => node ? { kind: "text", node, offset: k2 } : gapOut(bRun);
         const s = { start: staticPoint(pt3(0)), end: staticPoint(pt3(v3.length)) };
-        merged = link(
+        merged2 = link(
           plain4(v3, 0, v3.length, s, s),
           pt3(0),
           pt3(v3.length),
@@ -66485,8 +67099,8 @@ function createRecovery(ctx) {
               start: pt3(rawPoint(f, 0, "start")),
               end: pt3(rawPoint(f, f.text.length, "end"))
             });
-          const ks3 = rs3 ? measure(F3, rs3) : null, ke4 = re2 ? measure(F3, re2) : null;
-          const S2 = ks3 === null ? 0 : ks3;
+          const ks4 = rs3 ? measure(F3, rs3) : null, ke4 = re2 ? measure(F3, re2) : null;
+          const S2 = ks4 === null ? 0 : ks4;
           const E3 = Math.max(S2, ke4 === null ? F3.text.length : ke4);
           const s0 = pt3(rawPoint(F3, 0, "start"));
           return side(F3.text, S2, E3, sliceHtml(F3, S2, E3), span2, {
@@ -66524,10 +67138,10 @@ function createRecovery(ctx) {
           segmentGap
         ), De2 = ms3 === me3 ? Ds3 : mergedPoint(M3, me3, "end", segmentGap);
         const S0 = fo3.text.length ? outDesc(fo3, 0, "start", M3.node) : segmentGap(), S1 = fo3.text.length ? outDesc(fo3, fo3.text.length, "end", M3.node) : S0;
-        const ks2 = measure(fo3, Ds3), ke3 = measure(fo3, De2);
-        const s = ks2 === null ? 0 : ks2;
+        const ks3 = measure(fo3, Ds3), ke3 = measure(fo3, De2);
+        const s = ks3 === null ? 0 : ks3;
         const e19 = Math.max(s, ke3 === null ? fo3.text.length : ke3);
-        merged = link(
+        merged2 = link(
           side(
             fo3.text,
             s,
@@ -66541,7 +67155,7 @@ function createRecovery(ctx) {
           S0,
           S1
         );
-        const linked = links.spans.get(merged);
+        const linked = links.spans.get(merged2);
         linked.flat = fo3;
         if (!fo3.text.length) {
           const p = staticPoint(S0);
@@ -66567,7 +67181,7 @@ function createRecovery(ctx) {
           base,
           local,
           remote,
-          merged,
+          merged: merged2,
           liveSpan: null,
           liveScope: null
         }
@@ -66766,10 +67380,10 @@ function createMoveDestinations({
     const outputAuthority = /* @__PURE__ */ new WeakMap();
     const attached = /* @__PURE__ */ new WeakSet();
     const visiting = /* @__PURE__ */ new Set();
-    const add2 = (source, entry) => {
+    const add3 = (source, entry) => {
       if (!source) return;
       if (Array.isArray(source)) {
-        for (const node of source) add2(node, entry);
+        for (const node of source) add3(node, entry);
         return;
       }
       let entries = outputs.get(source);
@@ -66781,7 +67395,7 @@ function createMoveDestinations({
       const stack = [source];
       while (stack.length) {
         const node = stack.pop();
-        add2(node, entry);
+        add3(node, entry);
         for (const child of childrenOf(node).childNodes) stack.push(child);
       }
     };
@@ -66799,7 +67413,7 @@ function createMoveDestinations({
         for (const source of [p.base, p.local, p.remote])
           representedSubtree(source, { ...entry, kind: "unchanged" });
       } else if (p) {
-        for (const source of [p.base, p.local, p.remote]) add2(source, entry);
+        for (const source of [p.base, p.local, p.remote]) add3(source, entry);
         if (isElement(p.local)) {
           for (const child of childrenOf(p.local).children)
             if (ignored(child))
@@ -67414,10 +68028,10 @@ function createCrossParentConsumer({
     const authority = /* @__PURE__ */ new WeakMap();
     const outputs = /* @__PURE__ */ new WeakMap();
     const children2 = (node) => node.tagName === "TEMPLATE" && node.content ? node.content : node;
-    const add2 = (source, node) => {
+    const add3 = (source, node) => {
       if (!source) return;
       if (Array.isArray(source)) {
-        for (const part of source) add2(part, node);
+        for (const part of source) add3(part, node);
         return;
       }
       let list = outputs.get(source);
@@ -67431,7 +68045,7 @@ function createCrossParentConsumer({
       const authoritative = inherited || !!(p && remoteWins(p.remote || p.base));
       authority.set(node, authoritative);
       if (p)
-        for (const source of [p.base, p.local, p.remote]) add2(source, node);
+        for (const source of [p.base, p.local, p.remote]) add3(source, node);
       if (p?.pinned || p?.unchanged) return;
       for (const child of children2(node).childNodes)
         index2(child, node, authoritative);
@@ -68171,19 +68785,19 @@ function certificateGroups({
     budget.remaining -= cost;
     const edits = diffTokens(B3, S2, depth);
     const pairs = [];
-    let bi2 = 0, si3 = 0;
+    let bi3 = 0, si3 = 0;
     for (const h of edits.hunks) {
-      while (bi2 < h.bs) {
-        if (B3[bi2].raw === S2[si3].raw) pairs.push([B3[bi2], S2[si3]]);
-        bi2++;
+      while (bi3 < h.bs) {
+        if (B3[bi3].raw === S2[si3].raw) pairs.push([B3[bi3], S2[si3]]);
+        bi3++;
         si3++;
       }
-      bi2 = h.be;
+      bi3 = h.be;
       si3 += h.toks.length;
     }
-    while (bi2 < B3.length && si3 < S2.length) {
-      if (B3[bi2].raw === S2[si3].raw) pairs.push([B3[bi2], S2[si3]]);
-      bi2++;
+    while (bi3 < B3.length && si3 < S2.length) {
+      if (B3[bi3].raw === S2[si3].raw) pairs.push([B3[bi3], S2[si3]]);
+      bi3++;
       si3++;
     }
     return pairs;
@@ -68440,13 +69054,13 @@ function certificateGroups({
               if (M3.flat.atoms.length) continue;
               const otherUsed = reserved.get(other);
               charge(budget, M3.flat.text.length * 3);
-              let missing = "", otherKept = false;
+              let missing2 = "", otherKept = false;
               for (let i = 0; i < M3.flat.text.length; i++) {
                 if (SPACE2.test(M3.flat.text[i])) continue;
                 if (otherUsed[i]) otherKept = true;
-                else missing += M3.flat.text[i];
+                else missing2 += M3.flat.text[i];
               }
-              if (otherKept && missing === remainder) {
+              if (otherKept && missing2 === remainder) {
                 ambiguousSources ||= /* @__PURE__ */ new Set();
                 ambiguousSources.add(source);
                 ambiguousSources.add(other);
@@ -68456,21 +69070,21 @@ function certificateGroups({
             if (competing) continue;
             const after3 = models.get(target).flat.text;
             charge(budget, to3 - from + after3.length);
-            let bi2 = from, si3 = 0;
-            while (bi2 < to3 && si3 < after3.length) {
-              while (bi2 < to3 && SPACE2.test(text4[bi2])) bi2++;
+            let bi3 = from, si3 = 0;
+            while (bi3 < to3 && si3 < after3.length) {
+              while (bi3 < to3 && SPACE2.test(text4[bi3])) bi3++;
               while (si3 < after3.length && SPACE2.test(after3[si3])) si3++;
-              if (bi2 >= to3 || si3 >= after3.length) break;
+              if (bi3 >= to3 || si3 >= after3.length) break;
               append3(
                 exactTransfers ||= [],
                 source,
                 target,
-                bi2,
-                bi2 + 1,
+                bi3,
+                bi3 + 1,
                 si3,
                 budget
               );
-              bi2++;
+              bi3++;
               si3++;
             }
             used.fill(1, from, to3);
@@ -68509,14 +69123,14 @@ function certificateGroups({
         if ((!bhard || !shard) && !exactTransfers) continue;
         const matches = exactTransfers || [];
         if (bhard && shard && bhard === shard) {
-          let ti2 = 0, tj = 0, bi2 = 0, sj = 0;
+          let ti2 = 0, tj = 0, bi3 = 0, sj = 0;
           while (ti2 < bt3.length && tj < st3.length) {
             const x3 = bt3[ti2], y2 = st3[tj];
-            while (bi2 < x3.raw.length && SPACE2.test(x3.raw[bi2])) bi2++;
+            while (bi3 < x3.raw.length && SPACE2.test(x3.raw[bi3])) bi3++;
             while (sj < y2.raw.length && SPACE2.test(y2.raw[sj])) sj++;
-            if (bi2 === x3.raw.length) {
+            if (bi3 === x3.raw.length) {
               ti2++;
-              bi2 = 0;
+              bi3 = 0;
               continue;
             }
             if (sj === y2.raw.length) {
@@ -68534,12 +69148,12 @@ function certificateGroups({
               matches,
               x3.unit,
               y2.unit,
-              x3.from + bi2,
-              x3.from + bi2 + 1,
+              x3.from + bi3,
+              x3.from + bi3 + 1,
               y2.from + sj,
               budget
             );
-            bi2++;
+            bi3++;
             sj++;
           }
         } else if (bhard && shard) {
@@ -69068,18 +69682,18 @@ function certifiedOrigins({
     if (depth < 1) throw exhausted;
     charge(4 * (depth + 1) * (size + depth + 1));
     const edits = diffTokens(B3, S2, depth);
-    let bi2 = 0, si3 = 0;
+    let bi3 = 0, si3 = 0;
     const equal = () => {
-      const x3 = B3[bi2++], y2 = S2[si3++];
+      const x3 = B3[bi3++], y2 = S2[si3++];
       charge(x3.len);
       if (x3.raw === y2.raw) append3(runs, x3.from, x3.to, y2.from, "retained");
     };
     for (const h of edits.hunks) {
-      while (bi2 < h.bs) equal();
-      bi2 = h.be;
+      while (bi3 < h.bs) equal();
+      bi3 = h.be;
       si3 += h.toks.length;
     }
-    while (bi2 < B3.length && si3 < S2.length) equal();
+    while (bi3 < B3.length && si3 < S2.length) equal();
   };
   const compile4 = (side) => {
     const selected = certificates.filter(
@@ -69087,7 +69701,7 @@ function certifiedOrigins({
     );
     if (!selected.length) return null;
     const anchors = [];
-    const add2 = (run, models, kind) => {
+    const add3 = (run, models, kind) => {
       if (!sets[0].has(run.source) || !sets[side].has(run.target)) return;
       const bp = project2(models.get(run.source).flat, flats[0]);
       const sp = project2(models.get(run.target).flat, flats[side]);
@@ -69102,9 +69716,9 @@ function certifiedOrigins({
     for (const cert of selected) {
       if (!retainedArrays.has(cert.retained)) {
         retainedArrays.add(cert.retained);
-        for (const run of cert.retained) add2(run, cert.models, "retained");
+        for (const run of cert.retained) add3(run, cert.models, "retained");
       }
-      for (const run of cert.runs) add2(run, cert.models, "transfer");
+      for (const run of cert.runs) add3(run, cert.models, "transfer");
     }
     anchors.sort((a, b2) => {
       charge(1);
@@ -69121,15 +69735,15 @@ function certifiedOrigins({
       } else ordered.push(run);
     }
     const runs = [];
-    let bi2 = 0, si3 = 0;
+    let bi3 = 0, si3 = 0;
     for (const run of ordered) {
       if (run.target < si3) throw exhausted;
-      gap(runs, side, bi2, run.from, si3, run.target);
+      gap(runs, side, bi3, run.from, si3, run.target);
       runs.push(run);
-      bi2 = run.to;
+      bi3 = run.to;
       si3 = run.target + run.to - run.from;
     }
-    gap(runs, side, bi2, flats[0].text.length, si3, flats[side].text.length);
+    gap(runs, side, bi3, flats[0].text.length, si3, flats[side].text.length);
     const result = compileOccurrenceMap({
       base: flats[0],
       side: flats[side],
@@ -71545,10 +72159,10 @@ function mergePageModels(base, current, incoming, { doc, merge3: merge33, mergeJ
     }
     const res = merge33(inlineOf2(was, doc), inlineOf2(l, doc), inlineOf2(r44, doc));
     for (const k2 of res.conflicts) conflicts.push({ id, kind: "text", local: k2.local?.textContent ?? null, remote: k2.remote?.textContent ?? null });
-    const [merged] = parseModel(res.root, { seed: "", known: /* @__PURE__ */ new Map() });
+    const [merged2] = parseModel(res.root, { seed: "", known: /* @__PURE__ */ new Map() });
     for (const t of [c2.get(id), i2.get(id)]) {
-      t.c = merged.c;
-      if (merged.m) t.m = merged.m;
+      t.c = merged2.c;
+      if (merged2.m) t.m = merged2.m;
       else delete t.m;
     }
   }
@@ -71630,7 +72244,7 @@ function rebasePage({ storedHtml, state, incomingHtml, baseHtml, createDocument
   const base = articleOf(baseHtml, doc);
   const stored = articleOf(storedHtml, doc);
   if (!incoming || !base || !stored) return null;
-  const merged = mergePageModels(
+  const merged2 = mergePageModels(
     parseModel(base.article, { seed: rev, known }),
     parseModel(stored.article, { seed: state.rev, known }),
     parseModel(incoming.article, { seed: rev, known }),
@@ -71638,13 +72252,13 @@ function rebasePage({ storedHtml, state, incomingHtml, baseHtml, createDocument
   );
   const fallbackOf = (id) => typeof blocks[id]?.artifact?.fallbackHtml === "string" ? blocks[id].artifact.fallbackHtml : "";
   const inner = `
-${renderModel(merged.items, { fallbackOf, clean: fragmentCleaner(doc) })}
+${renderModel(merged2.items, { fallbackOf, clean: fragmentCleaner(doc) })}
 `;
   const [innerStart, innerEnd] = incoming.inner;
   const open = stampOpen(incomingHtml, incoming.startTag, state.rev);
   const body = incomingHtml.slice(0, incoming.startTag.startOffset) + open + inner + incomingHtml.slice(innerEnd);
   const html3 = withPageFormatFloor(body, Math.max(pageFormatFloor(storedHtml), pageFormatFloor(incomingHtml)));
-  return { html: html3, conflicts: merged.conflicts };
+  return { html: html3, conflicts: merged2.conflicts };
 }
 function closestBase(candidates, incomingHtml, createDocument) {
   if (candidates.length <= 1) return candidates[0] ?? null;
@@ -72020,6 +72634,163 @@ function pageTransitionState(transition, clientId) {
 // src/server/rooms/live-data-rooms.js
 var import_node_crypto3 = require("node:crypto");
 var import_node_util = require("node:util");
+
+// src/live/page-compaction.js
+var COMPACTION = Object.freeze({
+  version: 1,
+  loose: 32,
+  soft: 16,
+  activeBytes: 3840 * 1024,
+  deleteReserve: 64 * 1024,
+  newPerFrame: 4,
+  tailFloor: 64 * 1024,
+  leaseMs: 60 * 1e3,
+  retired: 8192
+});
+var ROOM_ERROR_STATUS = Object.freeze({
+  "checkpoint-required": 503,
+  "page-full": 409,
+  "compaction-failed": 409,
+  "page-immutable": 409,
+  "page-batch": 409,
+  "page-update-invalid": 422,
+  "page-upgrade": 404
+});
+var CLIENT_KEY = /^[ur][0-9a-z]+(-[0-9a-z]+){2}$/;
+var HOST_KEY = /^[ctf][0-9a-z]{8}-[0-9a-z]+(-[0-9a-z]+)?$/;
+var CHECKPOINT_KEY = /^(seed|c[0-9a-z]{8}-[0-9a-z]+)$/;
+var isCheckpointKey = (key) => CHECKPOINT_KEY.test(key);
+function pageShape(y2, limits = COMPACTION) {
+  let checkpoints = 0, loose = 0, parts = 0, legacy = 0;
+  for (const key of Object.keys(y2)) {
+    if (PART_KEY.test(key)) {
+      parts++;
+      continue;
+    }
+    if (isCheckpointKey(key)) checkpoints++;
+    else loose++;
+    if (!CLIENT_KEY.test(key) && !HOST_KEY.test(key) && key !== "seed") legacy++;
+  }
+  return { checkpoints, loose, parts, legacy, normal: parts === 0 && checkpoints <= 1 && loose <= limits.loose };
+}
+function planCompaction(y2, { overflow = false } = {}, limits = COMPACTION) {
+  const shape = pageShape(y2, limits);
+  const entries = entriesOf2(y2);
+  const checkpoint = entries.filter(([key]) => isCheckpointKey(key));
+  const loose = entries.filter(([key]) => !isCheckpointKey(key));
+  const looseBytes = loose.reduce((sum, [, v3]) => sum + v3.length, 0);
+  const checkpointBytes = checkpoint.reduce((sum, [, v3]) => sum + v3.length, 0);
+  const full = !shape.normal || overflow || looseBytes > Math.max(limits.tailFloor, checkpointBytes / 4);
+  if (full) return { kind: "full", sources: entries };
+  if (loose.length < 2 || shape.loose < limits.soft) return null;
+  return { kind: "tail", sources: loose };
+}
+function buildCandidate({ kind, sources, encode = Ic }) {
+  const updates = sources.map(([, v3]) => Lo2(v3));
+  if (kind === "tail") {
+    const merged2 = Tn2(updates);
+    const index2 = rangesOf(merged2);
+    for (const update2 of updates) if (!within(index2, rangesOf(update2))) return { failure: "not-covered" };
+    return { update: No2(merged2) };
+  }
+  const doc = new Ct2({ gc: true });
+  try {
+    for (const update2 of updates) Fr2(doc, update2);
+    if (doc.store.pendingStructs || doc.store.pendingDs) {
+      const merged2 = Tn2(updates);
+      const index3 = rangesOf(merged2);
+      for (const update2 of updates) if (!within(index3, rangesOf(update2))) return { failure: "not-covered" };
+      return { update: No2(merged2), pending: true };
+    }
+    const index2 = docRanges(doc);
+    for (const update2 of updates) if (!within(index2, rangesOf(update2))) return { failure: "not-covered" };
+    const out = No2(encode(doc));
+    const check = new Ct2({ gc: true });
+    try {
+      Fr2(check, Lo2(out));
+      const stored = docRanges(check);
+      if (!stored.complete) return { failure: "not-covered" };
+      for (const update2 of updates) if (!within(stored, rangesOf(update2))) return { failure: "not-covered" };
+    } finally {
+      check.destroy();
+    }
+    return { update: out };
+  } catch (error) {
+    return { failure: "invalid-update", message: error?.message || String(error) };
+  } finally {
+    doc.destroy();
+  }
+}
+function checkUpdate(text4) {
+  if (typeof text4 !== "string" || !isBase64(text4)) return null;
+  try {
+    const { items, deletes } = rangesOf(Lo2(text4));
+    let deleted = 0;
+    for (const spans of deletes.values()) for (const [from, to3] of spans) deleted += to3 - from;
+    return { deleted, inserts: items.size > 0 };
+  } catch {
+    return null;
+  }
+}
+function admitPageOps({ y: y2, ops, state, limits }) {
+  if (state.compaction !== limits.version) return { error: "page-upgrade" };
+  let added = 0;
+  let deleted = 0;
+  let inserts = false;
+  for (const op of ops) {
+    const key = op.path?.[1];
+    if (op.op !== "set" || typeof key !== "string" || !CLIENT_KEY.test(key)) return { error: "page-immutable" };
+    if (Object.hasOwn(y2, key)) {
+      if (y2[key] !== op.value) return { error: "page-immutable" };
+      continue;
+    }
+    if (state.retired.has(key)) return { error: "page-immutable" };
+    const checked = checkUpdate(op.value);
+    if (!checked) return { error: "page-update-invalid" };
+    added += 1;
+    deleted += checked.deleted;
+    inserts ||= checked.inserts;
+  }
+  if (added > limits.newPerFrame) return { error: "page-batch" };
+  if (state.failed) return { added, deleted, inserts, limit: limits.activeBytes + (inserts ? 0 : limits.deleteReserve), shape: null, failed: true };
+  const shape = pageShape(y2, limits);
+  if (!shape.normal || shape.loose + added > limits.loose) return { error: "checkpoint-required", retryAfter: 0 };
+  return { added, deleted, inserts, limit: limits.activeBytes + (inserts ? 0 : limits.deleteReserve), shape };
+}
+var UNIQUE_KEY = (key) => CLIENT_KEY.test(key) || HOST_KEY.test(key);
+function createRangeCache(max = 256) {
+  const cache = /* @__PURE__ */ new Map();
+  return (key, value) => {
+    const hit = cache.get(key);
+    if (hit && hit.value === value) return hit.ranges;
+    const ranges = rangesOf(Lo2(value));
+    cache.delete(key);
+    cache.set(key, { value, ranges });
+    if (cache.size > max) cache.delete(cache.keys().next().value);
+    return ranges;
+  };
+}
+function unionFileEntries({ y: y2, fileY, retired, rangesFor, keyFor = (i, key) => key }) {
+  const roomEntries = entriesOf2(y2);
+  const have = new Map(roomEntries);
+  let index2 = null;
+  const adds = [];
+  for (const [key, value] of entriesOf2(fileY ?? {})) {
+    if (have.get(key) === value) continue;
+    if (retired.has(key) && UNIQUE_KEY(key)) continue;
+    let ranges;
+    try {
+      ranges = rangesOf(Lo2(value));
+    } catch {
+      continue;
+    }
+    index2 ??= unite(roomEntries.map(([k2, v3]) => rangesFor(k2, v3)));
+    if (!within(index2, ranges)) adds.push([key, value]);
+  }
+  return adds.map(([key, value], i) => [keyFor(i, key), value]);
+}
+
+// src/server/rooms/live-data-rooms.js
 var byteLength = (text4) => Buffer.byteLength(text4, "utf8");
 var sizeOf = (value) => byteLength(serializeLive(value));
 var LIVE_LIMITS = Object.freeze({
@@ -72038,6 +72809,7 @@ var LIVE_LIMITS = Object.freeze({
   movesBytes: 1024 * 1024
 });
 var PAGE4 = /^page(\.[0-9]+)?$/;
+var COMPACTOR = "compactor";
 var isContainer2 = (v3) => v3 !== null && typeof v3 === "object";
 function seedStores(html3, { pageOnly = false, heldBytes = 0, heldCount = 0 } = {}) {
   const stores = /* @__PURE__ */ new Map();
@@ -72131,7 +72903,32 @@ var PersistentReservationError = class extends Error {
     this.code = code;
   }
 };
-function createRooms({ now = Date.now, newEpoch = import_node_crypto3.randomUUID, liveBytes = LIVE_LIMITS.liveBytes } = {}) {
+function createRooms({ now = Date.now, newEpoch = import_node_crypto3.randomUUID, liveBytes = LIVE_LIMITS.liveBytes, compaction = null } = {}) {
+  const hostLimits = compaction ? Object.freeze({ ...COMPACTION, ...typeof compaction === "object" ? compaction : {} }) : null;
+  const jobs = /* @__PURE__ */ new WeakMap();
+  let onDue = () => {
+  };
+  const hostMode = (yjs) => hostLimits && yjs ? { fence: 0, job: null, lastFull: null, deletesSince: 0, contentSeq: 0, failed: null, retired: /* @__PURE__ */ new Set(), legacy: /* @__PURE__ */ new Set(), ranges: createRangeCache() } : null;
+  const projectRoom = (room) => {
+    const compaction2 = room.compaction;
+    if (!compaction2) return structuredClone(room);
+    room.compaction = null;
+    let projected;
+    try {
+      projected = structuredClone(room);
+    } finally {
+      room.compaction = compaction2;
+    }
+    projected.compaction = { ...structuredClone({ ...compaction2, job: null, ranges: null }), ranges: createRangeCache() };
+    return projected;
+  };
+  const due = (room, overflow = false) => {
+    if (!room.compaction || room.compaction.job || room.compaction.failed) return;
+    try {
+      onDue(room, { overflow });
+    } catch {
+    }
+  };
   const rooms = /* @__PURE__ */ new Map();
   const pageReservations = /* @__PURE__ */ new Map();
   const reservedNodes = /* @__PURE__ */ new Map();
@@ -72152,7 +72949,8 @@ function createRooms({ now = Date.now, newEpoch = import_node_crypto3.randomUUID
     lastSentAt: /* @__PURE__ */ new Map(),
     seen: /* @__PURE__ */ new Map(),
     emptySince: null,
-    ...inspectPage(html3).kind === "yjs" && { pageTransition: makePageTransition() }
+    ...inspectPage(html3).kind === "yjs" && { pageTransition: makePageTransition() },
+    compaction: hostMode(inspectPage(html3).kind === "yjs")
   });
   const roomBytes = (room) => {
     let total = 0;
@@ -72160,10 +72958,91 @@ function createRooms({ now = Date.now, newEpoch = import_node_crypto3.randomUUID
     return total;
   };
   const heldBy = (room) => {
-    let total = (room.receiptBytes ?? 0) + (room.pageTransition?.bytes ?? 0);
+    let total = (room.receiptBytes ?? 0) + (room.pageTransition?.bytes ?? 0) + (room.compaction?.job?.reserved ?? 0);
     for (const s of room.stores.values()) total += s.bytes + s.logBytes;
     return total;
   };
+  const admit = (room, store, frame, ops) => {
+    const state = room.compaction;
+    const answer = admitPageOps({ y: store.value.y, ops, state: { ...room.compaction, compaction: frame.compaction }, limits: hostLimits });
+    if (answer.error) {
+      if (answer.error === "checkpoint-required") due(room);
+      return answer;
+    }
+    const { added, deleted, limit, shape } = answer;
+    return {
+      limit,
+      over() {
+        if (answer.failed || state.lastFull && state.deletesSince === 0) return { error: "page-full" };
+        due(room, true);
+        return { error: "checkpoint-required", retryAfter: 0 };
+      },
+      admitted(bytes) {
+        state.deletesSince += deleted;
+        state.contentSeq = room.seq;
+        if (answer.failed) return;
+        if (bytes > hostLimits.activeBytes) due(room, true);
+        else if (shape.loose + added >= hostLimits.soft) due(room);
+      }
+    };
+  };
+  const mergePageFile = (room, store, value) => {
+    const state = room.compaction;
+    if (value.g !== store.value.g) return null;
+    const adds = unionFileEntries({
+      y: store.value.y,
+      fileY: value.y,
+      retired: state.retired,
+      rangesFor: state.ranges,
+      keyFor: (i) => `f${textHash(room.epoch).slice(0, 8)}-${(room.seq + 1).toString(36)}-${i.toString(36)}`
+    });
+    const seq = room.seq + 1;
+    const taken = /* @__PURE__ */ new Set();
+    const ops = [];
+    for (const [key, v3] of adds) {
+      if (Object.hasOwn(store.value.y, key) || taken.has(key)) continue;
+      taken.add(key);
+      ops.push(validateOp({ op: "set", path: ["y", key], value: v3 }));
+    }
+    if (!ops.length) return null;
+    const fits = (n) => n <= LIVE_LIMITS.storeBytes && roomBytes(room) - store.bytes + n <= LIVE_LIMITS.roomBytes;
+    let next2 = applyOps(cloneJson(store.value), ops);
+    let bytes = sizeOf(next2);
+    if (!fits(bytes)) {
+      const built = buildCandidate({ kind: "full", sources: [...entriesOf2(store.value.y), ...adds] });
+      if (!built.update || built.pending) return "dropped";
+      const retire = Object.keys(store.value.y);
+      ops.length = 0;
+      for (const key of retire) ops.push(validateOp({ op: "del", path: ["y", key] }));
+      ops.push(validateOp({ op: "set", path: ["y", `c${textHash(room.epoch).slice(0, 8)}-${seq.toString(36)}`], value: built.update }));
+      next2 = applyOps(cloneJson(store.value), ops);
+      bytes = sizeOf(next2);
+      if (!fits(bytes)) return "dropped";
+      for (const [key] of entriesOf2(store.value.y)) {
+        state.retired.add(key);
+        if (state.retired.size > hostLimits.retired) state.retired.delete(state.retired.values().next().value);
+      }
+    }
+    const logged = byteLength(JSON.stringify(ops));
+    store.value = next2;
+    store.bytes = bytes;
+    room.seq = seq;
+    store.last = seq;
+    store.log.push({ seq, ops, bytes: logged, merge: true });
+    store.inFile.add(seq);
+    store.logBytes += logged;
+    evict(store);
+    state.contentSeq = seq;
+    state.lastFull = null;
+    due(room);
+    return true;
+  };
+  const endJob = (job) => {
+    if (job.room.compaction?.job !== job) return false;
+    job.room.compaction.job = null;
+    if (rooms.get(job.room.key) === job.room) used -= job.reserved;
+    return true;
+  };
   const pageSource = (key, nodeId) => {
     if (nodeId == null) throw new PageConversionError("invalid-document");
     if (pageReservations.has(key) || persistentReservations.has(key) || reservedNodes.has(String(nodeId))) throw new PageConversionError("page-converting");
@@ -72233,62 +73112,77 @@ function createRooms({ now = Date.now, newEpoch = import_node_crypto3.randomUUID
           if (tag.name !== "page" || !isYPageValue(value)) continue;
         } else if (isYPageValue(value, { complete: false })) continue;
       }
+      const host = Boolean(room.compaction && tag.name === "page" && room.pageTransition?.format === "yjs");
       const before2 = store.landed;
       const base = baseOf(room, store, tag.at);
       const stamped = placed(room, store, tag.at) && tag.at.hash === textHash(serializeLive(value));
-      if (base < store.floor) {
+      if (!host && base < store.floor) {
         store.landed = -1;
         if (before2 !== -1) landed.push(tag.name);
         continue;
       }
       const by = restored ? null : provenBy(room, tag.name, tag, stamped);
       const frames = tag.at?.epoch === room.epoch ? frameSet(by) : [];
-      const ancestry = descendants(by);
-      const own = (entry) => {
-        if (!by) return false;
-        if (!entry.merge) return contains2(frames, entry.from, entry.n);
-        const p = entry.provenance;
-        return by.v === 2 && p && p.at.epoch === tag.at.epoch && p.at.seq === tag.at.seq && contains2(ancestry, ...p.capture);
-      };
-      if (stamped) store.inFile.clear();
-      const entries = [];
-      for (const entry of store.log) {
-        if (entry.seq <= base) continue;
-        if (own(entry)) store.inFile.add(entry.seq);
-        else if (stamped || !store.inFile.has(entry.seq)) entries.push(entry);
-      }
-      for (const entry of entries) {
-        for (const op of entry.ops) {
-          try {
-            checkOp(value, op);
-            value = applyOp(value, op);
-          } catch {
-          }
-        }
-      }
-      const text4 = serializeLive(value);
-      if (text4 !== serializeLive(store.value)) {
-        const bytes = byteLength(text4);
-        if (bytes > LIVE_LIMITS.storeBytes || roomBytes(room) - store.bytes + bytes > LIVE_LIMITS.roomBytes) {
+      if (host) {
+        const merged2 = mergePageFile(room, store, value);
+        if (merged2 === "dropped") {
           room.stores.delete(tag.name);
           valueChanged = true;
           continue;
         }
-        const ops = diffOps(store.value, value);
-        store.value = value;
-        store.bytes = bytes;
-        room.seq += 1;
-        store.last = room.seq;
-        const provenance = by?.v === 2 ? { at: { epoch: tag.at.epoch, seq: tag.at.seq }, by: by.frames, capture: by.capture } : null;
-        const logged = byteLength(JSON.stringify(provenance ? { ops, provenance } : ops));
-        store.log.push({ seq: room.seq, ops, bytes: logged, merge: true, ...provenance && { provenance } });
-        store.inFile.add(room.seq);
-        store.logBytes += logged;
-        evict(store);
-        valueChanged = true;
+        if (merged2) valueChanged = true;
+        if (stamped && tag.at.epoch === room.epoch) {
+          store.landed = tag.at.seq >= room.compaction.contentSeq ? store.last : tag.at.seq;
+          if (store.landed !== before2) landed.push(tag.name);
+        }
+      } else {
+        const ancestry = descendants(by);
+        const own = (entry) => {
+          if (!by) return false;
+          if (!entry.merge) return contains2(frames, entry.from, entry.n);
+          const p = entry.provenance;
+          return by.v === 2 && p && p.at.epoch === tag.at.epoch && p.at.seq === tag.at.seq && contains2(ancestry, ...p.capture);
+        };
+        if (stamped) store.inFile.clear();
+        const entries = [];
+        for (const entry of store.log) {
+          if (entry.seq <= base) continue;
+          if (own(entry)) store.inFile.add(entry.seq);
+          else if (stamped || !store.inFile.has(entry.seq)) entries.push(entry);
+        }
+        for (const entry of entries) {
+          for (const op of entry.ops) {
+            try {
+              checkOp(value, op);
+              value = applyOp(value, op);
+            } catch {
+            }
+          }
+        }
+        const text4 = serializeLive(value);
+        if (text4 !== serializeLive(store.value)) {
+          const bytes = byteLength(text4);
+          if (bytes > LIVE_LIMITS.storeBytes || roomBytes(room) - store.bytes + bytes > LIVE_LIMITS.roomBytes) {
+            room.stores.delete(tag.name);
+            valueChanged = true;
+            continue;
+          }
+          const ops = diffOps(store.value, value);
+          store.value = value;
+          store.bytes = bytes;
+          room.seq += 1;
+          store.last = room.seq;
+          const provenance = by?.v === 2 ? { at: { epoch: tag.at.epoch, seq: tag.at.seq }, by: by.frames, capture: by.capture } : null;
+          const logged = byteLength(JSON.stringify(provenance ? { ops, provenance } : ops));
+          store.log.push({ seq: room.seq, ops, bytes: logged, merge: true, ...provenance && { provenance } });
+          store.inFile.add(room.seq);
+          store.logBytes += logged;
+          evict(store);
+          valueChanged = true;
+        }
+        store.landed = entries.length ? base : store.last;
+        if (store.landed !== before2) landed.push(tag.name);
       }
-      store.landed = entries.length ? base : store.last;
-      if (store.landed !== before2) landed.push(tag.name);
       if (by?.v === 2) {
         for (const [client, ranges] of frames) {
           if (!saveReceipt(room, tag.name + "\n" + client, ranges, store.last, LIVE_LIMITS.receipts, pageReservations.get(key)?.receipts)) {
@@ -72359,6 +73253,7 @@ function createRooms({ now = Date.now, newEpoch = import_node_crypto3.randomUUID
         reservation.result = null;
         return null;
       }
+      if (room.compaction?.job) endJob(room.compaction.job);
       const before2 = heldBy(room);
       const { stores, transition } = reservation.target;
       for (const name of room.stores.keys()) if (PAGE4.test(name)) room.stores.delete(name);
@@ -72375,6 +73270,7 @@ function createRooms({ now = Date.now, newEpoch = import_node_crypto3.randomUUID
         bytes += store.bytes;
       }
       room.pageTransition = transition;
+      if (hostLimits) room.compaction = hostMode(transition.format === "yjs");
       reservation.target = null;
       used += heldBy(room) - before2 - reservation.budget;
       reservation.budget = 0;
@@ -72454,7 +73350,7 @@ function createRooms({ now = Date.now, newEpoch = import_node_crypto3.randomUUID
         if (!store || store.ephemeral) throw new PersistentReservationError("invalid-target");
       }
       const currentHeld = heldBy(record5.room);
-      const projected = structuredClone(record5.room);
+      const projected = projectRoom(record5.room);
       reconcileFile(projected, record5.key, html3, {});
       for (const [name, store] of record5.room.stores) {
         if (!store.ephemeral && !projected.stores.has(name)) throw new PersistentReservationError("budget");
@@ -72633,6 +73529,8 @@ function createRooms({ now = Date.now, newEpoch = import_node_crypto3.randomUUID
       }
       const nKey = frame.name + "\n" + clientId;
       const last2 = room.lastN.get(nKey);
+      const admission = room.compaction && frame.name === "page" && !receiptHas(last2, frame.n) ? admit(room, store, frame, ops) : null;
+      if (admission?.error) return admission;
       if (receiptHas(last2, frame.n)) return { duplicate: true, seq: frame.n <= last2.n ? last2.seq : last2.savedSeq, epoch: room.epoch };
       if ((room.retiredReceipts?.get(nKey) ?? 0) > (frame.receiptGeneration ?? 0)) return { error: "receipt-expired" };
       let victim = null;
@@ -72680,8 +73578,13 @@ function createRooms({ now = Date.now, newEpoch = import_node_crypto3.randomUUID
       }
       if (bytes > LIVE_LIMITS.storeBytes || roomBytes(room) - store.bytes + bytes > LIVE_LIMITS.roomBytes) {
         undo();
+        if (admission) return admission.over(bytes);
         return { error: "too-large" };
       }
+      if (admission && bytes > admission.limit) {
+        undo();
+        return admission.over(bytes);
+      }
       const logged = done.length ? byteLength(JSON.stringify(ops)) : 0;
       const grows = done.length ? bytes - store.bytes + logAfter(store, logged) - store.logBytes : 0;
       const retiredBytes = victim === null ? 0 : receiptBytes(room.lastN.get(victim));
@@ -72705,18 +73608,36 @@ function createRooms({ now = Date.now, newEpoch = import_node_crypto3.randomUUID
       room.lastSentAt.set(clientId, now());
       room.seen.set(clientId, now());
       if (PAGE4.test(frame.name) && typeof frame.adopted === "string" && frame.adopted.length <= 64) room.adopted = frame.adopted;
+      if (admission && done.length) admission.admitted(bytes);
       const writerGone = room.writer && connected && !connected.includes(room.writer);
       if ((!room.writer || writerGone) && (!connected || connected.includes(clientId))) room.writer = clientId;
       return { seq: room.seq, epoch: room.epoch, name: frame.name, ops, writer: room.writer, checkpoint: pressed(store), receiptGeneration: room.receiptGeneration ?? 0, ...transition && { pageGeneration: transition.id } };
     },
     /** Everything a joining tab needs, with clientId's own receipt per store. Values are the room's own objects: serialize, never mutate. With since in this room's epoch, moves carries each store's log entries after since.seq (null where the log no longer reaches back that far). */
-    state(room, clientId = null, since = void 0) {
+    state(room, clientId = null, since = void 0, { compaction: capable } = {}) {
       const stores = {};
+      const legacy = room.compaction?.legacy;
+      if (legacy && clientId && capable !== void 0) {
+        if (capable === hostLimits.version) legacy.delete(clientId);
+        else legacy.add(clientId);
+      }
+      const hidden = Boolean(legacy && (capable !== void 0 ? capable !== hostLimits.version : clientId && legacy.has(clientId)));
       for (const [name, s] of room.stores) {
+        if (hidden && name === "page") continue;
         const seen = {};
         const mine = clientId ? room.lastN.get(name + "\n" + clientId) : null;
         if (mine) seen[clientId] = mine.n;
-        stores[name] = { value: s.value, ephemeral: s.ephemeral, from: s.from, landed: s.landed, floor: s.floor, last: s.last, seen, ...mine?.saved?.length && { saved: mine.saved } };
+        stores[name] = {
+          value: s.value,
+          ephemeral: s.ephemeral,
+          from: s.from,
+          landed: s.landed,
+          floor: s.floor,
+          last: s.last,
+          seen,
+          ...mine?.saved?.length && { saved: mine.saved },
+          ...name === "page" && room.compaction && { compaction: { v: hostLimits.version, loose: hostLimits.loose, activeBytes: hostLimits.activeBytes } }
+        };
       }
       const provenance = { provenanceVersion: 2, receiptGeneration: room.receiptGeneration ?? 0 };
       if (room.pageTransition) {
@@ -72754,7 +73675,10 @@ function createRooms({ now = Date.now, newEpoch = import_node_crypto3.randomUUID
       if (room.writer !== clientId) return { writerChanged: false, writer: room.writer };
       let best = null;
       let bestAt = -1;
-      for (const id of remaining.filter((candidate) => room.seen.has(candidate))) {
+      const seen = remaining.filter((candidate) => room.seen.has(candidate));
+      const legacy = room.compaction?.legacy;
+      const capable = legacy ? seen.filter((candidate) => !legacy.has(candidate)) : seen;
+      for (const id of capable.length ? capable : seen) {
         const at2 = room.lastSentAt.get(id) ?? 0;
         if (at2 > bestAt) {
           best = id;
@@ -72775,6 +73699,9 @@ function createRooms({ now = Date.now, newEpoch = import_node_crypto3.randomUUID
      */
     sweep(connectedOf = () => [], { mayExpire = () => true } = {}) {
       const t = now();
+      for (const room of rooms.values()) {
+        if (room.compaction?.job && t >= room.compaction.job.deadline) endJob(room.compaction.job);
+      }
       for (const [key, room] of rooms) {
         if (!roomIsDirty(room) && mayExpire(room) && !pageReservations.has(key) && !persistentReservations.has(key) && room.emptySince !== null && t - room.emptySince >= LIVE_LIMITS.retainMs) {
           used -= heldBy(room);
@@ -72822,6 +73749,120 @@ function createRooms({ now = Date.now, newEpoch = import_node_crypto3.randomUUID
       }
       return changed;
     },
+    onCompactionDue(listener) {
+      onDue = typeof listener === "function" ? listener : () => {
+      };
+    },
+    beginCompaction(room, { overflow = false } = {}) {
+      const state = room?.compaction;
+      if (!state || rooms.get(room.key) !== room || state.failed) return null;
+      if (state.job) {
+        if (now() < state.job.deadline) return null;
+        endJob(state.job);
+      }
+      const store = room.stores.get("page");
+      if (!store || pageReservations.has(room.key) || persistentReservations.has(room.key)) return null;
+      const plan = planCompaction(store.value.y, { overflow }, hostLimits);
+      if (!plan) return null;
+      const reserved = plan.sources.reduce((sum, [k2, v3]) => sum + k2.length + v3.length, 0);
+      if (used + reserved > liveBytes) return null;
+      state.fence += 1;
+      const token = Object.freeze({ key: room.key, epoch: room.epoch, fence: state.fence });
+      const job = {
+        token,
+        room,
+        store,
+        epoch: room.epoch,
+        generation: room.pageTransition?.id ?? null,
+        kind: plan.kind,
+        sources: new Map(plan.sources),
+        physical: Object.keys(store.value.y),
+        reserved,
+        deadline: now() + hostLimits.leaseMs,
+        deletesAtBegin: state.deletesSince
+      };
+      state.job = job;
+      used += reserved;
+      jobs.set(token, job);
+      return { token, kind: plan.kind, sources: plan.sources };
+    },
+    abandonCompaction(token, { failed = null } = {}) {
+      const job = jobs.get(token);
+      if (!job) return false;
+      jobs.delete(token);
+      const ended = endJob(job);
+      if (ended && failed) job.room.compaction.failed = { reason: failed, at: now() };
+      return ended;
+    },
+    commitCompaction(token, result) {
+      const job = jobs.get(token);
+      if (!job) return { refused: "stale-token" };
+      jobs.delete(token);
+      const { room, store } = job;
+      if (!endJob(job)) return { refused: "stale-token" };
+      if (rooms.get(room.key) !== room || room.epoch !== job.epoch || room.stores.get("page") !== store || (room.pageTransition?.id ?? null) !== job.generation) return { refused: "stale-token" };
+      const y2 = store.value.y;
+      const retire = job.physical.filter((k2) => {
+        const part = PART_KEY.exec(k2);
+        return job.sources.has(part ? part[1] : k2) || part && job.kind === "full";
+      });
+      if (retire.some((k2) => !Object.hasOwn(y2, k2))) return { refused: "sources-changed" };
+      const held = new Map(entriesOf2(Object.fromEntries(retire.map((k2) => [k2, y2[k2]]))));
+      for (const [k2, v3] of job.sources) if (held.get(k2) !== v3) return { refused: "sources-changed" };
+      if (typeof result?.update !== "string" || !checkUpdate(result.update)) return { refused: "bad-candidate" };
+      const key = `${job.kind === "full" ? "c" : "t"}${textHash(room.epoch).slice(0, 8)}-${(room.seq + 1).toString(36)}`;
+      if (Object.hasOwn(y2, key)) return { refused: "bad-candidate" };
+      const ops = [...retire.map((k2) => ({ op: "del", path: ["y", k2] })), { op: "set", path: ["y", key], value: result.update }].map(validateOp);
+      let value = store.value;
+      let bytes = store.bytes;
+      const done = [];
+      for (const op of ops) {
+        const rec = applyTracked(value, op);
+        if (!rec) continue;
+        done.push(rec);
+        bytes += sizeChange(rec, sizeOf, bytes);
+        value = rec.root;
+      }
+      if (bytes > hostLimits.activeBytes && bytes > store.bytes) {
+        for (let i = done.length - 1; i >= 0; i--) undoTracked(done[i]);
+        if (job.kind === "full" && retire.length === Object.keys(y2).length) {
+          room.compaction.lastFull = { bytes: store.bytes, seq: room.seq, deletesAtBegin: job.deletesAtBegin };
+          room.compaction.deletesSince -= job.deletesAtBegin;
+        }
+        return { refused: "too-large" };
+      }
+      const clean = store.landed === store.last;
+      const logged = byteLength(JSON.stringify(ops));
+      used += bytes - store.bytes + logAfter(store, logged) - store.logBytes;
+      store.value = value;
+      store.bytes = bytes;
+      room.seq += 1;
+      store.last = room.seq;
+      if (clean) store.landed = store.last;
+      store.log.push({ seq: room.seq, ops, bytes: logged, from: COMPACTOR, n: 0 });
+      store.logBytes += logged;
+      evict(store);
+      const state = room.compaction;
+      for (const k2 of job.sources.keys()) {
+        state.retired.add(k2);
+        if (state.retired.size > hostLimits.retired) state.retired.delete(state.retired.values().next().value);
+      }
+      if (job.kind === "full") {
+        state.lastFull = { bytes, seq: room.seq, deletesAtBegin: job.deletesAtBegin };
+        state.deletesSince -= job.deletesAtBegin;
+      }
+      if (pageShape(store.value.y, hostLimits).loose >= hostLimits.soft || !pageShape(store.value.y, hostLimits).normal) due(room);
+      return {
+        seq: room.seq,
+        epoch: room.epoch,
+        name: "page",
+        ops,
+        from: COMPACTOR,
+        kind: job.kind,
+        landed: store.landed,
+        ...room.pageTransition && { pageGeneration: room.pageTransition.id }
+      };
+    },
     /** Every room's key. */
     keys() {
       return [...rooms.keys()];
@@ -72836,6 +73877,117 @@ function createRooms({ now = Date.now, newEpoch = import_node_crypto3.randomUUID
   };
 }
 
+// src/server/rooms/page-compactor.js
+var import_node_worker_threads = require("node:worker_threads");
+var import_node_url = require("node:url");
+var import_meta = {};
+var RETRY_MS = [1e3, 5e3, 3e4];
+var MODULE_URL = typeof __dirname === "string" ? (0, import_node_url.pathToFileURL)(`${__dirname}/`).href : import_meta.url;
+var WORKER_FILE = true ? "./page-compaction-worker.cjs" : "./page-compaction-worker.js";
+var pageCompactionWorkerUrl = () => new URL(WORKER_FILE, MODULE_URL);
+function createPageCompactor({
+  rooms,
+  onCommit = () => {
+  },
+  workerUrl = pageCompactionWorkerUrl(),
+  timeoutMs = 3e4,
+  WorkerClass = import_node_worker_threads.Worker,
+  setTimer = setTimeout,
+  clearTimer = clearTimeout
+} = {}) {
+  const queue = /* @__PURE__ */ new Map();
+  const retries = /* @__PURE__ */ new Map();
+  let worker = null;
+  let running = null;
+  let ids = 0;
+  let closed = false;
+  const spawn = () => {
+    const instance = new WorkerClass(workerUrl);
+    worker = instance;
+    instance.unref?.();
+    instance.on("message", (message) => {
+      if (worker === instance) finish(message);
+    });
+    instance.on("error", () => {
+      if (worker === instance) crashed();
+    });
+    instance.on("exit", () => {
+      if (worker !== instance) return;
+      worker = null;
+      if (running) crashed();
+    });
+  };
+  function crashed() {
+    const job = running;
+    if (!job) return;
+    running = null;
+    clearTimer(job.timer);
+    worker?.terminate?.();
+    worker = null;
+    const tries = (retries.get(job.room) ?? 0) + 1;
+    retries.set(job.room, tries);
+    rooms.abandonCompaction(job.token, tries > RETRY_MS.length ? { failed: "crashed" } : {});
+    if (tries <= RETRY_MS.length) setTimer(() => due(job.room, { overflow: job.overflow }), RETRY_MS[tries - 1]);
+    pump();
+  }
+  function finish({ id, ...result }) {
+    const job = running;
+    if (!job || job.id !== id) return;
+    running = null;
+    clearTimer(job.timer);
+    if (result.failure) {
+      rooms.abandonCompaction(job.token, { failed: result.failure });
+    } else {
+      const answer = rooms.commitCompaction(job.token, result);
+      if (answer.seq !== void 0) {
+        retries.delete(job.room);
+        try {
+          onCommit(job.room, answer);
+        } catch {
+        }
+      }
+    }
+    pump();
+  }
+  function pump() {
+    if (closed || running || !queue.size) return;
+    const [room, { overflow }] = queue.entries().next().value;
+    queue.delete(room);
+    const begun = rooms.beginCompaction(room, { overflow });
+    if (!begun) {
+      pump();
+      return;
+    }
+    if (!worker) spawn();
+    const id = ++ids;
+    running = { id, room, overflow, token: begun.token, timer: setTimer(crashed, timeoutMs) };
+    worker.postMessage({ id, kind: begun.kind, sources: begun.sources });
+  }
+  function due(room, { overflow = false } = {}) {
+    const queued = queue.get(room);
+    queue.set(room, { overflow: overflow || Boolean(queued?.overflow) });
+    queueMicrotask(pump);
+  }
+  rooms.onCompactionDue(due);
+  return {
+    get running() {
+      return running !== null;
+    },
+    close() {
+      closed = true;
+      rooms.onCompactionDue(null);
+      if (running) {
+        clearTimer(running.timer);
+        rooms.abandonCompaction(running.token);
+        running = null;
+      }
+      const current = worker;
+      worker = null;
+      return current?.terminate?.();
+    }
+  };
+}
+
 // src/server/checkpoint/index.js
 var checkpoint_exports = {};
 __export(checkpoint_exports, {
@@ -72968,8 +74120,8 @@ function titleTextOf(node) {
 function titleAt(placement) {
   const head = placement.head?.sourceCodeLocation;
   if (head?.startTag) return head.startTag.endOffset;
-  const inside = (placement.head?.childNodes ?? []).find((node) => node.sourceCodeLocation);
-  if (inside) return inside.sourceCodeLocation.startOffset;
+  const inside2 = (placement.head?.childNodes ?? []).find((node) => node.sourceCodeLocation);
+  if (inside2) return inside2.sourceCodeLocation.startOffset;
   const body = placement.body?.sourceCodeLocation;
   if (body?.startTag) return body.startTag.startOffset;
   const first2 = (placement.body?.childNodes ?? []).find((node) => node.sourceCodeLocation);
@@ -72986,8 +74138,8 @@ function titleEdit(placement, title) {
 }
 function holdsEdit(found, blocks, doc) {
   const current = readBack(blocks, doc);
-  const merged = mergePageModels(found.baseItems, current, found.parsed, { doc, merge3: merge32, mergeJson });
-  return canon(merged.items) === canon(current);
+  const merged2 = mergePageModels(found.baseItems, current, found.parsed, { doc, merge3: merge32, mergeJson });
+  return canon(merged2.items) === canon(current);
 }
 var lastAdoption = { html: null, answer: false };
 function needsAdoption(html3, { createDocument }) {