agentic-documents 0.3.0 → 0.5.0

package/dist/formats.js

@@ -0,0 +1,234 @@
+import {
+  DATA_IMAGE,
+  exportDoc,
+  fromBase64,
+  safeHref,
+  toBase64
+} from "./chunk-L6W2AQUF.js";
+import {
+  AgenticDoc,
+  DocError,
+  checkAuthor
+} from "./chunk-6QOYS63L.js";
+
+// src/formats.ts
+import { DEFAULT_LIMITS, FormatError, readDocx, readOdt, writeDocx, writeOdt } from "agentic-formats";
+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 = (block) => {
+    switch (block.type) {
+      case "heading":
+        return [{ type: "heading", attrs: { level: block.level }, content: inlines(block.content) }];
+      case "paragraph":
+        return [paragraph(block.content)];
+      case "list":
+        return [
+          {
+            type: block.ordered ? "orderedList" : "bulletList",
+            ...block.ordered ? { attrs: { start: 1, type: null } } : {},
+            content: block.items.map((item) => ({ type: "listItem", content: [paragraph(item.content), ...item.sublist ? toNodes(item.sublist) : []] }))
+          }
+        ];
+      case "table": {
+        const rows = block.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: block.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]
+  };
+}
+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: exportDoc(doc, format, options).data, 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 {
+  DOCX_MIME,
+  FILE_FORMATS,
+  IMPORT_FORMATS,
+  exportFile,
+  fromTextDoc,
+  importFile,
+  toTextDoc
+};

package/dist/index.d.ts

@@ -1,94 +1,16 @@
-import { P as Principal, A as Anchor, a as AgenticDoc, T as TextTarget, b as AnchorTarget, D as DocAccess, c as PmNode } from './service-BKkxEnaJ.js';
-export { d as DocInfo, e as DocOptions, f as DocsPorts, g as DocsService, E as EditEntry, h as PRINCIPAL_KINDS, i as PrincipalKind, S as Section, j as SectionTarget, k as Target, l as blocksToMarkdown, m as markdownToBlocks, p as parseAuthor } from './service-BKkxEnaJ.js';
+import { c as Principal, b as PmNode } from './doc-mJPajXEQ.js';
+export { a as AgenticDoc, A as Anchor, d as AnchorTarget, D as DocOptions, E as EditEntry, e as PRINCIPAL_KINDS, P as PrincipalKind, S as Section, f as SectionTarget, T as Target, g as TextTarget, h as blocksToMarkdown, m as markdownToBlocks, p as parseAuthor } from './doc-mJPajXEQ.js';
 import { Schema } from 'prosemirror-model';
+export { a as DocError, D as DocErrorCode, M as Message, S as Suggestion, b as Suggestions, T as Thread, c as Threads } from './review-Hgq8OgvD.js';
 import { z } from 'zod';
+import { a as DocAccess } from './service-CqKE9DKz.js';
+export { b as DocInfo, c as DocsPorts, d as DocsService } from './service-CqKE9DKz.js';
+export { b as EXPORT_FORMATS, E as ExportFormat, a as ExportOptions, c as ExportResult, e as exportDoc } from './export-Cwx276UP.js';
 import { AdapterOptions, Blobs, Store } from 'agentic-identity';
 import 'yjs';
 
-type DocErrorCode = "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";
-declare class DocError extends Error {
-    readonly code: DocErrorCode;
-    readonly matches: {
-        occurrence: number;
-        context: string;
-    }[];
-    constructor(code: DocErrorCode, message: string, matches?: {
-        occurrence: number;
-        context: string;
-    }[]);
-}
-
 declare const schema: Schema<string, string>;
 
