agentic-documents 0.5.0 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 0.6.0
+
+### Added
+
+- `agentic-documents/ui`: `mountEditor(element, { id, client, principal, room? })` and the `DocumentEditor` React component
+  render the editor in a host app, with live co-editing through agentic-realtime when a room is given. Its styles are
+  in `agentic-documents/ui.css`. `react` and `react-dom` are optional peer dependencies; the Tiptap packages and
+  `agentic-design` are now dependencies.
+- The edit log has a new op, `live`. The editor writes one `live` entry when an agent principal types, so its text is
+  marked as agent work. Its counts are 0.
+
+### Changed
+
+- The ODT export uses `agentic-formats`. The local ODT writer and the `fflate` dependency are gone. `exportOdt` and
+  `ODT_MIME` stay as thin wrappers. The ODT file now comes from the neutral text model, so its XML differs from before.
+- The ODT export holds less than before, because the agentic-formats text model has no block for a quote, a rule, or a
+  code block, no list start number, one paragraph for each list item, and no WebP image. The text stays.
+  `ExportResult` has a `warnings` field that names each loss. It is empty for `md` and `html`. The field is required, so
+  code that builds an `ExportResult` by hand must add it. The CLI prints each warning on stderr. The HTTP API sends them
+  in the `x-export-warnings` header.
+
 ## 0.5.0
 
 ### Breaking

package/README.md

@@ -7,7 +7,7 @@
 
 Write documents with people and agents in real time.
 
