@xenosystem/blocks 0.19.1 → 0.20.0

package/dist/docs/index.js

@@ -0,0 +1,1599 @@
+import "../chunk-2KG3PWR4.js";
+
+// src/docs/document/format.ts
+var XDOC_FORMAT = "xeno.xdoc";
+var XDOC_VERSION = 1;
+var XDOC_EXTENSION = ".xdoc";
+var DOCUMENT_NODE_TYPES = Object.freeze([
+  "doc",
+  "paragraph",
+  "text",
+  "heading",
+  "blockquote",
+  "bulletList",
+  "orderedList",
+  "listItem",
+  "taskList",
+  "taskItem",
+  "codeBlock",
+  "horizontalRule",
+  "hardBreak",
+  "table",
+  "tableRow",
+  "tableCell",
+  "tableHeader",
+  "image",
+  "callout",
+  "toggleBlock",
+  "pageBreak"
+]);
+var DOCUMENT_MARK_TYPES = Object.freeze([
+  "bold",
+  "italic",
+  "strike",
+  "code",
+  "underline",
+  "link",
+  "subscript",
+  "superscript",
+  "highlight",
+  "wikiLink"
+]);
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var SAFE_LINK = /^(https?:\/\/|mailto:)/i;
+var SAFE_IMAGE = /^(https:\/\/|data:image\/(png|jpe?g|gif|webp);base64,)/i;
+var CALLOUT_TYPES = /* @__PURE__ */ new Set(["info", "warning", "error", "success", "tip"]);
+var ALIGN = /* @__PURE__ */ new Set(["left", "center", "right", "justify"]);
+var COLOUR_VALUE = /^(#[0-9a-fA-F]{3,8}|[a-zA-Z]{3,20}|var\(--[a-zA-Z0-9-]{1,60}\))$/;
+var LANGUAGE = /^[a-zA-Z0-9_+#.-]{0,40}$/;
+var LIMITS = Object.freeze({ depth: 64, nodes: 5e4, text: 2e6 });
+var isNull = (v) => v === null || v === void 0;
+var optString = (max) => (v) => isNull(v) || typeof v === "string" && v.length <= max;
+var align = (v) => isNull(v) || typeof v === "string" && ALIGN.has(v);
+var int = (lo, hi) => (v) => isNull(v) || Number.isInteger(v) && v >= lo && v <= hi;
+var bool = (v) => isNull(v) || typeof v === "boolean";
+var colwidth = (v) => isNull(v) || Array.isArray(v) && v.length <= 64 && v.every((n) => Number.isInteger(n) && n >= 0 && n <= 1e4);
+var dims = (v) => isNull(v) || typeof v === "number" && v >= 0 && v <= 1e5 || typeof v === "string" && /^\d{1,6}(px|%)?$/.test(v);
+var NODE_ATTRS = {
+  paragraph: { textAlign: align },
+  heading: { level: int(1, 6), textAlign: align },
+  orderedList: { start: int(0, 1e6), type: optString(8) },
+  taskItem: { checked: bool },
+  codeBlock: { language: (v) => isNull(v) || typeof v === "string" && LANGUAGE.test(v) },
+  tableCell: { colspan: int(1, 1e3), rowspan: int(1, 1e3), colwidth },
+  tableHeader: { colspan: int(1, 1e3), rowspan: int(1, 1e3), colwidth },
+  image: { src: (v) => typeof v === "string" && v.length <= 8e6 && SAFE_IMAGE.test(v), alt: optString(1e3), title: optString(1e3), width: dims, height: dims },
+  callout: { type: (v) => isNull(v) || typeof v === "string" && CALLOUT_TYPES.has(v) },
+  toggleBlock: { open: bool, summary: optString(500) }
+};
+var MARK_ATTRS = {
+  link: {
+    href: (v) => typeof v === "string" && v.length <= 4e3 && SAFE_LINK.test(v.trim()),
+    target: (v) => isNull(v) || v === "_blank",
+    rel: optString(200),
+    class: (v) => isNull(v)
+  },
+  highlight: { color: (v) => isNull(v) || typeof v === "string" && COLOUR_VALUE.test(v) },
+  wikiLink: { pageId: (v) => isNull(v) || typeof v === "string" && (UUID.test(v) || /^[A-Za-z0-9_-]{1,128}$/.test(v)), pageTitle: optString(500) }
+};
+function validateContent(content, options = {}) {
+  const nodes = /* @__PURE__ */ new Set([...DOCUMENT_NODE_TYPES, ...options.extraNodes ?? []]);
+  const marks = /* @__PURE__ */ new Set([...DOCUMENT_MARK_TYPES, ...options.extraMarks ?? []]);
+  const extraN = new Set(options.extraNodes ?? []);
+  const extraM = new Set(options.extraMarks ?? []);
+  const problems = [];
+  let count = 0;
+  let text2 = 0;
+  const isObj = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+  const attrs = (where, kind, value, rules) => {
+    if (isNull(value)) return;
+    if (!isObj(value)) {
+      problems.push({ path: where, code: "bad_shape", detail: `${kind}.attrs is not an object` });
+      return;
+    }
+    for (const [k, v] of Object.entries(value)) {
+      const rule = rules?.[k];
+      if (!rule) {
+        if (!isNull(v)) problems.push({ path: where, code: "bad_attr", detail: `${kind} does not take "${k}"` });
+        continue;
+      }
+      if (!rule(v)) problems.push({ path: where, code: "bad_attr", detail: `${kind}.${k} is not allowed` });
+    }
+  };
+  const walk = (n, where, depth) => {
+    if (problems.length > 50) return;
+    if (depth > LIMITS.depth) {
+      problems.push({ path: where, code: "too_deep", detail: `deeper than ${LIMITS.depth}` });
+      return;
+    }
+    if (++count > LIMITS.nodes) {
+      if (count === LIMITS.nodes + 1) problems.push({ path: where, code: "too_large", detail: `more than ${LIMITS.nodes} nodes` });
+      return;
+    }
+    if (!isObj(n) || typeof n.type !== "string") {
+      problems.push({ path: where, code: "bad_shape", detail: "a node needs a string type" });
+      return;
+    }
+    if (!nodes.has(n.type)) {
+      problems.push({ path: where, code: "unknown_node", detail: n.type });
+      return;
+    }
+    if (!extraN.has(n.type)) attrs(where, n.type, n.attrs, NODE_ATTRS[n.type]);
+    if (n.type === "text") {
+      if (typeof n.text !== "string" || !n.text) problems.push({ path: where, code: "bad_shape", detail: "a text node needs text" });
+      else if ((text2 += n.text.length) > LIMITS.text) problems.push({ path: where, code: "too_large", detail: `more than ${LIMITS.text} characters` });
+    } else if (n.text !== void 0) problems.push({ path: where, code: "bad_shape", detail: `${n.type} cannot carry text` });
+    if (n.marks !== void 0) {
+      if (!Array.isArray(n.marks)) problems.push({ path: where, code: "bad_shape", detail: "marks is not a list" });
+      else n.marks.forEach((m, i) => {
+        if (!isObj(m) || typeof m.type !== "string") problems.push({ path: `${where}.marks[${i}]`, code: "bad_shape", detail: "a mark needs a string type" });
+        else if (!marks.has(m.type)) problems.push({ path: `${where}.marks[${i}]`, code: "unknown_mark", detail: m.type });
+        else if (!extraM.has(m.type)) attrs(`${where}.marks[${i}]`, m.type, m.attrs, MARK_ATTRS[m.type]);
+      });
+    }
+    if (n.content !== void 0) {
+      if (!Array.isArray(n.content)) problems.push({ path: where, code: "bad_shape", detail: "content is not a list" });
+      else n.content.forEach((c, i) => walk(c, `${where}.content[${i}]`, depth + 1));
+    }
+  };
+  if (!isObj(content) || content.type !== "doc") return [{ path: "content", code: "bad_shape", detail: "the root must be a doc node" }];
+  walk(content, "content", 0);
+  return problems;
+}
+var XdocError = class extends Error {
+  problems;
+  constructor(message, problems = []) {
+    super(message);
+    this.name = "XdocError";
+    this.problems = problems;
+  }
+};
+var emptyContent = () => ({ type: "doc", content: [{ type: "paragraph" }] });
+function parseXdoc(input, options = {}) {
+  let raw = input;
+  if (typeof input === "string") {
+    try {
+      raw = JSON.parse(input);
+    } catch {
+      throw new XdocError("Not a XENO document: the file is not JSON");
+    }
+  }
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new XdocError("Not a XENO document");
+  const r = raw;
+  if (r.format !== void 0 && r.format !== XDOC_FORMAT) throw new XdocError(`Not a XENO document (format "${String(r.format)}")`);
+  if (r.version !== void 0 && (!Number.isInteger(r.version) || r.version > XDOC_VERSION)) {
+    throw new XdocError(`This document was written by a newer XENO Docs (version ${String(r.version)})`);
+  }
+  const problems = validateContent(r.content, options);
+  if (problems.length) throw new XdocError(`The document contains content this editor cannot show (${problems[0].detail})`, problems);
+  const now = Date.now();
+  const num = (v, d) => typeof v === "number" && Number.isFinite(v) ? v : d;
+  const content = r.content;
+  return {
+    format: XDOC_FORMAT,
+    version: XDOC_VERSION,
+    ...typeof r.id === "string" ? { id: r.id } : {},
+    title: typeof r.title === "string" ? r.title : "",
+    content,
+    created: num(r.created, now),
+    lastModified: num(r.lastModified, now),
+    wordCount: num(r.wordCount, wordCount(content)),
+    ...r.commentThreads && typeof r.commentThreads === "object" ? { commentThreads: r.commentThreads } : {}
+  };
+}
+function serializeXdoc(doc, options = {}) {
+  const problems = validateContent(doc.content, options);
+  if (problems.length) throw new XdocError(`The document contains content that cannot be saved (${problems[0].detail})`, problems);
+  const file = {
+    format: XDOC_FORMAT,
+    version: XDOC_VERSION,
+    ...doc.id ? { id: doc.id } : {},
+    title: doc.title,
+    content: doc.content,
+    created: doc.created,
+    lastModified: doc.lastModified,
+    wordCount: doc.wordCount ?? wordCount(doc.content),
+    ...doc.commentThreads && typeof doc.commentThreads === "object" ? { commentThreads: doc.commentThreads } : {}
+  };
+  return JSON.stringify(file, null, options.pretty === false ? void 0 : 2);
+}
+var BLOCKS = /* @__PURE__ */ new Set(["paragraph", "heading", "blockquote", "listItem", "taskItem", "codeBlock", "tableCell", "tableHeader", "callout", "toggleBlock"]);
+function plainText(content) {
+  const out = [];
+  const walk = (n) => {
+    if (!n) return;
+    if (n.type === "text" && typeof n.text === "string") out.push(n.text);
+    else if (n.type === "hardBreak") out.push(" ");
+    if (n.type === "toggleBlock" && typeof n.attrs?.summary === "string") out.push(` ${n.attrs.summary} `);
+    for (const c of n.content ?? []) walk(c);
+    if (BLOCKS.has(n.type)) out.push(" ");
+  };
+  walk(content);
+  return out.join("").replace(/\s+/g, " ").trim();
+}
+function wordCount(content) {
+  const t = plainText(content);
+  return t ? t.split(" ").length : 0;
+}
+function pageLinksIn(content) {
+  const seen = /* @__PURE__ */ new Set();
+  const walk = (n) => {
+    if (!n) return;
+    for (const m of n.marks ?? []) {
+      const id = m.type === "wikiLink" ? m.attrs?.pageId : null;
+      if (typeof id === "string" && id) seen.add(id.toLowerCase());
+    }
+    for (const c of n.content ?? []) walk(c);
+  };
+  walk(content);
+  return [...seen];
+}
+function nodeTypesIn(content) {
+  const seen = /* @__PURE__ */ new Set();
+  const walk = (n) => {
+    if (!n) return;
+    seen.add(n.type);
+    for (const m of n.marks ?? []) seen.add(`mark:${m.type}`);
+    for (const c of n.content ?? []) walk(c);
+  };
+  walk(content);
+  return seen;
+}
+
+// src/docs/document/markdown.ts
+var PAGE_LINK = /^xeno-doc:([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i;
+function documentToMarkdown(doc) {
+  if (!doc.content) return "";
+  return doc.content.map((node) => nodeToMarkdown(node, 0)).join("\n\n");
+}
+function nodeToMarkdown(node, depth) {
+  switch (node.type) {
+    case "heading":
+      return `${"#".repeat(node.attrs?.level || 1)} ${inlineToMarkdown(node.content)}`;
+    case "paragraph":
+      return inlineToMarkdown(node.content);
+    case "bulletList":
+      return (node.content || []).map((item) => listItemToMarkdown(item, depth, "-")).join("\n");
+    case "orderedList":
+      return (node.content || []).map((item, i) => listItemToMarkdown(item, depth, `${i + 1}.`)).join("\n");
+    case "taskList":
+      return (node.content || []).map((item) => {
+        const checked = item.attrs?.checked ? "x" : " ";
+        const content = (item.content || []).map((c) => nodeToMarkdown(c, depth + 1)).join("\n");
+        return `${"  ".repeat(depth)}- [${checked}] ${content}`;
+      }).join("\n");
+    case "blockquote":
+      return (node.content || []).map((c) => `> ${nodeToMarkdown(c, depth)}`).join("\n");
+    case "codeBlock": {
+      const lang = node.attrs?.language || "";
+      const code = node.content?.map((c) => c.text || "").join("") || "";
+      return `\`\`\`${lang}
+${code}
+\`\`\``;
+    }
+    case "horizontalRule":
+      return "---";
+    case "image": {
+      const alt = node.attrs?.alt || "";
+      const src = node.attrs?.src || "";
+      const title = node.attrs?.title ? ` "${node.attrs.title}"` : "";
+      return `![${alt}](${src}${title})`;
+    }
+    case "table":
+      return tableToMarkdown(node);
+    case "callout": {
+      const type = node.attrs?.type || "info";
+      const content = (node.content || []).map((c) => nodeToMarkdown(c, depth)).join("\n");
+      return `> **${type.charAt(0).toUpperCase() + type.slice(1)}:** ${content}`;
+    }
+    case "mathBlock":
+      return `$$
+${node.attrs?.content || ""}
+$$`;
+    case "toggleBlock": {
+      const summary = node.attrs?.summary || "Toggle";
+      const content = (node.content || []).map((c) => nodeToMarkdown(c, depth)).join("\n");
+      return `<details>
+<summary>${summary}</summary>
+
+${content}
+</details>`;
+    }
+    case "multiColumn": {
+      return (node.content || []).map((col, i) => {
+        const colContent = (col.content || []).map((c) => nodeToMarkdown(c, depth)).join("\n\n");
+        return `<!-- Column ${i + 1} -->
+${colContent}`;
+      }).join("\n\n");
+    }
+    default:
+      return inlineToMarkdown(node.content);
+  }
+}
+function listItemToMarkdown(item, depth, bullet) {
+  const content = (item.content || []).map((c, i) => {
+    const text2 = nodeToMarkdown(c, depth + 1);
+    if (i === 0) return text2;
+    return "  ".repeat(depth + 1) + text2;
+  }).join("\n");
+  return `${"  ".repeat(depth)}${bullet} ${content}`;
+}
+function inlineToMarkdown(content) {
+  if (!content) return "";
+  return content.map((node) => {
+    let text2 = node.text || "";
+    if (node.type === "hardBreak") return "  \n";
+    if (node.type === "image") {
+      return `![${node.attrs?.alt || ""}](${node.attrs?.src || ""})`;
+    }
+    if (!node.marks) return text2;
+    for (const mark of node.marks) {
+      switch (mark.type) {
+        case "bold":
+          text2 = `**${text2}**`;
+          break;
+        case "italic":
+          text2 = `*${text2}*`;
+          break;
+        case "strike":
+          text2 = `~~${text2}~~`;
+          break;
+        case "code":
+          text2 = `\`${text2}\``;
+          break;
+        case "link":
+          text2 = `[${text2}](${mark.attrs?.href || ""})`;
+          break;
+        case "wikiLink":
+          text2 = `[${text2}](xeno-doc:${mark.attrs?.pageId || ""})`;
+          break;
+        case "underline":
+          text2 = `<u>${text2}</u>`;
+          break;
+        case "subscript":
+          text2 = `<sub>${text2}</sub>`;
+          break;
+        case "superscript":
+          text2 = `<sup>${text2}</sup>`;
+          break;
+      }
+    }
+    return text2;
+  }).join("");
+}
+function tableToMarkdown(node) {
+  if (!node.content) return "";
+  const rows = node.content.filter((r) => r.type === "tableRow");
+  if (rows.length === 0) return "";
+  const lines = [];
+  for (let i = 0; i < rows.length; i++) {
+    const cells = rows[i].content || [];
+    const line = cells.map((cell) => {
+      const text2 = (cell.content || []).map((c) => inlineToMarkdown(c.content)).join(" ");
+      return ` ${text2} `;
+    }).join("|");
+    lines.push(`|${line}|`);
+    if (i === 0) {
+      const sep = cells.map(() => " --- ").join("|");
+      lines.push(`|${sep}|`);
+    }
+  }
+  return lines.join("\n");
+}
+function markdownToDocument(md) {
+  let input = md;
+  const frontmatterMatch = input.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n/);
+  if (frontmatterMatch) {
+    input = input.slice(frontmatterMatch[0].length);
+  }
+  const lines = input.split("\n");
+  const content = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.trim() === "") {
+      i++;
+      continue;
+    }
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      content.push({
+        type: "heading",
+        attrs: { level: headingMatch[1].length },
+        content: parseInlineMarkdown(headingMatch[2])
+      });
+      i++;
+      continue;
+    }
+    if (/^(---|\*\*\*|___)/.test(line.trim())) {
+      content.push({ type: "horizontalRule" });
+      i++;
+      continue;
+    }
+    if (line.trim().startsWith("```")) {
+      const lang = line.trim().slice(3).trim();
+      const codeLines = [];
+      i++;
+      while (i < lines.length && !lines[i].trim().startsWith("```")) {
+        codeLines.push(lines[i]);
+        i++;
+      }
+      i++;
+      content.push({
+        type: "codeBlock",
+        attrs: { language: lang || null },
+        content: [{ type: "text", text: codeLines.join("\n") }]
+      });
+      continue;
+    }
+    if (line.trim() === "$$") {
+      const mathLines = [];
+      i++;
+      while (i < lines.length && lines[i].trim() !== "$$") {
+        mathLines.push(lines[i]);
+        i++;
+      }
+      i++;
+      content.push({
+        type: "mathBlock",
+        attrs: { content: mathLines.join("\n") }
+      });
+      continue;
+    }
+    if (line.startsWith(">")) {
+      const quoteLines = [];
+      while (i < lines.length && lines[i].startsWith(">")) {
+        quoteLines.push(lines[i].replace(/^>\s?/, ""));
+        i++;
+      }
+      content.push({
+        type: "blockquote",
+        content: quoteLines.map((ql) => ({
+          type: "paragraph",
+          content: parseInlineMarkdown(ql)
+        }))
+      });
+      continue;
+    }
+    if (/^\s*[-*+]\s/.test(line)) {
+      const listItems = [];
+      while (i < lines.length && /^\s*[-*+]\s/.test(lines[i])) {
+        const itemText = lines[i].replace(/^\s*[-*+]\s/, "");
+        const taskMatch = itemText.match(/^\[([ xX])\]\s*(.*)$/);
+        if (taskMatch) {
+          listItems.push({
+            type: "taskItem",
+            attrs: { checked: taskMatch[1] !== " " },
+            content: [{ type: "paragraph", content: parseInlineMarkdown(taskMatch[2]) }]
+          });
+        } else {
+          listItems.push({
+            type: "listItem",
+            content: [{ type: "paragraph", content: parseInlineMarkdown(itemText) }]
+          });
+        }
+        i++;
+      }
+      if (listItems[0]?.type === "taskItem") {
+        content.push({ type: "taskList", content: listItems });
+      } else {
+        content.push({ type: "bulletList", content: listItems });
+      }
+      continue;
+    }
+    if (/^\s*\d+\.\s/.test(line)) {
+      const listItems = [];
+      while (i < lines.length && /^\s*\d+\.\s/.test(lines[i])) {
+        const itemText = lines[i].replace(/^\s*\d+\.\s/, "");
+        listItems.push({
+          type: "listItem",
+          content: [{ type: "paragraph", content: parseInlineMarkdown(itemText) }]
+        });
+        i++;
+      }
+      content.push({ type: "orderedList", content: listItems });
+      continue;
+    }
+    if (line.includes("|") && line.trim().startsWith("|")) {
+      const tableRows = [];
+      let isFirst = true;
+      while (i < lines.length && lines[i].includes("|")) {
+        const trimmed = lines[i].trim();
+        if (/^\|[\s\-:|]+\|$/.test(trimmed)) {
+          i++;
+          continue;
+        }
+        const cells = trimmed.split("|").filter((_, idx, arr) => idx > 0 && idx < arr.length - 1).map((cell) => cell.trim());
+        const cellType = isFirst ? "tableHeader" : "tableCell";
+        tableRows.push({
+          type: "tableRow",
+          content: cells.map((cellText) => ({
+            type: cellType,
+            content: [{ type: "paragraph", content: parseInlineMarkdown(cellText) }]
+          }))
+        });
+        isFirst = false;
+        i++;
+      }
+      content.push({ type: "table", content: tableRows });
+      continue;
+    }
+    const imgMatch = line.match(/^!\[([^\]]*)\]\(([^)]+)\)$/);
+    if (imgMatch) {
+      content.push({
+        type: "image",
+        attrs: { src: imgMatch[2], alt: imgMatch[1] }
+      });
+      i++;
+      continue;
+    }
+    const paraLines = [line];
+    i++;
+    while (i < lines.length && lines[i].trim() !== "" && !/^(#{1,6}\s|```|>|\s*[-*+]\s|\s*\d+\.\s|---|\*\*\*|___|!\[|\|)/.test(lines[i])) {
+      paraLines.push(lines[i]);
+      i++;
+    }
+    content.push({
+      type: "paragraph",
+      content: parseInlineMarkdown(paraLines.join(" "))
+    });
+  }
+  return { type: "doc", content: content.length > 0 ? content : [{ type: "paragraph" }] };
+}
+function parseInlineMarkdown(text2) {
+  if (!text2) return [];
+  const result = [];
+  const inlineRegex = /(\*\*(.+?)\*\*|\*(.+?)\*|~~(.+?)~~|`([^`]+)`|\[([^\]]+)\]\(([^)]+)\)|<u>(.+?)<\/u>|<sub>(.+?)<\/sub>|<sup>(.+?)<\/sup>)/g;
+  let lastIndex = 0;
+  let match;
+  while ((match = inlineRegex.exec(text2)) !== null) {
+    if (match.index > lastIndex) {
+      result.push({ type: "text", text: text2.slice(lastIndex, match.index) });
+    }
+    if (match[2]) {
+      result.push({ type: "text", text: match[2], marks: [{ type: "bold" }] });
+    } else if (match[3]) {
+      result.push({ type: "text", text: match[3], marks: [{ type: "italic" }] });
+    } else if (match[4]) {
+      result.push({ type: "text", text: match[4], marks: [{ type: "strike" }] });
+    } else if (match[5]) {
+      result.push({ type: "text", text: match[5], marks: [{ type: "code" }] });
+    } else if (match[6] && match[7]) {
+      const page = PAGE_LINK.exec(match[7]);
+      if (page) result.push({ type: "text", text: match[6], marks: [{ type: "wikiLink", attrs: { pageId: page[1].toLowerCase(), pageTitle: match[6] } }] });
+      else if (SAFE_LINK.test(match[7].trim())) result.push({ type: "text", text: match[6], marks: [{ type: "link", attrs: { href: match[7] } }] });
+      else result.push({ type: "text", text: match[6] });
+    } else if (match[8]) {
+      result.push({ type: "text", text: match[8], marks: [{ type: "underline" }] });
+    } else if (match[9]) {
+      result.push({ type: "text", text: match[9], marks: [{ type: "subscript" }] });
+    } else if (match[10]) {
+      result.push({ type: "text", text: match[10], marks: [{ type: "superscript" }] });
+    }
+    lastIndex = match.index + match[0].length;
+  }
+  if (lastIndex < text2.length) {
+    result.push({ type: "text", text: text2.slice(lastIndex) });
+  }
+  const kept = result.filter((n) => n.type !== "text" || (n.text ?? "") !== "");
+  return kept.length > 0 ? kept : text2 ? [{ type: "text", text: text2 }] : [];
+}
+
+// src/docs/document/schema.ts
+import StarterKit from "@tiptap/starter-kit";
+import Underline from "@tiptap/extension-underline";
+import TextAlign from "@tiptap/extension-text-align";
+import Placeholder from "@tiptap/extension-placeholder";
+import TaskList from "@tiptap/extension-task-list";
+import TaskItem from "@tiptap/extension-task-item";
+import Table from "@tiptap/extension-table";
+import TableRow from "@tiptap/extension-table-row";
+import TableCell from "@tiptap/extension-table-cell";
+import TableHeader from "@tiptap/extension-table-header";
+import Image from "@tiptap/extension-image";
+import Link from "@tiptap/extension-link";
+import Subscript from "@tiptap/extension-subscript";
+import Superscript from "@tiptap/extension-superscript";
+import Highlight from "@tiptap/extension-highlight";
+import Typography from "@tiptap/extension-typography";
+
+// src/docs/document/extensions/Callout.ts
+import { Node, mergeAttributes } from "@tiptap/core";
+var Callout = Node.create({
+  name: "callout",
+  group: "block",
+  content: "block+",
+  defining: true,
+  addAttributes() {
+    return {
+      type: {
+        default: "info",
+        parseHTML: (element) => element.getAttribute("data-callout-type") || "info",
+        renderHTML: (attributes) => ({
+          "data-callout-type": attributes.type
+        })
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      { tag: "div[data-callout-type]" },
+      { tag: "div.callout" }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    const type = HTMLAttributes["data-callout-type"] || "info";
+    return [
+      "div",
+      mergeAttributes(HTMLAttributes, {
+        class: `callout ${type}`,
+        "data-callout-type": type
+      }),
+      0
+    ];
+  },
+  addCommands() {
+    return {
+      setCallout: (attrs) => ({ commands }) => {
+        return commands.wrapIn(this.name, attrs);
+      },
+      toggleCallout: (attrs) => ({ commands }) => {
+        return commands.toggleWrap(this.name, attrs);
+      }
+    };
+  }
+});
+
+// src/docs/document/extensions/ToggleBlock.ts
+import { Node as Node2, mergeAttributes as mergeAttributes2 } from "@tiptap/core";
+var ToggleBlock = Node2.create({
+  name: "toggleBlock",
+  group: "block",
+  content: "block+",
+  defining: true,
+  addAttributes() {
+    return {
+      open: {
+        default: true,
+        parseHTML: (element) => element.getAttribute("data-open") !== "false",
+        renderHTML: (attributes) => ({
+          "data-open": String(attributes.open)
+        })
+      },
+      summary: {
+        default: "Toggle",
+        parseHTML: (element) => element.getAttribute("data-summary") || "Toggle",
+        renderHTML: (attributes) => ({
+          "data-summary": attributes.summary
+        })
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      { tag: "div[data-toggle-block]" },
+      {
+        tag: "details",
+        getAttrs: (element) => ({
+          open: element.hasAttribute("open"),
+          summary: element.querySelector("summary")?.textContent || "Toggle"
+        })
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return [
+      "details",
+      mergeAttributes2(HTMLAttributes, {
+        "data-toggle-block": "true",
+        ...HTMLAttributes["data-open"] === "true" ? { open: "open" } : {}
+      }),
+      ["summary", {}, HTMLAttributes["data-summary"] || "Toggle"],
+      ["div", { class: "toggle-content" }, 0]
+    ];
+  },
+  addCommands() {
+    return {
+      setToggleBlock: () => ({ commands }) => {
+        return commands.insertContent({
+          type: this.name,
+          attrs: { summary: "Click to expand", open: true },
+          content: [{ type: "paragraph", content: [{ type: "text", text: "Content here..." }] }]
+        });
+      }
+    };
+  }
+});
+
+// src/docs/document/extensions/PageBreak.ts
+import { Node as Node3, mergeAttributes as mergeAttributes3 } from "@tiptap/core";
+var PageBreak = Node3.create({
+  name: "pageBreak",
+  group: "block",
+  atom: true,
+  selectable: true,
+  draggable: false,
+  parseHTML() {
+    return [
+      { tag: "div[data-page-break]" },
+      {
+        tag: "div",
+        getAttrs: (element) => element.style.pageBreakAfter === "always" ? {} : false
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return [
+      "div",
+      mergeAttributes3(HTMLAttributes, {
+        "data-page-break": "true",
+        class: "page-break",
+        contenteditable: "false",
+        style: "page-break-after: always;"
+      }),
+      ["div", { class: "page-break-rule" }],
+      ["span", { class: "page-break-label" }, "Page Break"],
+      ["div", { class: "page-break-rule" }]
+    ];
+  },
+  addCommands() {
+    return {
+      setPageBreak: () => ({ commands }) => {
+        return commands.insertContent({ type: this.name });
+      }
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Enter": () => this.editor.commands.setPageBreak()
+    };
+  }
+});
+
+// src/docs/document/extensions/WikiLink.ts
+import { Mark, mergeAttributes as mergeAttributes4 } from "@tiptap/core";
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+var WikiLinkMark = Mark.create({
+  name: "wikiLink",
+  priority: 1e3,
+  addOptions() {
+    return {
+      onClickLink: () => {
+      },
+      HTMLAttributes: {
+        class: "wiki-link"
+      }
+    };
+  },
+  addAttributes() {
+    return {
+      pageId: {
+        default: null,
+        parseHTML: (element) => element.getAttribute("data-page-id"),
+        renderHTML: (attributes) => ({
+          "data-page-id": attributes.pageId
+        })
+      },
+      pageTitle: {
+        default: "",
+        parseHTML: (element) => element.getAttribute("data-page-title"),
+        renderHTML: (attributes) => ({
+          "data-page-title": attributes.pageTitle
+        })
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "span[data-wiki-link]"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return [
+      "span",
+      mergeAttributes4(
+        this.options.HTMLAttributes,
+        HTMLAttributes,
+        { "data-wiki-link": "" }
+      ),
+      0
+    ];
+  },
+  addCommands() {
+    return {
+      setWikiLink: (attrs) => ({ commands }) => {
+        return commands.setMark(this.name, attrs);
+      },
+      unsetWikiLink: () => ({ commands }) => {
+        return commands.unsetMark(this.name);
+      }
+    };
+  },
+  addProseMirrorPlugins() {
+    const { onClickLink } = this.options;
+    return [
+      new Plugin({
+        key: new PluginKey("wikiLinkClick"),
+        props: {
+          handleClick(view, pos) {
+            const { state } = view;
+            const $pos = state.doc.resolve(pos);
+            const marks = $pos.marks();
+            for (const mark of marks) {
+              if (mark.type.name === "wikiLink") {
+                const { pageId, pageTitle } = mark.attrs;
+                if (pageId || pageTitle) {
+                  onClickLink(pageId || "", pageTitle || "");
+                  return true;
+                }
+              }
+            }
+            return false;
+          }
+        }
+      })
+    ];
+  }
+});
+
+// src/docs/document/schema.ts
+var SafeImage = Image.extend({
+  parseHTML() {
+    return [{ tag: "img[src]", getAttrs: (el) => SAFE_IMAGE.test(el.getAttribute("src") ?? "") ? null : false }];
+  }
+});
+function createDocumentExtensions(options = {}) {
+  const list = [
+    StarterKit.configure({
+      ...options.codeBlock ? { codeBlock: false } : {},
+      heading: { levels: [1, 2, 3, 4, 5, 6] },
+      ...options.history === false ? { history: false } : {}
+    }),
+    Underline,
+    TextAlign.configure({ types: ["heading", "paragraph"] }),
+    Placeholder.configure({ placeholder: options.placeholder ?? 'Start writing, or press "/" for commands...' }),
+    TaskList,
+    TaskItem.configure({ nested: true }),
+    Table.configure({ resizable: options.resizableTables ?? false }),
+    TableRow,
+    TableCell,
+    TableHeader,
+    SafeImage.configure({ inline: false }),
+    Link.configure({
+      openOnClick: false,
+      autolink: true,
+      HTMLAttributes: { rel: "noopener noreferrer nofollow", target: "_blank" },
+      // the format refuses anything else; the editor must not be able to produce what the format refuses
+      isAllowedUri: (url) => SAFE_LINK.test(String(url).trim())
+    }),
+    Subscript,
+    Superscript,
+    Highlight.configure({ multicolor: true }),
+    Typography,
+    Callout,
+    ToggleBlock,
+    PageBreak,
+    WikiLinkMark.configure({ onClickLink: options.onOpenPage ?? (() => {
+    }) })
+  ];
+  if (options.codeBlock) list.push(options.codeBlock);
+  return list;
+}
+
+// src/docs/document/surface.ts
+import { Editor } from "@tiptap/core";
+function runFormat(editor, command, arg, promptLink) {
+  const c = editor.chain().focus();
+  switch (command) {
+    case "paragraph":
+      return c.setParagraph().run();
+    case "h1":
+      return c.toggleHeading({ level: 1 }).run();
+    case "h2":
+      return c.toggleHeading({ level: 2 }).run();
+    case "h3":
+      return c.toggleHeading({ level: 3 }).run();
+    case "bold":
+      return c.toggleBold().run();
+    case "italic":
+      return c.toggleItalic().run();
+    case "underline":
+      return c.toggleUnderline().run();
+    case "strike":
+      return c.toggleStrike().run();
+    case "code":
+      return c.toggleCode().run();
+    case "highlight":
+      return c.toggleHighlight().run();
+    case "bulletList":
+      return c.toggleBulletList().run();
+    case "orderedList":
+      return c.toggleOrderedList().run();
+    case "taskList":
+      return c.toggleTaskList().run();
+    case "blockquote":
+      return c.toggleBlockquote().run();
+    case "codeBlock":
+      return c.toggleCodeBlock().run();
+    case "callout":
+      return c.toggleCallout({ type: "info" }).run();
+    case "toggle":
+      return c.setToggleBlock().run();
+    case "pageBreak":
+      return c.setPageBreak().run();
+    case "horizontalRule":
+      return c.setHorizontalRule().run();
+    case "unlink":
+      return c.unsetLink().run();
+    case "undo":
+      return c.undo().run();
+    case "redo":
+      return c.redo().run();
+    case "link": {
+      const current = editor.getAttributes("link").href ?? null;
+      const href = typeof arg === "string" ? arg : promptLink ? promptLink(current) : null;
+      if (href === null || href === void 0) return false;
+      if (href.trim() === "") return c.unsetLink().run();
+      if (!SAFE_LINK.test(href.trim())) return false;
+      return c.extendMarkRange("link").setLink({ href: href.trim(), target: "_blank" }).run();
+    }
+    default:
+      return false;
+  }
+}
+var ACTIVE = {
+  paragraph: ["paragraph"],
+  h1: ["heading", { level: 1 }],
+  h2: ["heading", { level: 2 }],
+  h3: ["heading", { level: 3 }],
+  bold: ["bold"],
+  italic: ["italic"],
+  underline: ["underline"],
+  strike: ["strike"],
+  code: ["code"],
+  highlight: ["highlight"],
+  bulletList: ["bulletList"],
+  orderedList: ["orderedList"],
+  taskList: ["taskList"],
+  blockquote: ["blockquote"],
+  codeBlock: ["codeBlock"],
+  callout: ["callout"],
+  toggle: ["toggleBlock"],
+  link: ["link"]
+};
+function editorHandle(editor, promptLink) {
+  return {
+    getJSON: () => editor.getJSON(),
+    setContent: (content) => {
+      editor.commands.setContent(content, false);
+    },
+    setEditable: (editable) => editor.setEditable(editable),
+    focus: () => {
+      editor.commands.focus();
+    },
+    run: (command, arg) => runFormat(editor, command, arg, promptLink),
+    isActive: (command) => {
+      const a = ACTIVE[command];
+      return a ? editor.isActive(a[0], a[1]) : false;
+    },
+    insertText: (text2) => {
+      editor.chain().focus().insertContent({ type: "text", text: text2 }).run();
+    },
+    insertPageLink: (pageId, pageTitle, label) => {
+      const { from, to } = editor.state.selection;
+      const words = label || (from !== to ? editor.state.doc.textBetween(from, to, " ") : "") || pageTitle || "Untitled";
+      editor.chain().focus().insertContentAt({ from, to }, [
+        { type: "text", text: words, marks: [{ type: "wikiLink", attrs: { pageId, pageTitle } }] },
+        { type: "text", text: " " }
+      ]).run();
+    }
+  };
+}
+function mountDocumentSurface(element, controller, options = {}) {
+  const state = controller.getState();
+  const editor = new Editor({
+    element,
+    extensions: [...createDocumentExtensions({ ...options, onOpenPage: (id, title) => controller.openPage(id, title) }), ...options.extensions ?? []],
+    content: state.unsupported.length || state.status === "unsupported" ? "" : state.content,
+    editable: !state.readOnly,
+    editorProps: {
+      attributes: {
+        ...options.editorClass ? { class: options.editorClass } : {},
+        role: "textbox",
+        "aria-multiline": "true",
+        "aria-label": options.label ?? "Document text",
+        "data-xeno-document-surface": ""
+      }
+    },
+    onUpdate: () => controller.contentChanged(),
+    onSelectionUpdate: () => controller.selectionChanged()
+  });
+  const unbind = controller.attach(editorHandle(editor, options.promptLink));
+  return () => {
+    unbind();
+    editor.destroy();
+  };
+}
+
+// src/docs/document/controller.ts
+var DOCUMENT_FORMAT_COMMANDS = Object.freeze([
+  "paragraph",
+  "h1",
+  "h2",
+  "h3",
+  "bold",
+  "italic",
+  "underline",
+  "strike",
+  "code",
+  "highlight",
+  "bulletList",
+  "orderedList",
+  "taskList",
+  "blockquote",
+  "codeBlock",
+  "callout",
+  "toggle",
+  "pageBreak",
+  "horizontalRule",
+  "link",
+  "unlink",
+  "undo",
+  "redo"
+]);
+var KNOWN = /* @__PURE__ */ new Set([...DOCUMENT_NODE_TYPES, ...DOCUMENT_MARK_TYPES.map((m) => `mark:${m}`)]);
+var DocumentController = class {
+  host;
+  state = { id: null, versionId: null, title: "", readOnly: false, unsupported: [], dirty: false, status: "empty", message: null, content: emptyContent(), revision: 0 };
+  created = Date.now();
+  /** XENO Docs' comment threads, carried through a save untouched (this block does not edit comments). */
+  commentThreads;
+  editor = null;
+  listeners = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.host = options.host;
+  }
+  /** Subscribe to state changes (a view re-renders on each). */
+  subscribe(fn) {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+  getState() {
+    return this.state;
+  }
+  set(patch) {
+    this.state = { ...this.state, ...patch };
+    for (const fn of this.listeners) fn();
+  }
+  /**
+   * Open a document. A file the shared schema cannot render is NOT coerced: it opens read-only with
+   * the unknown types listed, so nothing the user wrote elsewhere is lost on a save here.
+   */
+  load(input) {
+    let content;
+    let unsupported = [];
+    let message = null;
+    try {
+      if (input.xdoc !== void 0) {
+        const f = parseXdoc(input.xdoc);
+        content = f.content;
+        this.created = f.created;
+        this.commentThreads = f.commentThreads;
+      } else {
+        content = input.content ?? emptyContent();
+        const problems = validateContent(content);
+        if (problems.length) throw new XdocError(problems[0].detail, problems);
+        this.created = input.created ?? Date.now();
+        this.commentThreads = void 0;
+      }
+    } catch (e) {
+      let raw = emptyContent();
+      try {
+        const r = typeof input.xdoc === "string" ? JSON.parse(input.xdoc) : input.xdoc ?? { content: input.content };
+        if (r && typeof r === "object" && r.content) raw = r.content;
+      } catch {
+      }
+      content = raw;
+      unsupported = [...nodeTypesIn(raw)].filter((t) => !KNOWN.has(t));
+      message = e instanceof Error ? e.message : "This document cannot be edited here";
+    }
+    this.set({
+      id: input.id,
+      versionId: input.versionId ?? null,
+      title: input.title,
+      readOnly: !!input.readOnly || unsupported.length > 0 || message !== null,
+      unsupported,
+      dirty: false,
+      status: message ? "unsupported" : "ready",
+      message,
+      content,
+      revision: this.state.revision + 1
+    });
+    if (this.editor) {
+      this.editor.setContent(message ? emptyContent() : content);
+      this.editor.setEditable(!this.state.readOnly);
+    }
+  }
+  /** Bind the live editor (`./surface` does this). Returns the unbind. */
+  attach(editor) {
+    this.editor = editor;
+    editor.setEditable(!this.state.readOnly);
+    return () => {
+      if (this.editor === editor) this.editor = null;
+    };
+  }
+  hasEditor() {
+    return this.editor !== null;
+  }
+  /** The editor reported an edit. */
+  contentChanged() {
+    if (this.state.readOnly) return;
+    if (!this.state.dirty) this.host.emit("dirty", { dirty: true });
+    this.set({ dirty: true, status: this.state.status === "saved" ? "ready" : this.state.status });
+  }
+  /** The cursor moved: a view re-reads which format commands are active. No state changes. */
+  selectionChanged() {
+    this.set({});
+  }
+  setTitle(title) {
+    if (this.state.readOnly || title === this.state.title) return;
+    if (!this.state.dirty) this.host.emit("dirty", { dirty: true });
+    this.set({ title, dirty: true });
+  }
+  /** The content as it stands — the live editor's when bound. */
+  currentContent() {
+    return this.editor ? this.editor.getJSON() : this.state.content;
+  }
+  /** Run a format command against the live editor. */
+  format(command, arg) {
+    if (this.state.readOnly || !this.editor) return false;
+    if (!DOCUMENT_FORMAT_COMMANDS.includes(command)) return false;
+    return this.editor.run(command, arg);
+  }
+  isActive(command) {
+    return this.editor ? this.editor.isActive(command) : false;
+  }
+  insertText(text2) {
+    if (this.state.readOnly || !this.editor) return false;
+    this.editor.insertText(String(text2));
+    return true;
+  }
+  insertPageLink(pageId, pageTitle, label) {
+    if (this.state.readOnly || !this.editor || !pageId) return false;
+    this.editor.insertPageLink(pageId, pageTitle, label);
+    return true;
+  }
+  /** A page link was clicked — the host navigates. */
+  openPage(pageId, pageTitle) {
+    if (pageId || pageTitle) this.host.emit("openPage", { pageId, pageTitle });
+  }
+  /** The `.xdoc` for the document as it stands. Throws {@link XdocError} if it would not validate. */
+  toXdoc() {
+    return serializeXdoc({ ...this.state.id ? { id: this.state.id } : {}, title: this.state.title, content: this.currentContent(), created: this.created, lastModified: Date.now(), ...this.commentThreads ? { commentThreads: this.commentThreads } : {} });
+  }
+  /** Ask the host to save. Refused (false) when read-only, when nothing is open, or mid-save. */
+  save() {
+    const s = this.state;
+    if (!s.id || s.readOnly || s.status === "saving") return false;
+    const title = s.title.trim();
+    if (!title) {
+      this.set({ status: "failed", message: "A title is required" });
+      return false;
+    }
+    let xdoc;
+    const content = this.currentContent();
+    try {
+      xdoc = this.toXdoc();
+    } catch (e) {
+      this.set({ status: "failed", message: e instanceof Error ? e.message : "The document cannot be saved" });
+      return false;
+    }
+    this.set({ status: "saving", message: null });
+    const save = { id: s.id, ...s.versionId ? { expectedVersion: s.versionId } : {}, title, xdoc, content, text: plainText(content), pageLinks: pageLinksIn(content) };
+    this.host.emit("save", save);
+    return true;
+  }
+  /** The host saved: adopt its new version id. */
+  saved(versionId) {
+    this.set({ versionId: versionId ?? this.state.versionId, dirty: false, status: "saved", message: null });
+    this.host.emit("dirty", { dirty: false });
+  }
+  /** The host reports an outcome that is not success (`conflict`, `failed`) or a message. */
+  setStatus(status, message) {
+    this.set({ status, message: message ?? null });
+  }
+  /** What an agent reads. The status travels with the words so "empty" is never a guess. */
+  describe() {
+    const content = this.currentContent();
+    const s = this.state;
+    return { id: s.id, title: s.title, status: s.status, readOnly: s.readOnly, dirty: s.dirty, text: plainText(content), wordCount: wordCount(content), pageLinks: pageLinksIn(content), unsupported: s.unsupported };
+  }
+  serialize() {
+    return { id: this.state.id, title: this.state.title };
+  }
+  deserialize(_state) {
+  }
+  dispose() {
+    this.listeners.clear();
+    this.editor = null;
+  }
+};
+
+// src/docs/document/panel.ts
+import { createElement } from "react";
+import { createRoot } from "react-dom/client";
+import { bindConfig } from "@xenosystem/block-sdk";
+
+// src/docs/document/manifest.ts
+var DOCUMENT_PANEL_ID = "xeno.core.document";
+var documentManifest = {
+  id: DOCUMENT_PANEL_ID,
+  version: "0.1.0",
+  title: "Document",
+  icon: "file-text",
+  description: "XENO Docs\u2019 editor over the shared .xdoc format: rich text, lists, tasks, tables, callouts, toggles, page links. The host stores and loads; the block edits and asks. A document containing a block this schema does not know opens read-only, never coerced.",
+  defaultSlot: "center",
+  inputs: [
+    {
+      id: "document",
+      name: "Document",
+      type: "object",
+      description: "{id, versionId?, title, xdoc | content, readOnly?}. `xdoc` is the stored file (text or parsed); `versionId` is round-tripped as `expectedVersion` on save so a stale save is refused, not merged.",
+      multiple: false
+    },
+    {
+      id: "saved",
+      name: "Saved",
+      type: "object",
+      description: "{versionId} \u2014 the host wrote the version the last `save` asked for.",
+      multiple: false
+    },
+    {
+      id: "status",
+      name: "Status",
+      type: "object",
+      description: '{status: "conflict" | "failed", message?} \u2014 the save did not happen, and why.',
+      multiple: false
+    }
+  ],
+  outputs: [
+    {
+      id: "save",
+      name: "Save",
+      type: "object",
+      description: "{id, expectedVersion?, title, xdoc, content, text, pageLinks}. An INTENT \u2014 the host writes `xdoc` (already validated against the format) as the next version and answers on `saved` or `status`."
+    },
+    {
+      id: "openPage",
+      name: "Open page",
+      type: "object",
+      description: "{pageId, pageTitle} \u2014 a page link (the `wikiLink` mark) was followed. The host navigates."
+    },
+    {
+      id: "dirty",
+      name: "Dirty",
+      type: "object",
+      description: "{dirty} \u2014 the document has unsaved changes (true) or was just saved (false)."
+    }
+  ],
+  commands: [
+    {
+      id: "get_document",
+      title: "Get Document",
+      description: "Return {id, title, status, readOnly, dirty, text, wordCount, pageLinks, unsupported}. `status` travels with the text so an empty string is never read as an empty document when it was an unsupported one.",
+      parameters: {}
+    },
+    { id: "set_title", title: "Set Title", description: "Rename the document (unsaved until `save`).", parameters: { title: { type: "string", description: "The new title", required: true } } },
+    { id: "insert_text", title: "Insert Text", description: "Insert plain text at the cursor.", parameters: { text: { type: "string", description: "The text", required: true } } },
+    {
+      id: "format",
+      title: "Format",
+      description: "Apply one format command: paragraph, h1\u2013h3, bold, italic, underline, strike, code, highlight, bulletList, orderedList, taskList, blockquote, codeBlock, callout, toggle, pageBreak, horizontalRule, link (with href), unlink, undo, redo.",
+      parameters: {
+        command: { type: "string", description: "The command", required: true },
+        href: { type: "string", description: "For link: an http(s) or mailto address" }
+      }
+    },
+    {
+      id: "insert_page_link",
+      title: "Link a Page",
+      description: "Insert a link to another document (the `wikiLink` mark) at the cursor.",
+      parameters: {
+        pageId: { type: "string", description: "The linked document\u2019s id", required: true },
+        pageTitle: { type: "string", description: "Its title, shown as the link text", required: true }
+      }
+    },
+    { id: "save", title: "Save", description: "Ask the host to save. Refused while read-only or already saving.", parameters: {} }
+  ],
+  config: [
+    { key: "placeholder", label: "Placeholder", type: "text", defaultValue: "Start writing\u2026", description: "The empty-document hint.", placeholder: "Start writing\u2026" },
+    { key: "showTitle", label: "Show title field", type: "boolean", defaultValue: true, description: "Edit the title in the block. Off when the host owns the title." }
+  ],
+  capabilities: ["storage.local"],
+  sdk: "^1.1.0"
+};
+
+// src/docs/document/react/DocumentPanelView.tsx
+import { useEffect, useRef, useSyncExternalStore } from "react";
+import { Column, EmptyState, Input, Note, StatusBar, TextButton, Toolbar, ToolbarGroup } from "@xenosystem/components/chrome";
+
+// src/docs/document/declaration.ts
+var DOCUMENT_TOOLBAR = Object.freeze([
+  { command: "h1", label: "H1" },
+  { command: "h2", label: "H2" },
+  { command: "h3", label: "H3" },
+  { command: "paragraph", label: "Text" },
+  { command: "bold", label: "Bold" },
+  { command: "italic", label: "Italic" },
+  { command: "underline", label: "Underline" },
+  { command: "strike", label: "Strike" },
+  { command: "code", label: "Code" },
+  { command: "bulletList", label: "List" },
+  { command: "orderedList", label: "Numbered" },
+  { command: "taskList", label: "Tasks" },
+  { command: "blockquote", label: "Quote" },
+  { command: "codeBlock", label: "Code block" },
+  { command: "callout", label: "Callout" },
+  { command: "link", label: "Link" }
+]);
+var STATUS = { empty: "", ready: "", saving: "Saving\u2026", saved: "Saved", conflict: "Someone saved a newer version", failed: "Not saved", unsupported: "Read only" };
+function documentViewState(c, options = {}) {
+  const s = c.getState();
+  const has = s.id !== null;
+  const editable = has && !s.readOnly;
+  const words = wordCount(c.currentContent());
+  const note = s.status === "unsupported" ? `${s.message ?? "This document cannot be edited here."}${s.unsupported.length ? ` Open it in XENO Docs to edit it.` : ""}` : s.status === "failed" || s.status === "conflict" ? s.message ?? STATUS[s.status] : null;
+  return {
+    hasDocument: has,
+    editable,
+    readOnly: has && s.readOnly,
+    title: s.title,
+    titleShown: has && options.showTitle !== false,
+    tools: DOCUMENT_TOOLBAR.map((t) => ({ key: t.command, command: t.command, label: t.label, active: c.isActive(t.command) })),
+    toolsShown: editable,
+    unsupported: s.status === "unsupported",
+    note,
+    canSave: editable && s.status !== "saving",
+    statusLabel: s.dirty && s.status !== "saving" ? "Unsaved changes" : STATUS[s.status] ?? "",
+    wordsLabel: `${words} ${words === 1 ? "word" : "words"}`
+  };
+}
+function applyDocumentUi(c, intent) {
+  switch (intent.kind) {
+    case "format":
+      if (DOCUMENT_FORMAT_COMMANDS.includes(intent.command)) c.format(intent.command);
+      break;
+    case "title":
+      c.setTitle(intent.value);
+      break;
+    case "save":
+      c.save();
+      break;
+  }
+}
+var documentViewManifest = {
+  ...documentManifest,
+  capabilities: [],
+  inputs: [{ id: "view", name: "View state", type: "object", description: "The DocumentViewModel the runtime derives from the controller on every draw." }],
+  outputs: [{ id: "ui", name: "UI intent", type: "object", description: "{ kind, command?, value? } \u2014 applied by the runtime to the controller." }],
+  commands: []
+};
+var EMPTY = { hasDocument: false, editable: false, readOnly: false, title: "", titleShown: false, tools: [], toolsShown: false, unsupported: false, note: null, canSave: false, statusLabel: "", wordsLabel: "0 words" };
+var BEHAVIOURS = {
+  "docs/documentPanelView": (inputs) => inputs.view ?? EMPTY
+};
+var DOCUMENT_RUNTIME_UNITS = ["document/Surface"];
+var text = (b) => ({ component: "text", props: { text: b } });
+var ui = (kind, fields = {}) => ({ emit: "ui", value: { object: { kind: { value: kind }, ...fields } } });
+var DOCUMENT_DECLARATION = {
+  format: "xeno.block@1",
+  manifest: documentViewManifest,
+  behaviour: "docs/documentPanelView",
+  composition: {
+    component: "fragment",
+    children: [
+      { component: "chrome/EmptyState", when: { not: { input: "view.hasDocument" } }, props: { title: { value: "No document open" }, hint: { value: "Choose a document, or start a new one." } } },
+      {
+        component: "chrome/Column",
+        when: { input: "view.hasDocument" },
+        children: [
+          {
+            component: "chrome/Toolbar",
+            when: { input: "view.toolsShown" },
+            props: {
+              left: {
+                node: {
+                  component: "chrome/ToolbarGroup",
+                  children: [
+                    {
+                      component: "chrome/TextButton",
+                      each: { input: "view.tools", key: "key" },
+                      props: { strong: { item: "active" } },
+                      children: [text({ item: "label" })],
+                      on: { onClick: ui("format", { command: { item: "command" } }) }
+                    }
+                  ]
+                }
+              },
+              right: {
+                node: {
+                  component: "chrome/ToolbarGroup",
+                  props: { end: { value: true } },
+                  children: [{ component: "chrome/TextButton", props: { strong: { value: true }, disabled: { not: { input: "view.canSave" } } }, children: [text({ value: "Save" })], on: { onClick: ui("save") } }]
+                }
+              }
+            }
+          },
+          { component: "chrome/Input", when: { input: "view.titleShown" }, props: { value: { input: "view.title" }, label: { value: "Title" }, readOnly: { input: "view.readOnly" } }, on: { onChange: ui("title", { value: { arg: "" } }) } },
+          { component: "chrome/Note", when: { input: "view.note" }, children: [text({ input: "view.note" })] },
+          { component: "document/Surface" },
+          { component: "chrome/StatusBar", props: { left: { input: "view.wordsLabel" }, right: { input: "view.statusLabel" } } }
+        ]
+      }
+    ]
+  }
+};
+
+// src/docs/document/react/DocumentPanelView.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function DocumentSurface({ controller, surface }) {
+  const ref = useRef(null);
+  useEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    return mountDocumentSurface(el, controller, surface);
+  }, [controller]);
+  return /* @__PURE__ */ jsx("div", { ref, "data-xeno-document-surface-host": "" });
+}
+var documentRuntimeComponents = (controller, surface) => ({
+  "document/Surface": () => /* @__PURE__ */ jsx(DocumentSurface, { controller, surface })
+});
+function DocumentPanelView({ controller, surface, ...options }) {
+  useSyncExternalStore((fn) => controller.subscribe(fn), () => controller.getState(), () => controller.getState());
+  const view = documentViewState(controller, options);
+  const ui2 = (intent) => applyDocumentUi(controller, intent);
+  if (!view.hasDocument) return /* @__PURE__ */ jsx(EmptyState, { title: "No document open", hint: "Choose a document, or start a new one." });
+  return /* @__PURE__ */ jsxs(Column, { children: [
+    view.toolsShown ? /* @__PURE__ */ jsx(
+      Toolbar,
+      {
+        left: /* @__PURE__ */ jsx(ToolbarGroup, { children: view.tools.map((t) => /* @__PURE__ */ jsx(TextButton, { strong: t.active, onClick: () => ui2({ kind: "format", command: t.command }), children: t.label }, t.key)) }),
+        right: /* @__PURE__ */ jsx(ToolbarGroup, { end: true, children: /* @__PURE__ */ jsx(TextButton, { strong: true, disabled: !view.canSave, onClick: () => ui2({ kind: "save" }), children: "Save" }) })
+      }
+    ) : null,
+    view.titleShown ? /* @__PURE__ */ jsx(Input, { value: view.title, label: "Title", readOnly: view.readOnly, onChange: (value) => ui2({ kind: "title", value }) }) : null,
+    view.note ? /* @__PURE__ */ jsx(Note, { children: view.note }) : null,
+    /* @__PURE__ */ jsx(DocumentSurface, { controller, surface }),
+    /* @__PURE__ */ jsx(StatusBar, { left: view.wordsLabel, right: view.statusLabel })
+  ] });
+}
+
+// src/docs/document/panel.ts
+function createDocumentPanel(options = {}) {
+  return {
+    manifest: documentManifest,
+    activate(host) {
+      const controller = new DocumentController({ host: { emit: (portId, value) => host.emit(portId, value) } });
+      const resolve = (config) => ({
+        showTitle: config.showTitle !== false,
+        placeholder: typeof config.placeholder === "string" ? config.placeholder : "Start writing\u2026"
+      });
+      let renderConfig = resolve(host.config ?? {});
+      let unrender = null;
+      let root = null;
+      let currentEl = null;
+      const draw = (el) => {
+        unrender?.();
+        if (options.render) {
+          unrender = options.render(el, { controller, config: renderConfig });
+          return;
+        }
+        root = createRoot(el);
+        root.render(createElement(DocumentPanelView, { controller, showTitle: renderConfig.showTitle, surface: { placeholder: renderConfig.placeholder, ...options.surface } }));
+        unrender = () => {
+          root?.unmount();
+          root = null;
+        };
+      };
+      const unbindConfig = bindConfig(host, (config) => {
+        renderConfig = resolve(config);
+        if (currentEl) draw(currentEl);
+      });
+      return {
+        render(el) {
+          currentEl = el;
+          draw(el);
+        },
+        onInput(portId, value) {
+          if (portId === "document" && value && typeof value === "object") controller.load(value);
+          else if (portId === "saved") controller.saved(value?.versionId);
+          else if (portId === "status") {
+            const p = value;
+            if (p?.status) controller.setStatus(p.status, p.message);
+          }
+        },
+        async onCommand(commandId, params) {
+          switch (commandId) {
+            case "get_document":
+              return controller.describe();
+            case "set_title":
+              controller.setTitle(String(params.title ?? ""));
+              return true;
+            case "insert_text":
+              return controller.insertText(String(params.text ?? ""));
+            case "format":
+              return controller.format(String(params.command ?? ""), params.href);
+            case "insert_page_link":
+              return controller.insertPageLink(String(params.pageId ?? ""), String(params.pageTitle ?? ""));
+            case "save":
+              return controller.save();
+            default:
+              return;
+          }
+        },
+        serialize() {
+          return controller.serialize();
+        },
+        deserialize(state) {
+          controller.deserialize(state);
+        },
+        dispose() {
+          unbindConfig();
+          currentEl = null;
+          unrender?.();
+          unrender = null;
+          controller.dispose();
+        }
+      };
+    }
+  };
+}
+var documentPanel = createDocumentPanel();
+export {
+  Callout,
+  BEHAVIOURS as DOCUMENT_BEHAVIOURS,
+  DOCUMENT_DECLARATION,
+  DOCUMENT_FORMAT_COMMANDS,
+  DOCUMENT_MARK_TYPES,
+  DOCUMENT_NODE_TYPES,
+  DOCUMENT_PANEL_ID,
+  DOCUMENT_RUNTIME_UNITS,
+  DOCUMENT_TOOLBAR,
+  DocumentController,
+  DocumentPanelView,
+  DocumentSurface,
+  LIMITS,
+  PageBreak,
+  SAFE_IMAGE,
+  SAFE_LINK,
+  SafeImage,
+  ToggleBlock,
+  WikiLinkMark,
+  XDOC_EXTENSION,
+  XDOC_FORMAT,
+  XDOC_VERSION,
+  XdocError,
+  applyDocumentUi,
+  createDocumentExtensions,
+  createDocumentPanel,
+  documentManifest,
+  documentPanel,
+  documentRuntimeComponents,
+  documentToMarkdown,
+  documentViewManifest,
+  documentViewState,
+  editorHandle,
+  emptyContent,
+  markdownToDocument,
+  mountDocumentSurface,
+  nodeTypesIn,
+  pageLinksIn,
+  parseXdoc,
+  plainText,
+  runFormat,
+  serializeXdoc,
+  validateContent,
+  wordCount
+};