-interface Message {
-    id: string;
-    at: string;
-    author: Principal;
-    body: string;
-}
-interface Thread {
-    id: string;
-    anchor: Anchor;
-    status: "open" | "resolved";
-    resolvedBy?: Principal;
-    resolvedAt?: string;
-    messages: Message[];
-    /** The anchored text no longer matches what the comment was made on. */
-    stale: boolean;
-    /** The text now under the anchor, or null when it is gone. */
-    currentText: string | null;
-}
-interface Suggestion {
-    id: string;
-    kind: "insert" | "replace" | "delete";
-    at?: "before" | "after";
-    anchor: Anchor;
-    replacement: string;
-    author: Principal;
-    createdAt: string;
-    status: "pending" | "accepted" | "rejected";
-    decidedBy?: Principal;
-    decidedAt?: string;
-    stale: boolean;
-}
-/** Comment threads anchored to text. Replies and status merge across replicas. */
-declare class Threads {
-    private readonly doc;
-    constructor(doc: AgenticDoc);
-    private get map();
-    private get;
-    private message;
-    add(target: TextTarget | AnchorTarget, body: string, author: Principal): string;
-    reply(id: string, body: string, author: Principal): void;
-    private setStatus;
-    resolve(id: string, author: Principal): void;
-    reopen(id: string, author: Principal): void;
-    list(filter?: {
-        status?: Thread["status"];
-    }): Thread[];
-}
-/** Suggested edits. Nothing changes in the text until a person, or an agent with the accept scope, accepts one. */
-declare class Suggestions {
-    private readonly doc;
-    constructor(doc: AgenticDoc);
-    private get map();
-    private get;
-    private read;
-    /** An `at` on the target means insert. An empty replacement means delete. */
-    add(target: TextTarget | AnchorTarget, replacement: string, author: Principal): string;
-    private decide;
-    /**
-     * Apply the edit as the accepting author. The check and the edit share one transaction. Accepting
-     * an accepted suggestion changes nothing. A stale anchor throws and the suggestion stays pending.
-     */
-    accept(id: string, author: Principal): void;
-    /** Same right as accept. A person can withdraw their own suggestion. An agent can never decide its own. */
-    reject(id: string, author: Principal): void;
-    list(filter?: {
-        status?: Suggestion["status"];
-    }): Suggestion[];
-}
-
 /** One table drives the CLI, the MCP server, and the HTTP API, so they stay the same. */
 interface Command {
     name: string;
@@ -99,20 +21,6 @@ interface Command {
 }
 declare const commands: Command[];
 
-declare const EXPORT_FORMATS: readonly ["md", "html", "odt"];
-type ExportFormat = (typeof EXPORT_FORMATS)[number];
-interface ExportOptions {
-    /** Keep `<img>` for web and relative sources. Opening the page then asks those hosts for the image. Off by default. */
-    remoteImages?: boolean;
-}
-interface ExportResult {
-    format: ExportFormat;
-    contentType: string;
-    encoding: "utf8" | "base64";
-    data: string;
-}
-declare function exportDoc(doc: AgenticDoc, format: ExportFormat, options?: ExportOptions): ExportResult;
-
 interface FileBlobsOptions extends AdapterOptions {
     /** A lock older than this is taken over. Default 10 seconds. A save takes milliseconds. */
     lockStaleMs?: number;
@@ -142,4 +50,4 @@ declare const ODT_MIME = "application/vnd.oasis.opendocument.text";
 /** Write blocks as an OpenDocument text file (.odt): content, styles, and images as embedded files. */
 declare function exportOdt(blocks: PmNode[]): Uint8Array;
 
-export { AgenticDoc, Anchor, AnchorTarget, type Command, DocError, type DocErrorCode, EXPORT_FORMATS, type ExportFormat, type ExportOptions, type ExportResult, type FileBlobsOptions, type Message, ODT_MIME, PmNode, Principal, type Suggestion, Suggestions, TextTarget, type Thread, Threads, commands, createFileBlobs, createFileStore, exportDoc, exportOdt, schema };
+export { type Command, type FileBlobsOptions, ODT_MIME, PmNode, Principal, commands, createFileBlobs, createFileStore, exportOdt, schema };

package/dist/index.js

@@ -1,28 +1,32 @@
 import {
   createFileBlobs,
   createFileStore
-} from "./chunk-TFCRPEEM.js";
+} from "./chunk-7R7ZPPRF.js";
 import {
   DocsService
-} from "./chunk-FZA5LQV3.js";
+} from "./chunk-YNHZCIGO.js";
+import {
+  commands
+} from "./chunk-S6MQDWFK.js";
 import {
   EXPORT_FORMATS,
   ODT_MIME,
-  commands,
   exportDoc,
   exportOdt
-} from "./chunk-GYQFTF2E.js";
+} from "./chunk-L6W2AQUF.js";
+import {
+  Suggestions,
+  Threads
+} from "./chunk-UPEGODUV.js";
 import {
   AgenticDoc,
   DocError,
   PRINCIPAL_KINDS,
-  Suggestions,
-  Threads,
   blocksToMarkdown,
   markdownToBlocks,
   parseAuthor,
   schema
-} from "./chunk-YBBQNCMC.js";
+} from "./chunk-6QOYS63L.js";
 export {
   AgenticDoc,
   DocError,

package/dist/live-worker.d.ts

@@ -5,8 +5,9 @@ import 'hono';
 import 'agentic-identity';
 import 'agentic-identity/cloudflare';
 import 'agentic-realtime';
-import './service-BKkxEnaJ.js';
+import './doc-mJPajXEQ.js';
 import 'yjs';
+import './service-CqKE9DKz.js';
 
 type Namespace = Parameters<typeof createDurableObjectRealtime>[0];
 interface LiveEnv extends WorkerEnv {

package/dist/live-worker.js

@@ -2,12 +2,14 @@ import {
   createApp,
   regionOf,
   serviceFor
-} from "./chunk-IU3YIQ4Y.js";
-import "./chunk-FZA5LQV3.js";
-import "./chunk-GYQFTF2E.js";
+} from "./chunk-FX755I7V.js";
+import "./chunk-YNHZCIGO.js";
+import "./chunk-S6MQDWFK.js";
+import "./chunk-L6W2AQUF.js";
+import "./chunk-UPEGODUV.js";
 import {
   DocError
-} from "./chunk-YBBQNCMC.js";
+} from "./chunk-6QOYS63L.js";
 
 // src/live-worker.ts
 import { createDurableObjectRealtime } from "agentic-realtime/worker";