-> Status: early, version 0.5.0. The document model, the text operations, the CLI, the MCP server,
+> Status: early, version 0.6.0. The document model, the text operations, the CLI, the MCP server,
 > the Worker API, live editing in a room, and a small web UI work. See [UI](#ui).
 
 ## Install
@@ -195,7 +195,7 @@ try {
 }
 ```
 
-- One method per route: `create`, `read`, `outline`, `edits`, `insert`, `replace`, `delete`, `append`,
+- One method per route: `create`, `list`, `read`, `rename`, `remove`, `outline`, `edits`, `insert`, `replace`, `delete`, `append`,
   `suggest`, `suggestions`, `accept`, `reject`, `comment`, `reply`, `resolve`, `reopen`, `threads`,
   `export`, `room`, `me`, `health`, `state`, and `checkpoint`. The WebSocket route is not a method. Use
   `LiveDoc` from `agentic-documents/live` for it.
@@ -205,6 +205,47 @@ try {
 - The client never retries. A write is not safe to send twice.
 - Pass `fetch` to use your own, for a Worker service binding or for tests.
 
+## Embed the editor
+
+`agentic-documents/ui` renders the editor inside your own app. You give it a document id, a client, the principal who
+uses it, and an optional live room. With a room, people and agents edit together through agentic-realtime and see each
+other. It needs `react` and `react-dom` 19 (peer dependencies).
+
+```ts
+import { createClient } from "agentic-documents/client";
+import { mountEditor } from "agentic-documents/ui";
+import "agentic-design/styles.css";
+import "agentic-documents/ui.css";
+
+const client = createClient({ baseUrl: "https://docs.example.com", token });
+const principal = await client.me(); // { kind, name, role }
+const editor = mountEditor(document.getElementById("editor")!, {
+  id: "plan",
+  client,
+  principal,
+  room: { url: "wss://docs.example.com/api/v1/docs/plan/ws", token },
+});
+// Later: editor.update({ ...options, id: "other" }), or await editor.unmount() to save this tab's changes and leave.
+```
+
+- In a React app, render `<DocumentEditor id client principal room onError onLeave />` instead. `onLeave` gets the
+  promise of the last save.
+- `client` needs only `state` and `checkpoint`. A client from `createClient` has them, or pass your own. Keep the
+  same client object between renders: a new one opens the document again.
+- `principal` needs a `kind` (one of the principal kinds) and a `name`. A missing or unknown kind throws a
+  `TypeError`. It is never given a default. Only the `role` `editor` can change the text. Any other role, or no role,
+  opens it read only. The server still checks every write against the token. Use the principal that `client.me()`
+  returns for the same token, so the editor labels the text with the kind that the server gives the token.
+- When an agent principal types, the editor writes one `live` entry to the edit log for its Yjs client. The editor
+  and the web UI then mark that text as agent work for everyone who opens the document.
+- `room.url` is the WebSocket address of the document room. In a browser the token goes in a WebSocket subprotocol.
+  Pass `room.WebSocket` for a room that takes its token another way. Without a room, the editor saves through the
+  client and shows no other people.
+- The editor saves 1.5 seconds after this tab changes the text, and again on `unmount`. The promise from `unmount`
+  rejects when that last save fails. A save never makes a document, so a removed document stays removed.
+- The styles sit under the `.adoc` class and use the agentic-design tokens. Load `agentic-design/styles.css` first.
+- File import and export are in `agentic-documents/formats` (see [File formats](#file-formats)).
+
 ## File formats
 
 `agentic-documents/formats` imports and exports files, so an app that embeds the editor needs no mapping
@@ -215,7 +256,7 @@ code of its own. ODT and DOCX go through the neutral text model of
 import { exportFile, importFile } from "agentic-documents/formats";
 
 const { doc, title, warnings } = importFile(bytes, "docx", { kind: "human", name: "Ada" });
-const odt = exportFile(doc, "odt", { title }); // { contentType, data: Uint8Array, warnings }
+const odt = exportFile(doc, "odt", { title }); // { contentType, data (Uint8Array for odt), warnings }
 ```
 
 - `importFile(input, format, author, { limits? })` reads `md` (text or UTF-8 bytes), `odt`, or `docx` (bytes) into a
@@ -250,10 +291,10 @@ const odt = exportFile(doc, "odt", { title }); // { contentType, data: Uint8Arra
   one application and undoes the other, so the text and the edit log hold it once. An accept
   beats a reject made at the same moment.
 - Export to ODT (OpenDocument text): headings, paragraphs, bold, italic, strike, code, links, lists,
-  quotes, rules, tables, and images as embedded files. The package follows ODF 1.3 with the mimetype
-  stored first. The CLI and the API send the file bytes. LibreOffice opens it, lists keep their
-  numbers, and its own re-save reads back to the same Markdown (checked by hand with LibreOffice 24.8
-  in the PR that added it).
+  tables, and PNG, JPEG, and GIF images as embedded files. `agentic-formats` writes the file, with the
+  mimetype stored first. The CLI and the API send the file bytes. A quote, a code block, a rule, a list
+  start number, and a WebP image are not kept in full (see Limits). Each loss is in `warnings` (SDK and
+  MCP), on stderr (CLI), and in the `x-export-warnings` header (API).
 - Export to Markdown and to self-contained HTML. The HTML loads nothing from other hosts. An image
   stored in the document as a `data:` URI (PNG, JPEG, GIF, or WebP) shows. Any other image becomes
   its alt text, because a remote image tells its host who opened the file. `remoteImages` turns
@@ -359,7 +400,9 @@ Limits of live editing:
   of code text, a horizontal rule is left out, a numbered list starts at 1, and a task list becomes a list that starts
   each item with `☐` or `☑`. On import, underline, superscript, and subscript are left out, and a footnote becomes
   text in brackets, and code text keeps only its code mark. Each one is named in `warnings`.
-- ODT export: comments and suggestions are not written. A code block loses its language. A table
+- ODT export: a quote becomes plain paragraphs, a code block becomes a paragraph of code text, a rule is
+  left out, a numbered list starts at 1, a list item keeps one paragraph, and a WebP image becomes its alt text.
+  Comments and suggestions are not written. A code block loses its language. A table
   cell span is not written (the model has none yet). A task list becomes a bullet list that starts each
   item with `☐` or `☑`. A remote image is not linked, because an office program would ask its host
   for it when the file opens. It becomes its alt text.

package/dist/{chunk-7R7ZPPRF.js → chunk-34C47PDC.js}

@@ -1,6 +1,6 @@
 import {
   DocError
-} from "./chunk-6QOYS63L.js";
+} from "./chunk-GQ5E6T7Z.js";
 
 // src/adapters/file-blobs.ts
 import { createHash, randomUUID } from "crypto";

