@panphora/clayjs 1.17.0 → 1.18.1

package/src/page/format-gate.js

@@ -29,6 +29,9 @@
 // lands between `capabilities()` and `activate()` is refused rather than missed.
 
 import { PAGE_FORMAT, PAGE_FORMAT_EXTENSION, PAGE_FORMAT_UPGRADE, formatCapability, notePageFormatFloor, pageFormatDecision, pageFormatFloor } from "./format-level.js";
+import { registerUnsavedState } from "../lib/unsaved-state.js";
+
+const PENDING_COMMAND = "page-format-command";
 
 const UPGRADE_MESSAGE = "This document uses a newer page format; update the editor in the other tabs to keep writing";
 
@@ -46,6 +49,10 @@ export function createFormatGate({
   let floor = 0;
   let pending = null;
   let lanePending = false;
+  let laneReceipt = null;
+  let laneAsked = false;
+  let laneJoin = Promise.resolve(false);
+  let laneJoining = null;
   let disposed = false;
 
   // The floor this gate knows the document at. A save or a room answer can tell
@@ -54,9 +61,22 @@ export function createFormatGate({
   function note(level) {
     floor = Math.max(floor, formatCapability(level));
     notePageFormatFloor(floor);
+    if (floor >= PAGE_FORMAT) requestLane();
     return floor;
   }
 
+  // A raised floor is one lane switch per tab, however this tab learned of it:
+  // its own accepted save (activateNow joins with that receipt), another tab's
+  // write that came in with the document, or a relay's meta. A switch the lane
+  // has not accepted yet stays pending, and the retry path covers it.
+  function requestLane() {
+    if (laneAsked || disposed) return laneJoin;
+    laneAsked = true;
+    lanePending = true;
+    laneJoin = joinLane(null);
+    return laneJoin;
+  }
+
   async function read() {
     try {
       const answer = await host.read();
@@ -88,7 +108,10 @@ export function createFormatGate({
     if (disposed) return { status: "disposed", retry: false };
     if (!(await supportedHere())) return { status: "unsupported-host", code: "page-format-unsupported", extension: PAGE_FORMAT_EXTENSION };
     await read();
-    if (floor >= PAGE_FORMAT) return { status: "active", floor };
+    if (floor >= PAGE_FORMAT) {
+      await requestLane();
+      return { status: "active", floor };
+    }
     const admitted = await admittance();
     const early = pageFormatDecision({ floor, required: PAGE_FORMAT, capability, admitted });
     if (!early.ok) return upgrade(early.minimum);
@@ -106,28 +129,45 @@ export function createFormatGate({
     if (disposed) {
       // The save was accepted, so the document is at floor 1 either way; this
       // tab is gone and must not act on it.
+      laneAsked = true;
       note(PAGE_FORMAT);
       return { status: "disposed", retry: false };
     }
+    laneAsked = true;
     note(PAGE_FORMAT);
     lanePending = true;
-    await joinLane(answer.receipt ?? null);
-    return { status: "active", floor, receipt: answer.receipt ?? null };
+    laneReceipt = answer.receipt ?? null;
+    await joinLane(laneReceipt);
+    return { status: "active", floor, receipt: laneReceipt };
   }
 
   // Joining the new lane scope happens after the receipt is accepted, and only
   // then: an interrupted switch leaves this tab on floor 0's scope with every
-  // store intact and the switch still pending, never a lane it cannot cover.
+  // store intact and the switch still pending, never a lane it cannot cover. The
+  // receipt is kept, so the retry of a refused switch is covered by the same write.
   async function joinLane(receipt) {
     if (!lane || !lanePending) return false;
+    if (laneJoining) return laneJoining;
+    const covering = receipt ?? laneReceipt;
+    laneJoining = (async () => {
+      try {
+        // The receipt is what says the pending work went with an accepted write.
+        const result = await lane.switchScope(PAGE_FORMAT, { covered: Boolean(covering), receipt: covering });
+        // "already" is the lane answering that this tab is on that scope: the
+        // join held, and there is nothing left pending.
+        if (result && (result.status === "switched" || result.status === "already")) {
+          lanePending = false;
+          laneReceipt = null;
+          return true;
+        }
+      } catch {}
+      return false;
+    })();
     try {
-      const result = await lane.switchTo({ floor: PAGE_FORMAT, receipt });
-      if (result && result.status === "switched") {
-        lanePending = false;
-        return true;
-      }
-    } catch {}
-    return false;
+      return await laneJoining;
+    } finally {
+      laneJoining = null;
+    }
   }
 
   function activate() {
@@ -150,16 +190,25 @@ export function createFormatGate({
     // same attempt, and a retry after a failure starts a new one.
     activate,
     // A new-format command: capture what it applies to, ask the gate, and apply
-    // only when activation succeeded and nothing moved underneath it.
+    // only when activation succeeded and nothing moved underneath it. While it waits on
+    // activation the work is unsaved and belongs to the person who asked for it: the
+    // exit asks the unsaved-state registry, and this command answers to its own name
+    // until it applies or fails, so an exit is refused rather than committing and
+    // disposing the editor underneath it.
     async run(command) {
       const stamp = { revision: revision(), installed: installed() };
-      const result = await activate();
-      if (result.status !== "active") return result;
-      if (disposed) return { status: "disposed", retry: false };
-      if (revision() !== stamp.revision || installed() !== stamp.installed) {
-        return { status: "retry", code: "format-gate-stale", retry: true };
+      const unsaved = registerUnsavedState({ id: PENDING_COMMAND, isPending: () => true });
+      try {
+        const result = await activate();
+        if (result.status !== "active") return result;
+        if (disposed) return { status: "disposed", retry: false };
+        if (revision() !== stamp.revision || installed() !== stamp.installed) {
+          return { status: "retry", code: "format-gate-stale", retry: true };
+        }
+        return { status: "applied", floor, result: await command?.apply?.(stamp) };
+      } finally {
+        unsaved.dispose();
       }
-      return { status: "applied", floor, result: await command?.apply?.(stamp) };
     },
     // Retry what is still pending: a lane switch whose receipt is in hand, or an
     // activation that failed on the wire. Unsaved work is never part of this.
@@ -173,6 +222,7 @@ export function createFormatGate({
     dispose() {
       disposed = true;
       lanePending = false;
+      laneReceipt = null;
       return { status: "disposed" };
     },
   };

package/src/page/format-host.js

@@ -27,8 +27,21 @@ function servedFloor() {
 // never uses a newer format never downloads the lane to raise one.
 const savePage = async (options) => (await import("../core/save.js")).savePageForce(() => {}, options);
 
+// A forced save asked for while another is on the wire is skipped rather than queued.
+// The activation is the person's own request, so it waits for the save ahead of it to
+// settle and asks again, instead of answering "try again" for a save it never sent.
+const SKIPPED_ATTEMPTS = 4;
+const SKIPPED_WAIT_MS = 10000;
+const skippedBehindSave = (result) => result?.ok === false && result?.msgType === "skipped" && /in progress/i.test(result?.msg ?? "");
+const saveSettles = async () => {
+  const { isSaveInProgress } = await import("../core/save-core.js");
+  const until = Date.now() + SKIPPED_WAIT_MS;
+  while (isSaveInProgress() && Date.now() < until) await new Promise((r) => setTimeout(r, 50));
+};
+
 export function createFormatHost({
   save = savePage,
+  settles = saveSettles,
   supported = () => hostPageFormat().then((floor) => floor === PAGE_FORMAT),
 } = {}) {
   return {
@@ -43,6 +56,10 @@ export function createFormatHost({
       let result;
       try {
         result = await save({ pageFormatFloor: floor });
+        for (let attempt = 1; attempt < SKIPPED_ATTEMPTS && skippedBehindSave(result); attempt += 1) {
+          await settles();
+          result = await save({ pageFormatFloor: floor });
+        }
       } catch (error) {
         return { accepted: false, code: error?.code ?? FAILED };
       }

package/src/page/format-native-commands.js

@@ -12,6 +12,7 @@ import { history } from "../vendor/prosemirror.vendor.js";
 import { schema } from "./schema.js";
 import { PALETTE, markable } from "./format-native.js";
 import { announce } from "./announce.js";
+import toast from "../ui/toast-lazy.js";
 import { openPageMenu } from "./chrome.js";
 
 // blocks.js's STEP, read here rather than imported from it: this module is part
@@ -72,8 +73,11 @@ export function formatMark(view, name, attrs = {}, { reset = false } = {}) {
 // The four formats pasted in from elsewhere are floor-1 content too: the slice is
 // inserted only once the gate answered applied. A refusal keeps the text and
 // writes no descriptor; a selection that moved while the answer came back takes
-// neither.
+// neither, and neither does a document that changed underneath the paste: the
+// plain fallback would write at a place a peer edit has moved, so the text stays
+// in the clipboard instead.
 export function pasteFormats(view, slice, from, to) {
+  const before = view.state.doc;
   const place = () => {
     if (view.isDestroyed) return false;
     const st = view.state;
@@ -83,12 +87,12 @@ export function pasteFormats(view, slice, from, to) {
   };
   const plain = () => {
     const text = slice.content.textBetween(0, slice.content.size, "\n", " ");
-    if (!view.isDestroyed && text) view.dispatch(view.state.tr.insertText(text, from, to));
+    if (!view.isDestroyed && text && view.state.doc === before) view.dispatch(view.state.tr.insertText(text, from, to));
     return false;
   };
   runFormat(view, place).then((result) => {
     if (result?.status === "applied") return;
-    if (!view.isDestroyed) announce(view, result?.message ?? "That format isn\u2019t available here.");
+    refuse(view, result?.message ?? "That format isn\u2019t available here.");
     plain();
   }, plain);
 }
@@ -106,7 +110,11 @@ export function quoteFromSpace(plugin, view, { at, from, to }, plain) {
     view.dispatch(asStep(tr.setMeta(plugin, { transform: tr, from, to, text: " " })));
     return true;
   };
-  view.runFormatCommand(convert).then((result) => { if (result?.status !== "applied") plain(); }, plain);
+  view.runFormatCommand(convert).then((result) => {
+    if (result?.status === "applied") return;
+    if (result) refuse(view, refusalText(result));
+    plain();
+  }, plain);
 }
 
 // The More menu's rows: the underline command, the palette of a color mark and
@@ -115,8 +123,16 @@ export function quoteFromSpace(plugin, view, { at, from, to }, plain) {
 const CANNOT_MARK = "This text can\u2019t take that format.";
 const refusalText = (result) => (result.status === "upgrade-required" ? result.message : result.code === "mark-not-allowed" ? CANNOT_MARK : "That format isn\u2019t available here.");
 
+// A refusal is said to a screen reader and shown, since a sighted reader whose
+// click did nothing otherwise has no way to know why.
+export const refuse = (view, text) => {
+  if (view.isDestroyed) return;
+  announce(view, text);
+  toast(text, "error");
+};
+
 const notice = (view, result) => {
-  if (result?.status !== "applied" && !view.isDestroyed) announce(view, refusalText(result ?? {}));
+  if (result?.status !== "applied") refuse(view, refusalText(result ?? {}));
 };
 
 export const runNative = (view, name, attrs = {}, options = undefined) => {

package/src/page/image-actions.js

@@ -0,0 +1,64 @@
+// The image menu's own actions: the alt text field and the width presets, reached
+// by the chrome's actions menu. Its own module, so a document that never sets
+// either downloads neither.
+import { asStep } from "./blocksel.js";
+
+const indexOfId = (doc, id) => {
+  let found = -1;
+  doc.forEach((n, _, i) => { if (n.attrs.id === id) found = i; });
+  return found;
+};
+
+export function setImageAttrs(view, id, patch) {
+  const st = view.state;
+  const index = indexOfId(st.doc, id);
+  if (index < 0) return false;
+  let at = 0;
+  for (let i = 0; i < index; i++) at += st.doc.child(i).nodeSize;
+  const node = st.doc.child(index);
+  view.dispatch(asStep(st.tr.setNodeMarkup(at, null, { ...node.attrs, ...patch })));
+  return true;
+}
+
+export function openAltEditor(view, id) {
+  const index = indexOfId(view.state.doc, id);
+  if (index < 0) return false;
+  const shell = view.dom.parentElement;
+  const doc = shell.ownerDocument;
+  let at = 0;
+  for (let i = 0; i < index; i++) at += view.state.doc.child(i).nodeSize;
+  const box = doc.createElement("div");
+  box.className = "page-link";
+  box.dataset.mode = "alt";
+  const input = doc.createElement("input");
+  input.className = "page-link-input";
+  input.type = "text";
+  input.value = view.state.doc.child(index).attrs.alt || "";
+  input.placeholder = "Describe the image";
+  input.setAttribute("aria-label", "Alt text");
+  box.append(input);
+  const rect = view.nodeDOM(at)?.getBoundingClientRect?.();
+  const shellBox = shell.getBoundingClientRect();
+  if (rect) {
+    box.style.setProperty("--page-pop-x", `${rect.left - shellBox.left}px`);
+    box.style.setProperty("--page-pop-y", `${rect.bottom - shellBox.top + 6}px`);
+  }
+  shell.append(box);
+  let done = false;
+  const close = (commit, refocus = true) => {
+    if (done) return;
+    done = true;
+    const value = input.value.trim();
+    box.remove();
+    const i = indexOfId(view.state.doc, id);
+    if (commit && i >= 0 && value !== view.state.doc.child(i).attrs.alt) setImageAttrs(view, id, { alt: value });
+    if (refocus) view.focus();
+  };
+  input.addEventListener("keydown", (e) => {
+    if (e.key === "Enter") { e.preventDefault(); close(true); }
+    else if (e.key === "Escape") { e.preventDefault(); e.stopPropagation(); close(false); }
+  });
+  input.addEventListener("blur", () => close(true, false));
+  input.focus();
+  return true;
+}

package/src/page/import-markdown.js

@@ -0,0 +1,262 @@
+// Markdown import: the tokens marked's lexer returns become the page's flat block
+// records (model.js), so a file arrives without marked rendering anything. Raw HTML
+// stays inert: a block of it is a preserved block, cleaned of scripts, event handlers
+// and script URLs, and inline markup is literal text. A construct the schema cannot
+// express is kept as a literal code block and named in `unsupported`; a link or
+// image address the editor refuses is left out and named in `refused`, its text
+// kept. Nothing is dropped, and a limit refuses with a code rather than mutating.
+import { schema } from "./schema.js";
+import { markKey, runsOf } from "./inline.js";
+import { keysBetween, newId } from "./model.js";
+import { fragmentCleaner } from "./projection.js";
+import { safeHref, safeSrc } from "./address.js";
+
+// HTML in a file someone sent is kept for its formatting, never for what it can load or
+// run: anything that embeds or fetches another document goes, and so does every address
+// that runs script, whichever attribute holds it.
+const EMBEDS = "iframe, frame, frameset, object, embed, applet, meta, base, link, form, style, animate, set, animateMotion, animateTransform, portal";
+const LOADERS = /^(srcdoc|data|formaction|codebase|archive|ping|background|poster|lowsrc|dynsrc)$/i;
+const SCRIPTED = /^\s*(javascript|vbscript|data):/i;
+function cleanImported(html) {
+  const t = document.createElement("template");
+  t.innerHTML = html;
+  for (const el of t.content.querySelectorAll(EMBEDS)) el.remove();
+  for (const el of t.content.querySelectorAll("*")) {
+    for (const { name, value } of [...el.attributes]) {
+      if (LOADERS.test(name) || SCRIPTED.test(value.replace(/[\u0000-\u0020]/g, ""))) el.removeAttribute(name);
+    }
+  }
+  return t.innerHTML;
+}
+
+export const MAX_BYTES = 2 * 1024 * 1024;
+export const MAX_DEPTH = 32;
+export const MAX_BLOCKS = 10000;
+
+export class MarkdownImportError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = "MarkdownImportError";
+    this.code = code;
+  }
+}
+
+const ATOM = "\uFFFC";
+const BREAK = { type: "hard_break" };
+const BLOCK = new Set(["paragraph", "heading", "list", "blockquote", "code", "table", "hr", "html", "def", "space"]);
+const encoder = new TextEncoder();
+const M = schema.marks;
+
+const sorted = (marks) => marks.slice().sort((a, b) => a.type.rank - b.type.rank);
+
+function added(marks, name, attrs) {
+  if (marks.some((mark) => mark.type === M[name])) return marks;
+  return sorted([...marks, M[name].create(attrs)]);
+}
+
+// One text block's inline content as the record keeps it: c, and m as runs (one
+// key per UTF-16 unit, packed), exactly as flatten and runsOf write it; `parts`
+// splits around an image, which the schema only carries as a block of its own.
+function inlineOf(tokens, { images = true, refused = [], unsupported = [] } = {}) {
+  const parts = [];
+  let c = "";
+  let m = [];
+  const flush = () => {
+    if (c) parts.push({ c, m });
+    c = "";
+    m = [];
+  };
+  const text = (value, marks) => {
+    const str = String(value ?? "");
+    if (!str) return;
+    const key = markKey(sorted(marks));
+    c += str;
+    for (let i = 0; i < str.length; i++) m.push(key);
+  };
+  const atom = (json) => { c += ATOM; m.push("@" + JSON.stringify(json)); };
+  const walk = (list, marks) => {
+    for (const token of list ?? []) {
+      const type = token?.type;
+      if (typeof type !== "string") throw new MarkdownImportError("malformed-input", "A Markdown token has no type.");
+      switch (type) {
+        case "text":
+          if (Array.isArray(token.tokens)) walk(token.tokens.filter((child) => typeof child?.type === "string" && !BLOCK.has(child.type)), marks);
+          else text(token.text, marks);
+          break;
+        case "escape": text(token.text, marks); break;
+        case "strong": walk(token.tokens, added(marks, "strong")); break;
+        case "em": walk(token.tokens, added(marks, "em")); break;
+        case "del":
+        case "strike": walk(token.tokens, added(marks, "strike")); break;
+        case "codespan": text(token.text, added(marks, "code")); break;
+        case "br": atom(BREAK); break;
+        case "link": {
+          const href = safeHref(token.href);
+          if (href) walk(token.tokens, added(marks, "link", { href }));
+          else {
+            refused.push({ type: "link", href: String(token.href ?? "") });
+            walk(token.tokens, marks);
+          }
+          break;
+        }
+        case "image": {
+          const image = { src: String(token.href ?? ""), alt: String(token.text ?? ""), title: token.title ?? "" };
+          if (!images) { text(image.alt, marks); break; }
+          flush();
+          parts.push({ image });
+          break;
+        }
+        // Raw HTML is inert: its text stays text, never a node or a mark.
+        case "html": text(token.text ?? token.raw, marks); break;
+        case "checkbox": break;
+        default:
+          unsupported.push({ type, text: String(token.raw ?? token.text ?? "") });
+          text(token.raw ?? token.text, marks);
+          break;
+      }
+    }
+  };
+  walk(tokens, []);
+  flush();
+  return { parts };
+}
+
+export function importMarkdownTokens(tokens) {
+  if (!Array.isArray(tokens)) throw new MarkdownImportError("malformed-input", "Markdown import needs the lexer's token list.");
+  let size = 0;
+  for (const token of tokens) {
+    if (!token || typeof token !== "object" || typeof token.type !== "string") throw new MarkdownImportError("malformed-input", "A Markdown token has no type.");
+    size += encoder.encode(String(token.raw ?? "")).length;
+  }
+  if (size > MAX_BYTES) throw new MarkdownImportError("input-too-large", `Markdown import is limited to ${MAX_BYTES} bytes; this file is ${size}.`);
+
+  const blocks = [];
+  const unsupported = [];
+  const refused = [];
+  const used = new Set();
+  const fresh = (prefix) => {
+    let id = newId(prefix);
+    while (used.has(id)) id = newId(prefix);
+    used.add(id);
+    return id;
+  };
+  const push = (value) => {
+    if (blocks.length + 1 > MAX_BLOCKS) throw new MarkdownImportError("too-many-blocks", `Markdown import is limited to ${MAX_BLOCKS} blocks.`);
+    blocks.push(value);
+  };
+  const deeper = (ctx) => {
+    const depth = ctx.depth + 1;
+    if (depth > MAX_DEPTH) throw new MarkdownImportError("nesting-too-deep", `Markdown import is limited to ${MAX_DEPTH} levels of nesting.`);
+    return depth;
+  };
+  const block = (t, attrs, { c, m }) => {
+    const value = { t, ...attrs, c };
+    if (m.some(Boolean)) value.m = runsOf(m);
+    return value;
+  };
+  const imageOf = (image) => {
+    const src = safeSrc(image.src);
+    if (src) return { t: "image", src, ...(image.alt ? { alt: image.alt } : {}), ...(image.title ? { caption: image.title } : {}) };
+    refused.push({ type: "image", href: image.src });
+    return image.alt ? block("paragraph", {}, { c: image.alt, m: [] }) : null;
+  };
+  const textBlocks = (t, attrs, inline) => {
+    for (const part of inline.parts) {
+      if (!part.image) { push(block(t, attrs, part)); continue; }
+      const value = imageOf(part.image);
+      if (value) push(value);
+    }
+  };
+  const paragraph = (inline, ctx) => textBlocks(ctx.quote ? "quote" : "paragraph", {}, inline);
+  const inline = (tokens, options = {}) => inlineOf(tokens, { refused, unsupported, ...options });
+  const literal = (token) => {
+    const raw = String(token.raw ?? token.text ?? "");
+    unsupported.push({ type: token.type, text: raw });
+    push({ t: "code_block", lang: "markdown", c: raw });
+  };
+
+  const walk = (list, ctx) => {
+    for (const token of list ?? []) {
+      const type = token?.type;
+      if (typeof type !== "string") throw new MarkdownImportError("malformed-input", "A Markdown token has no type.");
+      switch (type) {
+        case "space": break;
+        case "heading": {
+          const level = Math.min(6, Math.max(1, Number.parseInt(token.depth, 10) || 1));
+          textBlocks("heading", level === 2 ? {} : { level }, inline(token.tokens, { images: false }));
+          break;
+        }
+        case "paragraph":
+        case "text": paragraph(inline(token.tokens ?? [token]), ctx); break;
+        case "hr": push({ t: "divider" }); break;
+        case "code": push({ t: "code_block", ...(token.lang ? { lang: String(token.lang) } : {}), c: String(token.text ?? "") }); break;
+        case "html": {
+          const raw = String(token.text ?? token.raw ?? "");
+          unsupported.push({ type: "HTML block cleaned", text: raw });
+          push({ t: "preserved", html: cleanImported(fragmentCleaner(document).fallback(raw)) });
+          break;
+        }
+        case "blockquote": {
+          const depth = deeper(ctx);
+          walk(token.tokens, { ...ctx, depth, quote: true });
+          break;
+        }
+        case "list": {
+          const depth = deeper(ctx);
+          const level = ctx.indent ?? 0;
+          const kind = token.ordered ? "ordered" : "bullet";
+          for (const item of token.items ?? []) {
+            let own = { c: "", m: [] };
+            const rest = [];
+            for (const child of item?.tokens ?? []) {
+              const childType = child?.type;
+              if (childType === "checkbox" || childType === "space") continue;
+              if (childType === "text" || childType === "paragraph") {
+                if (own.c) own = { c: own.c + ATOM, m: [...own.m, "@" + JSON.stringify(BREAK)] };
+                const tokens = childType === "paragraph" ? child.tokens ?? [] : [child];
+                for (const part of inline(tokens, { images: false }).parts) {
+                  own = { c: own.c + part.c, m: [...own.m, ...part.m] };
+                }
+                rest.push(...(child.tokens ?? []).filter((nested) => typeof nested?.type === "string" && BLOCK.has(nested.type) && nested.type !== "space"));
+              } else rest.push(child);
+            }
+            const itemKind = item?.task ? "check" : kind;
+            const attrs = {
+              ...(itemKind === "bullet" ? {} : { kind: itemKind }),
+              ...(level ? { indent: level } : {}),
+              ...(item?.task && item.checked ? { checked: true } : {}),
+            };
+            push(block("list_item", attrs, own));
+            if (rest.length) walk(rest, { ...ctx, depth, indent: level + 1, quote: false });
+          }
+          break;
+        }
+        case "table": {
+          const header = token.header ?? [];
+          if (!header.length) { literal(token); break; }
+          const cell = (tokens) => inline(tokens, { images: false }).parts[0] ?? { c: "", m: [] };
+          const colIds = header.map(() => fresh("c"));
+          const colPos = keysBetween(null, null, header.length);
+          const cols = Object.fromEntries(colIds.map((id, i) => [id, { pos: colPos[i], name: cell(header[i]?.tokens).c }]));
+          // The header line is the column names, drawn as <thead>; the body holds the data rows.
+          const rows = token.rows?.length ? token.rows : [[]];
+          const rowPos = keysBetween(null, null, rows.length);
+          const values = rows.map((row) => Object.fromEntries(colIds.map((id, i) => {
+            const part = cell(row?.[i]?.tokens);
+            return [id, part.m.some(Boolean) ? { c: part.c, m: runsOf(part.m) } : part.c];
+          })));
+          push({ t: "table", cols, rows: Object.fromEntries(values.map((cells, i) => [fresh("r"), { pos: rowPos[i], cells }])) });
+          break;
+        }
+        default: literal(token); break;
+      }
+    }
+  };
+
+  walk(tokens, { depth: 0, indent: 0, quote: false });
+
+  const positions = keysBetween(null, null, blocks.length);
+  const out = {};
+  blocks.forEach((value, i) => { out[fresh("b")] = { ...value, pos: positions[i] }; });
+  return { blocks: out, unsupported, refused };
+}