package/dist/live.d.ts

@@ -1,5 +1,6 @@
 import { Peer } from 'agentic-realtime/client';
-import { a as AgenticDoc, P as Principal, e as DocOptions, D as DocAccess } from './service-BKkxEnaJ.js';
+import { a as AgenticDoc, c as Principal, D as DocOptions } from './doc-mJPajXEQ.js';
+import { a as DocAccess, D as DocSummary } from './service-CqKE9DKz.js';
 import 'yjs';
 import 'agentic-identity';
 
@@ -63,8 +64,12 @@ declare class LiveService implements DocAccess {
     private readonly options;
     constructor(options: Pick<LiveOptions, "server" | "token" | "name" | "doc">);
     private join;
+    private call;
     /** The room is only a copy, so a new document is made in the store. A room seeds from it on the next join. */
     create(id: string, markdown: string): Promise<void>;
+    list(): Promise<DocSummary[]>;
+    rename(id: string, title: string): Promise<void>;
+    remove(id: string): Promise<void>;
     read<T>(id: string, run: (doc: AgenticDoc) => T): Promise<T>;
     write<T>(id: string, run: (doc: AgenticDoc) => T): Promise<T>;
     private exists;

package/dist/live.js

@@ -2,9 +2,10 @@ import {
   LiveDoc,
   LiveService,
   whoAmI
-} from "./chunk-R5XUTBC3.js";
-import "./chunk-FZA5LQV3.js";
-import "./chunk-YBBQNCMC.js";
+} from "./chunk-E7B6T5WN.js";
+import "./chunk-YNHZCIGO.js";
+import "./chunk-UPEGODUV.js";
+import "./chunk-6QOYS63L.js";
 export {
   LiveDoc,
   LiveService,

package/dist/{mcp-P2C75IIG.js → mcp-ESSEG46C.js}

@@ -3,10 +3,12 @@ import {
 } from "./chunk-5Y66UCTE.js";
 import {
   commands
-} from "./chunk-GYQFTF2E.js";
+} from "./chunk-S6MQDWFK.js";
+import "./chunk-L6W2AQUF.js";
+import "./chunk-UPEGODUV.js";
 import {
   DocError
-} from "./chunk-YBBQNCMC.js";
+} from "./chunk-6QOYS63L.js";
 
 // src/mcp.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";