package/dist/{chunk-UPEGODUV.js → chunk-5IQX2W52.js}

@@ -2,7 +2,7 @@ import {
   APPLIED,
   DocError,
   checkAuthor
-} from "./chunk-6QOYS63L.js";
+} from "./chunk-GQ5E6T7Z.js";
 
 // src/review.ts
 import * as Y from "yjs";

package/dist/{chunk-S6MQDWFK.js → chunk-6UYJV2EJ.js}

@@ -1,14 +1,26 @@
-import {
-  EXPORT_FORMATS,
-  exportDoc
-} from "./chunk-L6W2AQUF.js";
 import {
   Suggestions,
   Threads
-} from "./chunk-UPEGODUV.js";
+} from "./chunk-5IQX2W52.js";
+import {
+  EXPORT_FORMATS,
+  exportFile,
+  exportText,
+  toBase64
+} from "./chunk-KC5KFB5R.js";
 import {
   DocError
-} from "./chunk-6QOYS63L.js";
+} from "./chunk-GQ5E6T7Z.js";
+
+// src/export.ts
+function exportDoc(doc, format, options = {}) {
+  if (format === "odt") {
+    const file = exportFile(doc, "odt");
+    return { format, contentType: file.contentType, encoding: "base64", data: toBase64(file.data), warnings: file.warnings };
+  }
+  const contentType = format === "html" ? "text/html; charset=utf-8" : "text/markdown; charset=utf-8";
+  return { format, contentType, encoding: "utf8", data: exportText(doc, format, options), warnings: [] };
+}
 
 // src/commands.ts
 import { z } from "zod";
@@ -146,5 +158,6 @@ var commands = [
 ];
 
 export {
+  exportDoc,
   commands
 };

package/dist/{chunk-E7B6T5WN.js → chunk-CN6UAW7B.js}

@@ -1,12 +1,14 @@
 import {
   MAX_LIVE_BYTES
-} from "./chunk-YNHZCIGO.js";
+} from "./chunk-JBAQEIOH.js";
 import {
   AgenticDoc,
   DOC_ERROR_CODES,
-  DocError,
+  DocError
+} from "./chunk-GQ5E6T7Z.js";
+import {
   PRINCIPAL_KINDS
-} from "./chunk-6QOYS63L.js";
+} from "./chunk-DWVJIKVT.js";
 
 // src/live.ts
 import * as Y from "yjs";

package/dist/chunk-DWVJIKVT.js

@@ -0,0 +1,8 @@
+// src/kinds.ts
+var PRINCIPAL_KINDS = ["human", "agent_of_human", "agent_of_agent", "agent", "user_token"];
+var isMachine = (kind) => kind !== "human";
+
+export {
+  PRINCIPAL_KINDS,
+  isMachine
+};

package/dist/{chunk-6QOYS63L.js → chunk-GQ5E6T7Z.js}

