agentic-documents 0.4.0 → 0.6.0

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-IU3YIQ4Y.js → chunk-V6TBTOHW.js}

@@ -1,15 +1,17 @@
+import {
+  commands
+} from "./chunk-6UYJV2EJ.js";
 import {
   DocsService,
   MAX_LIVE_BYTES
-} from "./chunk-FZA5LQV3.js";
-import {
-  commands
-} from "./chunk-GYQFTF2E.js";
+} from "./chunk-JBAQEIOH.js";
 import {
   DocError,
-  PRINCIPAL_KINDS,
   parseAuthor
-} from "./chunk-YBBQNCMC.js";
+} from "./chunk-GQ5E6T7Z.js";
+import {
+  PRINCIPAL_KINDS
+} from "./chunk-DWVJIKVT.js";
 
 // src/worker.ts
 import { Hono } from "hono";
@@ -104,6 +106,22 @@ async function readCapped(request, cap) {
   }
   return whole;
 }
+var WS_PROTOCOL = "agentic-docs";
+var WS_BEARER = `${WS_PROTOCOL}.bearer.`;
+function socketBearer(c) {
+  if (c.req.header("upgrade") !== "websocket" || !c.req.path.endsWith("/ws")) return void 0;
+  for (const offered of (c.req.header("sec-websocket-protocol") ?? "").split(",")) {
+    const part = offered.trim();
+    if (!part.startsWith(WS_BEARER)) continue;
+    try {
+      const base64 = part.slice(WS_BEARER.length).replace(/-/g, "+").replace(/_/g, "/");
+      return new TextDecoder("utf-8", { fatal: true }).decode(Uint8Array.from(atob(base64), (ch) => ch.charCodeAt(0)));
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
 var DOC_ID = /^[a-z0-9][a-z0-9_-]{0,63}$/;
 function createApp(source, options = {}) {
   const app2 = new Hono();
@@ -113,7 +131,7 @@ function createApp(source, options = {}) {
   });
   app2.get("/health", (c) => c.json({ ok: true, pack: "agentic-documents" }));
   app2.use("/api/v1/*", async (c, next) => {
-    const bearer = /^Bearer (.+)$/.exec(c.req.header("authorization") ?? "")?.[1];
+    const bearer = /^Bearer (.+)$/.exec(c.req.header("authorization") ?? "")?.[1] ?? socketBearer(c);
     const identity = bearer === void 0 ? void 0 : identityFor(c.env?.AGENTIC_DOCS_TOKENS, bearer);
     if (!identity) return fail("UNAUTHENTICATED", "send a valid bearer token", 401);
     c.set("author", identity.principal);
@@ -130,23 +148,28 @@ function createApp(source, options = {}) {
     const { contributors } = await options.live(c.env ?? {}).meta(c.req.param("id"));
     return c.json({ contributors: contributors.map(({ id, kind, machine }) => ({ name: id, kind, machine })) });
   });
-  app2.get("/api/v1/docs/:id/ws", (c) => {
+  app2.get("/api/v1/docs/:id/ws", async (c) => {
     const id = c.req.param("id");
     if (!options.live) return fail("NOT_FOUND", "this server hosts no live rooms", 404);
     if (c.req.header("upgrade") !== "websocket") return fail("UPGRADE_REQUIRED", "open this route as a WebSocket", 426);
     if (!DOC_ID.test(id)) return fail("INVALID_INPUT", `invalid document id "${id}"`, 400);
     const { kind, name } = c.get("author");
-    return options.live(c.env ?? {}).connect(id, c.req.raw, { principal: { id: name, kind }, role: c.get("role"), name });
+    const opened = options.live(c.env ?? {}).connect(id, c.req.raw, { principal: { id: name, kind }, role: c.get("role"), name });
+    if (!(c.req.header("sec-websocket-protocol") ?? "").split(",").some((p) => p.trim() === WS_PROTOCOL)) return opened;
+    const room = await opened;
+    const socket = room.webSocket;
+    return socket ? new Response(null, { status: 101, webSocket: socket, headers: new Headers([...room.headers, ["sec-websocket-protocol", WS_PROTOCOL]]) }) : room;
   });
   async function run(c, command, input) {
     try {
       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" });
@@ -171,12 +194,14 @@ function createApp(source, options = {}) {
   app2.post("/api/v1/docs/:id/checkpoint", async (c) => {
     if (c.get("role") === "viewer") throw new DocError("FORBIDDEN", "this token is a viewer; it cannot change a document");
     const update = await readCapped(c.req.raw, MAX_LIVE_BYTES);
-    await (await serviceOf(c)).checkpoint(c.req.param("id"), update, c.get("author"));
+    await (await serviceOf(c)).checkpoint(c.req.param("id"), update, c.get("author"), { create: c.req.query("create") !== "false" });
     return c.json({ ok: true });
   });
   const create = commands.find((c) => c.name === "new");
+  const listing = commands.find((c) => c.name === "list");
   app2.post("/api/v1/docs", async (c) => run(c, create, await body(c)));
-  for (const command of commands.filter((c) => c !== create)) {
+  app2.get("/api/v1/docs", (c) => run(c, listing, {}));
+  for (const command of commands.filter((c) => c !== create && c !== listing)) {
     const path = `/api/v1/docs/:id/${command.name}`;
     if (command.readOnly) app2.get(path, (c) => run(c, command, { ...c.req.query(), id: c.req.param("id") }));
     else app2.post(path, async (c) => run(c, command, { ...await body(c), id: c.req.param("id") }));

package/dist/cli.js

@@ -1,25 +1,28 @@
 #!/usr/bin/env node
+import {
+  VERSION
+} from "./chunk-5Y66UCTE.js";
 import {
   createFileBlobs,
   createFileStore
-} from "./chunk-TFCRPEEM.js";
+} from "./chunk-34C47PDC.js";
 import {
   LiveService,
   whoAmI
-} from "./chunk-R5XUTBC3.js";
-import {
-  DocsService
-} from "./chunk-FZA5LQV3.js";
-import {
-  VERSION
-} from "./chunk-5Y66UCTE.js";
+} from "./chunk-CN6UAW7B.js";
 import {
   commands
-} from "./chunk-GYQFTF2E.js";
+} from "./chunk-6UYJV2EJ.js";
+import {
+  DocsService
+} from "./chunk-JBAQEIOH.js";
+import "./chunk-5IQX2W52.js";
+import "./chunk-KC5KFB5R.js";
 import {
   DocError,
   parseAuthor
-} from "./chunk-YBBQNCMC.js";
+} from "./chunk-GQ5E6T7Z.js";
+import "./chunk-DWVJIKVT.js";
 
 // src/cli.ts
 import { readFileSync, writeFileSync } from "fs";
@@ -118,7 +121,7 @@ async function main(argv, env = process.env) {
     author = named && scopes?.length ? { ...named, scopes } : named;
   }
   if (name === "mcp") {
-    const { startMcp } = await import("./mcp-P2C75IIG.js");
+    const { startMcp } = await import("./mcp-ZTUTC4CS.js");
     await startMcp(service, author);
     return 0;
   }
@@ -138,7 +141,8 @@ async function main(argv, env = process.env) {
     }
     const result = await command.run(service, input, author);
     if (name === "export") {
-      const { data, encoding } = result;
+      const { data, encoding, warnings } = result;
+      for (const line of warnings) console.error(`warning: ${line}`);
       const bytes = encoding === "base64" ? Buffer.from(data, "base64") : data;
       if (out === void 0) process.stdout.write(bytes);
       else writeFileSync(out, bytes);

package/dist/client.d.ts

@@ -1,7 +1,10 @@
-import { P as PrincipalKind, S as Section, E as EditEntry } from './doc-C_8kCsl7.js';
-export { A as Anchor } from './doc-C_8kCsl7.js';
-import { D as DocErrorCode, S as Suggestion, T as Thread, E as ExportFormat } from './review-BQW2Ci2h.js';
+import { e as PrincipalKind, S as Section, E as EditEntry } from './doc-BXG9qG5X.js';
+export { a as Anchor } from './doc-BXG9qG5X.js';
+import { E as ExportFormat } from './render-463xHb-x.js';
+import { a as DocErrorCode, S as Suggestion, T as Thread } from './review-Ds-i5Vnc.js';
+import { d as DocSummary } from './service-Ck6oX-Kq.js';
 import 'yjs';
+import 'agentic-identity';
 
 /** The place an edit goes: a section id, or exact text. */
 type Where = {
@@ -69,6 +72,18 @@ declare function createClient(options: ClientOptions): {
     }, call?: CallOptions) => Promise<{
         id: string;
     }>;
+    /** `GET /api/v1/docs`: documents with titles, creators, and last edits. */
+    list: (call?: CallOptions) => Promise<DocSummary[]>;
+    /** `POST /rename`: give a document a title. */
+    rename: (id: string, input: {
+        title: string;
+    }, call?: CallOptions) => Promise<{
+        ok: true;
+    }>;
+    /** `POST /remove`: delete a document. An agent needs the `docs:remove` scope. */
+    remove: (id: string, call?: CallOptions) => Promise<{
+        ok: true;
+    }>;
     /** `GET /read`: the whole document, or one section, as Markdown. */
     read(id: string, input?: {
         section?: string;
@@ -161,11 +176,13 @@ declare function createClient(options: ClientOptions): {
     }>;
     /** `GET /state`: the stored document as a Yjs update. */
     state(id: string, call?: CallOptions): Promise<Uint8Array>;
-    /** `POST /checkpoint`: merge a Yjs update into the stored document. */
-    checkpoint(id: string, update: Uint8Array, call?: CallOptions): Promise<{
+    /** `POST /checkpoint`: merge a Yjs update into the stored document. It makes the document when there is none, unless `create` is false: then it fails with `NO_DOCUMENT`. */
+    checkpoint(id: string, update: Uint8Array, call?: CallOptions & {
+        create?: boolean;
+    }): Promise<{
         ok: true;
     }>;
 };
 type DocsClient = ReturnType<typeof createClient>;
 
-export { type CallOptions, type ClientOptions, type Contributor, DocsApiError, type DocsApiErrorCode, type DocsClient, EditEntry, ExportFormat, type Me, Section, Suggestion, Thread, type Where, createClient };
+export { type CallOptions, type ClientOptions, type Contributor, DocSummary, DocsApiError, type DocsApiErrorCode, type DocsClient, EditEntry, ExportFormat, type Me, Section, Suggestion, Thread, type Where, createClient };

package/dist/client.js

@@ -72,6 +72,12 @@ function createClient(options) {
     me: (call) => get("/api/v1/me", {}, (v) => isObject(v) && typeof v.kind === "string" && typeof v.name === "string" && Array.isArray(v.scopes) && (v.role === "editor" || v.role === "viewer"), "the token identity", call),
     /** `POST /api/v1/docs`. */
     create: (input, call) => withKey("/api/v1/docs", input, "id", call),
+    /** `GET /api/v1/docs`: documents with titles, creators, and last edits. */
+    list: (call) => list("/api/v1/docs", {}, call),
+    /** `POST /rename`: give a document a title. */
+    rename: (id, input, call) => ok(`${doc(id)}/rename`, input, call),
+    /** `POST /remove`: delete a document. An agent needs the `docs:remove` scope. */
+    remove: (id, call) => ok(`${doc(id)}/remove`, {}, call),
     /** `GET /read`: the whole document, or one section, as Markdown. */
     async read(id, input = {}, call) {
       return (await send(`${doc(id)}/read`, { method: "GET", query: input }, call, "text/markdown")).text();
@@ -102,9 +108,10 @@ function createClient(options) {
     async state(id, call) {
       return new Uint8Array(await (await send(`${doc(id)}/state`, { method: "GET" }, call, "application/octet-stream")).arrayBuffer());
     },
-    /** `POST /checkpoint`: merge a Yjs update into the stored document. */
+    /** `POST /checkpoint`: merge a Yjs update into the stored document. It makes the document when there is none, unless `create` is false: then it fails with `NO_DOCUMENT`. */
     async checkpoint(id, update, call) {
-      return await json(await send(`${doc(id)}/checkpoint`, { method: "POST", body: update }, call), isOk, "{ ok: true }");
+      const query = call?.create === false ? { create: false } : void 0;
+      return await json(await send(`${doc(id)}/checkpoint`, { method: "POST", body: update, query }, call), isOk, "{ ok: true }");
     }
   };
 }

package/dist/{doc-C_8kCsl7.d.ts → doc-BXG9qG5X.d.ts}

@@ -18,6 +18,7 @@ declare function blocksToMarkdown(nodes: PmNode[]): string;
 
 declare const PRINCIPAL_KINDS: readonly ["human", "agent_of_human", "agent_of_agent", "agent", "user_token"];
 type PrincipalKind = (typeof PRINCIPAL_KINDS)[number];
+
 /** Who made a change. Every mutation needs one, so machine-made work stays labeled. */
 interface Principal {
     kind: PrincipalKind;
@@ -51,13 +52,16 @@ interface Section {
     title: string;
 }
 interface EditEntry {
-    op: "create" | "append" | "insert" | "replace" | "delete";
+    /** `live` ties the editor client of an agent to that agent, so the text the client types is marked as its work. Its counts stay 0. */
+    op: "create" | "append" | "insert" | "replace" | "delete" | "live";
     at: string;
     author: Principal;
     /** Counts of characters (text targets) or blocks (section targets). Never content. */
     inserted: number;
     deleted: number;
     section?: string;
+    /** The Yjs client id of the replica that made the edit. Text it wrote carries this id, so a UI can mark text by author kind. Written by the client, like the rest of the log. */
+    client?: number;
     /** Set when an accepted suggestion caused the edit. `author` is who suggested it. */
     suggestion?: {
         id: string;
@@ -87,6 +91,8 @@ declare class AgenticDoc {
     readonly now: () => Date;
     constructor(ydoc?: Y.Doc, options?: DocOptions);
     static fromMarkdown(markdown: string, author: Principal, options?: DocOptions): AgenticDoc;
+    /** Make a document from blocks in ProseMirror JSON form. Blocks that the schema does not allow fail with INVALID_INPUT. */
+    static fromBlocks(content: PmNode[], author: Principal, options?: DocOptions): AgenticDoc;
     static fromUpdate(update: Uint8Array, options?: DocOptions): AgenticDoc;
     encode(): Uint8Array;
     applyUpdate(update: Uint8Array): void;
@@ -123,4 +129,4 @@ declare class AgenticDoc {
     append(markdown: string, author: Principal): void;
 }
 
-export { type Anchor as A, type DocOptions as D, type EditEntry as E, type PrincipalKind as P, type Section as S, type Target as T, type Principal as a, type PmNode as b, AgenticDoc as c, type AnchorTarget as d, PRINCIPAL_KINDS as e, type SectionTarget as f, type TextTarget as g, blocksToMarkdown as h, markdownToBlocks as m, parseAuthor as p };
+export { AgenticDoc as A, type DocOptions as D, type EditEntry as E, type Principal as P, type Section as S, type Target as T, type Anchor as a, type AnchorTarget as b, PRINCIPAL_KINDS as c, type PmNode as d, type PrincipalKind as e, type SectionTarget as f, type TextTarget as g, blocksToMarkdown as h, markdownToBlocks as m, parseAuthor as p };