package/dist/review-Hgq8OgvD.d.ts

@@ -0,0 +1,85 @@
+import { A as Anchor, c as Principal, a as AgenticDoc, g as TextTarget, d as AnchorTarget } from './doc-mJPajXEQ.js';
+
+type DocErrorCode = "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";
+declare class DocError extends Error {
+    readonly code: DocErrorCode;
+    readonly matches: {
+        occurrence: number;
+        context: string;
+    }[];
+    constructor(code: DocErrorCode, message: string, matches?: {
+        occurrence: number;
+        context: string;
+    }[]);
+}
+
+interface Message {
+    id: string;
+    at: string;
+    author: Principal;
+    body: string;
+}
+interface Thread {
+    id: string;
+    anchor: Anchor;
+    status: "open" | "resolved";
+    resolvedBy?: Principal;
+    resolvedAt?: string;
+    messages: Message[];
+    /** The anchored text no longer matches what the comment was made on. */
+    stale: boolean;
+    /** The text now under the anchor, or null when it is gone. */
+    currentText: string | null;
+}
+interface Suggestion {
+    id: string;
+    kind: "insert" | "replace" | "delete";
+    at?: "before" | "after";
+    anchor: Anchor;
+    replacement: string;
+    author: Principal;
+    createdAt: string;
+    status: "pending" | "accepted" | "rejected";
+    decidedBy?: Principal;
+    decidedAt?: string;
+    stale: boolean;
+}
+/** Comment threads anchored to text. Replies and status merge across replicas. */
+declare class Threads {
+    private readonly doc;
+    constructor(doc: AgenticDoc);
+    private get map();
+    private get;
+    private message;
+    add(target: TextTarget | AnchorTarget, body: string, author: Principal): string;
+    reply(id: string, body: string, author: Principal): void;
+    private setStatus;
+    resolve(id: string, author: Principal): void;
+    reopen(id: string, author: Principal): void;
+    list(filter?: {
+        status?: Thread["status"];
+    }): Thread[];
+}
+/** Suggested edits. Nothing changes in the text until a person, or an agent with the accept scope, accepts one. */
+declare class Suggestions {
+    private readonly doc;
+    constructor(doc: AgenticDoc);
+    private get map();
+    private get;
+    private read;
+    /** An `at` on the target means insert. An empty replacement means delete. */
+    add(target: TextTarget | AnchorTarget, replacement: string, author: Principal): string;
+    private decide;
+    /**
+     * Apply the edit as the accepting author. The check and the edit share one transaction. Accepting
+     * an accepted suggestion changes nothing. A stale anchor throws and the suggestion stays pending.
+     */
+    accept(id: string, author: Principal): void;
+    /** Same right as accept. A person can withdraw their own suggestion. An agent can never decide its own. */
+    reject(id: string, author: Principal): void;
+    list(filter?: {
+        status?: Suggestion["status"];
+    }): Suggestion[];
+}
+
+export { type DocErrorCode as D, type Message as M, type Suggestion as S, type Thread as T, DocError as a, Suggestions as b, Threads as c };

package/dist/service-CqKE9DKz.d.ts