@@ -1,3 +1,7 @@
+import {
+  PRINCIPAL_KINDS
+} from "./chunk-DWVJIKVT.js";
+
 // src/errors.ts
 var DOC_ERROR_CODES = ["NO_MATCH", "AMBIGUOUS_MATCH", "STALE_ANCHOR", "NO_SECTION", "INVALID_AUTHOR", "INVALID_INPUT", "NO_THREAD", "NO_SUGGESTION", "ALREADY_DECIDED", "FORBIDDEN", "NO_DOCUMENT", "DOCUMENT_EXISTS", "LOCKED", "CONFLICT", "MISCONFIGURED"];
 var DocError = class extends Error {
@@ -314,7 +318,6 @@ function settle(ydoc) {
 var PREAMBLE = "preamble";
 var FRAGMENT = "default";
 var CONTEXT_CHARS = 20;
-var PRINCIPAL_KINDS = ["human", "agent_of_human", "agent_of_agent", "agent", "user_token"];
 var isSection = (t) => "section" in t;
 var isAnchor = (t) => "anchor" in t;
 function checkAuthor(author) {
@@ -562,7 +565,6 @@ export {
   blocksToMarkdown,
   schema,
   APPLIED,
-  PRINCIPAL_KINDS,
   checkAuthor,
   parseAuthor,
   AgenticDoc

package/dist/{chunk-YNHZCIGO.js → chunk-JBAQEIOH.js}

@@ -2,12 +2,14 @@ import {
   Suggestions,
   Threads,
   isPerson
-} from "./chunk-UPEGODUV.js";
+} from "./chunk-5IQX2W52.js";
 import {
   AgenticDoc,
-  DocError,
+  DocError
+} from "./chunk-GQ5E6T7Z.js";
+import {
   PRINCIPAL_KINDS
-} from "./chunk-6QOYS63L.js";
+} from "./chunk-DWVJIKVT.js";
 
 // src/service.ts
 import * as Y from "yjs";

package/dist/chunk-KC5KFB5R.js

@@ -0,0 +1,354 @@
+import {
+  AgenticDoc,
+  DocError,
+  checkAuthor
+} from "./chunk-GQ5E6T7Z.js";
+
+// src/formats.ts
+import { DEFAULT_LIMITS, FormatError, readDocx, readOdt, writeDocx, writeOdt } from "agentic-formats";
+
+// src/render.ts
+var EXPORT_FORMATS = ["md", "html", "odt"];
+var esc = (s) => String(s ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+var url = (value) => /^(https?:|mailto:|[^:]*$)/i.test(String(value ?? "").trim()) ? esc(String(value).trim()) : "#";
+var integer = (value, fallback) => Number.isFinite(Number(value)) ? Math.trunc(Number(value)) : fallback;
+var INLINE_IMAGE = /^data:image\/(png|jpeg|gif|webp);base64,[a-z0-9+/=]+$/i;
+var textOf = (node) => node.text ?? (node.content ?? []).map(textOf).join("");
+var MARK_TAGS = { bold: "strong", italic: "em", strike: "s", code: "code" };
+function image(node, remote) {
+  const src = String(node.attrs?.src ?? "").trim();
+  const alt = esc(node.attrs?.alt);
+  if (INLINE_IMAGE.test(src)) return `<img src="${src}" alt="${alt}">`;
+  if (remote && url(src) !== "#") return `<img src="${url(src)}" alt="${alt}">`;
+  return `<span class="image">[image${alt ? `: ${alt}` : ""}]</span>`;
+}
+function inline(node, remote) {
+  if (node.type === "hardBreak") return "<br>";
+  if (node.type === "image") return image(node, remote);
+  return (node.marks ?? []).reduce((html, mark) => {
+    if (mark.type === "link") return `<a href="${url(mark.attrs?.href)}">${html}</a>`;
+    const tag = MARK_TAGS[mark.type];
+    return tag ? `<${tag}>${html}</${tag}>` : html;
+  }, esc(node.text));
+}
+function block(node, remote) {
+  const kids = (node.content ?? []).map((n) => block(n, remote)).join("");
+  const text = (node.content ?? []).map((n) => inline(n, remote)).join("");
+  switch (node.type) {
+    case "paragraph":
+      return `<p>${text}</p>
+`;
+    case "heading": {
+      const level = Math.min(6, Math.max(1, integer(node.attrs?.level, 1)));
+      return `<h${level}>${text}</h${level}>
+`;
+    }
+    case "blockquote":
+      return `<blockquote>
+${kids}</blockquote>
+`;
+    case "codeBlock": {
+      const lang = node.attrs?.language ? ` class="language-${esc(node.attrs.language)}"` : "";
+      return `<pre><code${lang}>${esc(textOf(node))}</code></pre>
+`;
+    }
+    case "horizontalRule":
+      return "<hr>\n";
+    case "bulletList":
+    case "taskList":
+      return `<ul>
+${kids}</ul>
+`;
+    case "orderedList":
+      return `<ol start="${integer(node.attrs?.start, 1)}">
+${kids}</ol>
+`;
+    case "listItem":
+      return `<li>${kids}</li>
+`;
+    case "taskItem":
+      return `<li><input type="checkbox" disabled${node.attrs?.checked ? " checked" : ""}> ${kids}</li>
+`;
+    case "table":
+      return `<table>
+${kids}</table>
+`;
+    case "tableRow":
+      return `<tr>${kids}</tr>
+`;
+    case "tableHeader":
+      return `<th>${kids}</th>`;
+    case "tableCell":
+      return `<td>${kids}</td>`;
+    default:
+      return "";
+  }
+}
+function toHtml(blocks, remote) {
+  const title = textOf(blocks.find((b) => b.type === "heading") ?? { type: "doc" }) || "Document";
+  const css = "body{font-family:system-ui,sans-serif;max-width:46rem;margin:2rem auto;padding:0 1rem;line-height:1.5}table{border-collapse:collapse}td,th{border:1px solid #888;padding:.25rem .5rem}pre{overflow:auto}";
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>${esc(title)}</title>
+<style>${css}</style>
+</head>
+<body>
+${blocks.map((b) => block(b, remote)).join("")}</body>
+</html>
+`;
+}
+function exportText(doc, format, options = {}) {
+  return format === "html" ? toHtml(doc.toJSON().content ?? [], options.remoteImages === true) : doc.toMarkdown();
+}
+
+// src/package.ts
+var DATA_IMAGE = /^data:(image\/(?:png|jpeg|gif|webp));base64,([a-z0-9+/=]+)$/i;
+function toBase64(bytes) {
+  let text = "";
+  for (let i = 0; i < bytes.length; i += 32768) text += String.fromCharCode(...bytes.subarray(i, i + 32768));
+  return btoa(text);
+}
+var fromBase64 = (value) => Uint8Array.from(atob(value), (c) => c.charCodeAt(0));
+
+// src/xml.ts
+var safeHref = (value) => {
+  const href = String(value ?? "").trim();
+  return /^(https?:|mailto:|#|[^:]*$)/i.test(href) ? href : void 0;
+};
+
+// src/formats.ts
+var IMPORT_FORMATS = ["md", "odt", "docx"];
+var FILE_FORMATS = ["md", "html", "odt", "docx"];
+var DOCX_MIME = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+var CONTENT_TYPES = {
+  md: "text/markdown; charset=utf-8",
+  html: "text/html; charset=utf-8",
+  odt: "application/vnd.oasis.opendocument.text",
+  docx: DOCX_MIME
+};
+var PM_MARKS = { bold: "bold", italic: "italic", strike: "strike", code: "code" };
+var MODEL_IMAGE = /^image\/(png|jpeg|gif)$/;
+var TASK = ["\u2610 ", "\u2611 "];
+var warner = () => {
+  const seen = /* @__PURE__ */ new Set();
+  return { warn: (line) => void seen.add(line), list: () => [...seen] };
+};
+function toTextDoc(blocks, title) {
+  const { warn, list } = warner();
+  const inlines = (nodes = [], extra = []) => nodes.flatMap((node) => {
+    if (node.type === "hardBreak") return [{ type: "break" }];
+    if (node.type === "image") {
+      const alt = typeof node.attrs?.alt === "string" ? node.attrs.alt : "";
+      const found = DATA_IMAGE.exec(String(node.attrs?.src ?? "").trim());
+      if (found && MODEL_IMAGE.test(found[1].toLowerCase())) {
+        try {
+          return [{ type: "image", data: fromBase64(found[2]), mime: found[1].toLowerCase(), ...alt ? { alt } : {} }];
+        } catch {
+        }
+      }
+      warn("an image that is not an embedded PNG, JPEG, or GIF is kept as its alt text");
+      return [{ type: "text", text: `[image${alt ? `: ${alt}` : ""}]` }];
+    }
+    if (!node.text) return [];
+    const marks = [...extra, ...(node.marks ?? []).flatMap((m) => PM_MARKS[m.type] ? [PM_MARKS[m.type]] : [])];
+    const href = safeHref((node.marks ?? []).find((m) => m.type === "link")?.attrs?.href);
+    return [{ type: "text", text: node.text, ...marks.length ? { marks } : {}, ...href ? { href } : {} }];
+  });
+  const listOf = (node) => {
+    const items = (node.content ?? []).map((item) => {
+      const [first, ...rest] = item.content ?? [];
+      const content = inlines(first?.content);
+      if (item.type === "taskItem") content.unshift({ type: "text", text: TASK[item.attrs?.checked ? 1 : 0] });
+      let sublist;
+      for (const child of rest) {
+        if (!sublist && /^(bulletList|orderedList|taskList)$/.test(child.type)) sublist = listOf(child);
+        else {
+          warn("a list item with more than one paragraph is kept as one paragraph with line breaks");
+          for (const b of toBlocks(child)) content.push({ type: "break" }, ...textOfBlock(b));
+        }
+      }
+      return { content, ...sublist ? { sublist } : {} };
+    });
+    if (node.type === "orderedList" && Number(node.attrs?.start ?? 1) !== 1) warn("a numbered list that does not start at 1 starts at 1");
+    return { type: "list", ordered: node.type === "orderedList", items };
+  };
+  const textOfBlock = (b) => b.type === "list" ? b.items.flatMap((i, n) => [...n ? [{ type: "break" }] : [], ...i.content]) : b.type === "table" ? b.rows.flat(2).flatMap(textOfBlock) : b.content;
+  const toBlocks = (node) => {
+    switch (node.type) {
+      case "paragraph":
+        return [{ type: "paragraph", content: inlines(node.content) }];
+      case "heading": {
+        const level = Math.min(6, Math.max(1, Math.trunc(Number(node.attrs?.level)) || 1));
+        return [{ type: "heading", level, content: inlines(node.content) }];
+      }
+      case "blockquote":
+        warn("a quote is kept as plain paragraphs");
+        return (node.content ?? []).flatMap(toBlocks);
+      case "codeBlock": {
+        warn("a code block is kept as a paragraph of code text");
+        const lines = (node.content ?? []).map((t) => t.text ?? "").join("").split("\n");
+        return [{ type: "paragraph", content: lines.flatMap((line, i) => [...i ? [{ type: "break" }] : [], ...line ? [{ type: "text", text: line, marks: ["code"] }] : []]) }];
+      }
+      case "horizontalRule":
+        warn("a horizontal rule is left out");
+        return [];
+      case "bulletList":
+      case "orderedList":
+      case "taskList":
+        return [listOf(node)];
+      case "table": {
+        const rows = node.content ?? [];
+        const header = rows.length > 0 && (rows[0].content ?? []).length > 0 && (rows[0].content ?? []).every((c) => c.type === "tableHeader");
+        return [{ type: "table", ...header ? { header: true } : {}, rows: rows.map((r) => (r.content ?? []).map((c) => (c.content ?? []).flatMap(toBlocks))) }];
+      }
+      default:
+        warn(`a ${node.type} block is left out`);
+        return [];
+    }
+  };
+  const model = { ...title ? { title } : {}, blocks: blocks.flatMap(toBlocks) };
+  return { model, warnings: list() };
+}
+function fromTextDoc(model) {
+  const { warn, list } = warner();
+  const text = (value, marks = []) => value ? [{ type: "text", text: value, ...marks.length ? { marks } : {} }] : [];
+  const inlines = (nodes) => nodes.flatMap((node) => {
+    switch (node.type) {
+      case "break":
+        return [{ type: "hardBreak" }];
+      case "image":
+        if (!MODEL_IMAGE.test(node.mime)) {
+          warn("an image that is not a PNG, JPEG, or GIF is kept as its alt text");
+          return text(`[image${node.alt ? `: ${node.alt}` : ""}]`);
+        }
+        return [{ type: "image", attrs: { src: `data:${node.mime};base64,${toBase64(node.data)}`, alt: node.alt ?? null, title: null } }];
+      case "footnote":
+        warn("a footnote is kept as text in brackets");
+        return [...text(" ["), ...inlines(node.content), ...text("]")];
+      case "text": {
+        const marks = [];
+        for (const mark of node.marks ?? []) {
+          if (mark === "bold" || mark === "italic" || mark === "strike" || mark === "code") marks.push({ type: mark });
+          else warn(`the ${mark} mark is left out; the text stays`);
+        }
+        const href = node.href === void 0 ? void 0 : safeHref(node.href);
+        if (node.href !== void 0 && !href) warn("a link that is not a web, mail, or relative address is left out; the text stays");
+        if (href) marks.push({ type: "link", attrs: { href } });
+        if (marks.length > 1 && marks.some((m) => m.type === "code")) {
+          warn("a mark or a link on code text is left out; the text stays as code");
+          return text(node.text, [{ type: "code" }]);
+        }
+        return text(node.text, marks);
+      }
+      default:
+        return [];
+    }
+  });
+  const paragraph = (content) => ({ type: "paragraph", ...content.length ? { content: inlines(content) } : {} });
+  const toNodes = (block2) => {
+    switch (block2.type) {
+      case "heading":
+        return [{ type: "heading", attrs: { level: block2.level }, content: inlines(block2.content) }];
+      case "paragraph":
+        return [paragraph(block2.content)];
+      case "list":
+        return [
+          {
+            type: block2.ordered ? "orderedList" : "bulletList",
+            ...block2.ordered ? { attrs: { start: 1, type: null } } : {},
+            content: block2.items.map((item) => ({ type: "listItem", content: [paragraph(item.content), ...item.sublist ? toNodes(item.sublist) : []] }))
+          }
+        ];
+      case "table": {
+        const rows = block2.rows.filter((r) => r.length > 0);
+        if (rows.length === 0) return [];
+        return [
+          {
+            type: "table",
+            content: rows.map((row, i) => ({
+              type: "tableRow",
+              content: row.map((cell) => {
+                const content = cell.flatMap(toNodes);
+                return { type: block2.header && i === 0 ? "tableHeader" : "tableCell", attrs: { colspan: 1, rowspan: 1, colwidth: null }, content: content.length ? content : [{ type: "paragraph" }] };
+              })
+            }))
+          }
+        ];
+      }
+      default:
+        return [];
+    }
+  };
+  const prune = (node) => node.content ? { ...node, content: node.content.filter((n) => n.type !== "text" || n.text).map(prune) } : node;
+  const blocks = model.blocks.flatMap(toNodes).map(prune);
+  return { blocks, ...model.title ? { title: model.title } : {}, warnings: list() };
+}
+var formatFailure = (error) => {
+  if (error instanceof FormatError) throw new DocError("INVALID_INPUT", `the file was refused (${error.code}): ${error.message}`);
+  throw error;
+};
+function importFile(input, format, author, options = {}) {
+  checkAuthor(author);
+  if (!IMPORT_FORMATS.includes(format)) throw new DocError("INVALID_INPUT", `import format must be one of ${IMPORT_FORMATS.join(", ")}`);
+  const maxBytes = options.limits?.maxInputBytes ?? DEFAULT_LIMITS.maxInputBytes;
+  if (format === "md") {
+    let markdown;
+    try {
+      markdown = typeof input === "string" ? input : new TextDecoder("utf-8", { fatal: true }).decode(input);
+    } catch {
+      throw new DocError("INVALID_INPUT", "a md file must be UTF-8 text");
+    }
+    if (new TextEncoder().encode(markdown).length > maxBytes) throw new DocError("INVALID_INPUT", `the file is larger than ${maxBytes} bytes`);
+    return { doc: AgenticDoc.fromMarkdown(markdown, author, options.doc), warnings: [] };
+  }
+  if (!(input instanceof Uint8Array)) throw new DocError("INVALID_INPUT", `a ${format} file must be bytes, not text`);
+  let read;
+  try {
+    read = format === "odt" ? readOdt(input, options.limits) : readDocx(input, options.limits);
+  } catch (error) {
+    return formatFailure(error);
+  }
+  const mapped = fromTextDoc(read.model);
+  return {
+    doc: AgenticDoc.fromBlocks(mapped.blocks, author, options.doc),
+    ...mapped.title ? { title: mapped.title } : {},
+    warnings: [...read.warnings, ...mapped.warnings]
+  };
+}
+var ODT_MIME = CONTENT_TYPES.odt;
+function exportOdt(blocks) {
+  try {
+    return writeOdt(toTextDoc(blocks).model).bytes;
+  } catch (error) {
+    return formatFailure(error);
+  }
+}
+function exportFile(doc, format, options = {}) {
+  if (!FILE_FORMATS.includes(format)) throw new DocError("INVALID_INPUT", `export format must be one of ${FILE_FORMATS.join(", ")}`);
+  if (format === "md" || format === "html") return { format, contentType: CONTENT_TYPES[format], data: exportText(doc, format, options), warnings: [] };
+  const { model, warnings } = toTextDoc(doc.toJSON().content ?? [], options.title);
+  let written;
+  try {
+    written = format === "odt" ? writeOdt(model) : writeDocx(model);
+  } catch (error) {
+    return formatFailure(error);
+  }
+  return { format, contentType: CONTENT_TYPES[format], data: written.bytes, warnings: [...warnings, ...written.warnings] };
+}
+
+export {
+  EXPORT_FORMATS,
+  exportText,
+  toBase64,
+  IMPORT_FORMATS,
+  FILE_FORMATS,
+  DOCX_MIME,
+  toTextDoc,
+  fromTextDoc,
+  importFile,
+  ODT_MIME,
+  exportOdt,
+  exportFile
+};

package/dist/{chunk-FX755I7V.js → chunk-V6TBTOHW.js}

@@ -1,15 +1,17 @@
+import {
+  commands
+} from "./chunk-6UYJV2EJ.js";
 import {
   DocsService,
   MAX_LIVE_BYTES
-} from "./chunk-YNHZCIGO.js";
-import {
-  commands
-} from "./chunk-S6MQDWFK.js";
+} from "./chunk-JBAQEIOH.js";
 import {
   DocError,
-  PRINCIPAL_KINDS,
   parseAuthor
-} from "./chunk-6QOYS63L.js";
+} from "./chunk-GQ5E6T7Z.js";
+import {
+  PRINCIPAL_KINDS
+} from "./chunk-DWVJIKVT.js";
 
 // src/worker.ts
 import { Hono } from "hono";
@@ -163,10 +165,11 @@ function createApp(source, options = {}) {
       if (!command.readOnly && c.get("role") === "viewer") throw new DocError("FORBIDDEN", "this token is a viewer; it cannot change a document");
       const result = await command.run(await (typeof source === "function" ? source(c.env ?? {}) : source), input, c.get("author"));
       if (command.name === "export") {
-        const { data, contentType, encoding, format } = result;
+        const { data, contentType, encoding, format, warnings } = result;
         const images = input.remoteImages === true || input.remoteImages === "true" ? "data: https:" : "data:";
         const disposition = format === "odt" ? { "content-disposition": `attachment; filename="${input.id}.odt"` } : {};
-        const headers = { ...disposition, "content-type": contentType, "content-security-policy": `default-src 'none'; style-src 'unsafe-inline'; img-src ${images}; sandbox` };
+        const lost = warnings.length ? { "x-export-warnings": JSON.stringify(warnings).replace(/[^\x20-\x7e]/g, (ch) => `\\u${ch.charCodeAt(0).toString(16).padStart(4, "0")}`) } : {};
+        const headers = { ...disposition, ...lost, "content-type": contentType, "content-security-policy": `default-src 'none'; style-src 'unsafe-inline'; img-src ${images}; sandbox` };
         return encoding === "base64" ? c.body(Uint8Array.from(atob(data), (ch) => ch.charCodeAt(0)), 200, headers) : c.body(data, 200, headers);
       }
       if (typeof result === "string") return c.body(result, 200, { "content-type": "text/markdown; charset=utf-8" });