@@ -0,0 +1,91 @@
+import { P as PrincipalKind, c as Principal, a as AgenticDoc, D as DocOptions } from './doc-mJPajXEQ.js';
+import { Blobs, Store } from 'agentic-identity';
+
+/** What the catalog keeps for each document. The author kind stays, so machine-made work stays labeled. */
+interface DocInfo {
+    createdBy: {
+        kind: PrincipalKind;
+        name: string;
+    };
+    createdAt: number;
+    /** The name a person gave the document. Without one, a list shows the id. */
+    title?: string;
+    /** The last save, and who made it. They start as the creation. */
+    updatedAt?: number;
+    updatedBy?: {
+        kind: PrincipalKind;
+        name: string;
+    };
+}
+/** One row of the document list. */
+interface DocSummary {
+    id: string;
+    title: string;
+    createdBy: DocInfo["createdBy"];
+    createdAt: number;
+    updatedAt: number;
+    updatedBy: DocInfo["createdBy"];
+}
+interface DocsPorts {
+    /** Holds each document as a Yjs update. Saves are conditional on the version that was read. */
+    blobs: Blobs;
+    /** Holds the catalog: who created each document, and when. */
+    store: Store;
+}
+/** What every command needs: make a document, read it, and change it. A live room can stand behind it as well as the ports. */
+interface DocAccess {
+    create(id: string, markdown: string, author: Principal): Promise<void>;
+    read<T>(id: string, run: (doc: AgenticDoc) => T): Promise<T>;
+    write<T>(id: string, run: (doc: AgenticDoc) => T, author?: Principal): Promise<T>;
+    list(): Promise<DocSummary[]>;
+    rename(id: string, title: string, author: Principal): Promise<void>;
+    remove(id: string, author: Principal): Promise<void>;
+}
+/** Loads and saves documents as Yjs updates in a Blobs port. The CLI, MCP server, and API share it. */
+declare class DocsService implements DocAccess {
+    private readonly options;
+    private readonly blobs;
+    private readonly store;
+    constructor(ports: DocsPorts, options?: DocOptions);
+    private key;
+    create(id: string, markdown: string, author: Principal): Promise<void>;
+    /** The stored document as a Yjs update. A live client seeds its room from it. */
+    state(id: string): Promise<Uint8Array>;
+    /**
+     * Merge a Yjs update from a live room into the stored document, and create the document when it
+     * has none. A merge is safe to repeat and to run in any order. The save is conditional, so two
+     * checkpoints at once both land.
+     */
+    checkpoint(id: string, update: Uint8Array, author: Principal, options?: {
+        create?: boolean;
+    }): Promise<void>;
+    /**
+     * The encoded document, once it reads back and every stored entry has the shape the commands rely on. Yjs does not
+     * check types, so an update can put text where the editor expects blocks, or a thread with no messages, and then a
+     * command fails on every later call.
+     */
+    private checked;
+    private fits;
+    private catalog;
+    /**
+     * Record a save. The catalog is a side record that follows the blob, so a failure here never fails a save that worked:
+     * the caller would repeat a change that is not safe to repeat. A document with no catalog entry stays without one.
+     */
+    private touch;
+    /** Every cataloged document, newest first, up to ${MAX_LISTED}. A damaged entry is skipped, so one bad entry never hides the list. */
+    list(): Promise<DocSummary[]>;
+    /** Give the document a name. It does not change the text. */
+    rename(id: string, title: string, author: Principal): Promise<void>;
+    /** Delete the document and its catalog entry. An agent needs the remove scope. A live room keeps its own copy of the text. */
+    remove(id: string, author: Principal): Promise<void>;
+    /** Who created the document and when, or null when it has no catalog entry (made before the catalog, or a failed catalog write). */
+    info(id: string): Promise<DocInfo | null>;
+    read<T>(id: string, run: (doc: AgenticDoc) => T): Promise<T>;
+    /**
+     * Load, run the change, and save only if nobody saved in between. When someone did, load again and
+     * run the change again, so a check such as "is it still pending" sees the new state.
+     */
+    write<T>(id: string, run: (doc: AgenticDoc) => T, author?: Principal): Promise<T>;
+}
+
+export { type DocSummary as D, type DocAccess as a, type DocInfo as b, type DocsPorts as c, DocsService as d };

package/dist/ui/_headers

@@ -0,0 +1,4 @@
+/*
+  Content-Security-Policy: default-src 'none'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self'; connect-src 'self'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'
+  X-Content-Type-Options: nosniff
+  Referrer-Policy: no-referrer