agentic-documents 0.4.0 → 0.5.0

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

@@ -1,10 +1,13 @@
+import {
+  Suggestions,
+  Threads,
+  isPerson
+} from "./chunk-UPEGODUV.js";
 import {
   AgenticDoc,
   DocError,
-  PRINCIPAL_KINDS,
-  Suggestions,
-  Threads
-} from "./chunk-YBBQNCMC.js";
+  PRINCIPAL_KINDS
+} from "./chunk-6QOYS63L.js";
 
 // src/service.ts
 import * as Y from "yjs";
@@ -16,7 +19,10 @@ var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 var isString = (v) => typeof v === "string";
 var isWho = (v) => isObject(v) && PRINCIPAL_KINDS.includes(v.kind) && isString(v.name) && v.name !== "";
 var isAnchor = (v) => isObject(v) && isString(v.text) && isObject(v.start) && isObject(v.end);
-var ROOTS = /* @__PURE__ */ new Set(["default", "edits", "suggestions", "threads", "applied"]);
+var ROOTS = /* @__PURE__ */ new Set(["default", "edits", "suggestions", "threads", "applied", "__tiptap_position_migrations:root:default"]);
+var MAX_TITLE = 120;
+var REMOVE_SCOPE = "docs:remove";
+var MAX_LISTED = 500;
 var DocsService = class {
   constructor(ports, options = {}) {
     this.options = options;
@@ -47,7 +53,7 @@ var DocsService = class {
    * 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.
    */
-  async checkpoint(id, update, author) {
+  async checkpoint(id, update, author, options = {}) {
     const key = this.key(id);
     const scratch = new Y.Doc();
     try {
@@ -62,6 +68,7 @@ var DocsService = class {
     for (let attempt = 0; attempt < ATTEMPTS; attempt++) {
       const found = await this.blobs.get(key);
       if (!found) {
+        if (options.create === false) throw new DocError("NO_DOCUMENT", `no document with id "${id}"`);
         const created = AgenticDoc.fromUpdate(update, this.options);
         const fresh = this.checked(id, created);
         this.fits(id, fresh);
@@ -73,7 +80,10 @@ var DocsService = class {
       doc.applyUpdate(update);
       const merged = this.checked(id, doc);
       this.fits(id, merged);
-      if (await this.blobs.put(key, merged, { ifMatch: found.version })) return;
+      if (await this.blobs.put(key, merged, { ifMatch: found.version })) {
+        await this.touch(id, author);
+        return;
+      }
     }
     throw new DocError("CONFLICT", `document "${id}" kept changing; try again`);
   }
@@ -86,7 +96,7 @@ var DocsService = class {
     const refuse = (what) => new DocError("INVALID_INPUT", `the update would leave document "${id}" unreadable: ${what}`);
     try {
       doc.toMarkdown();
-      if (!doc.edits().every((e) => isObject(e) && isWho(e.author) && isString(e.at) && isString(e.op))) throw refuse("an edit log entry is malformed");
+      if (!doc.edits().every((e) => isObject(e) && isWho(e.author) && isString(e.at) && isString(e.op) && (e.client === void 0 || Number.isSafeInteger(e.client) && e.client >= 0))) throw refuse("an edit log entry is malformed");
       for (const [, t] of doc.ydoc.getMap("threads")) {
         const messages = t instanceof Y.Map ? t.get("messages") : void 0;
         const ok = t instanceof Y.Map && isAnchor(t.get("anchor")) && ["open", "resolved"].includes(t.get("status")) && messages instanceof Y.Array && messages.length > 0 && messages.toArray().every((m) => isObject(m) && isString(m.id) && isString(m.at) && isString(m.body) && isWho(m.author));
@@ -108,9 +118,71 @@ var DocsService = class {
   }
   async catalog(id, author) {
     await this.store.transaction(async (tx) => {
-      if (await tx.get(CATALOG, id) === null) await tx.put(CATALOG, id, { createdBy: { kind: author.kind, name: author.name }, createdAt: Date.now() });
+      if (await tx.get(CATALOG, id) === null) {
+        const now = Date.now();
+        const who = { kind: author.kind, name: author.name };
+        await tx.put(CATALOG, id, { createdBy: who, createdAt: now, updatedAt: now, updatedBy: who });
+      }
     });
   }
+  /**
+   * 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.
+   */
+  async touch(id, author) {
+    if (!author) return;
+    try {
+      await this.store.transaction(async (tx) => {
+        const entry = await tx.get(CATALOG, id);
+        if (entry !== null) await tx.put(CATALOG, id, { ...entry, updatedAt: Date.now(), updatedBy: { kind: author.kind, name: author.name } });
+      });
+    } catch {
+    }
+  }
+  /** Every cataloged document, newest first, up to ${MAX_LISTED}. A damaged entry is skipped, so one bad entry never hides the list. */
+  async list() {
+    const found = [];
+    let cursor;
+    do {
+      const page = await this.store.query(CATALOG, { orderBy: { field: "createdAt", direction: "desc" }, limit: 100, cursor });
+      for (const { id, data } of page.items) {
+        const entry = isObject(data) ? data : {};
+        const { createdBy, createdAt } = entry;
+        if (!isWho(createdBy) || typeof createdAt !== "number") continue;
+        const by = entry.updatedBy;
+        if (by !== void 0 && !isWho(by)) continue;
+        found.push({ id, title: typeof entry.title === "string" && entry.title !== "" ? entry.title : id, createdBy, createdAt, updatedAt: typeof entry.updatedAt === "number" ? entry.updatedAt : createdAt, updatedBy: by ?? createdBy });
+      }
+      cursor = page.nextCursor;
+    } while (cursor !== void 0 && found.length < MAX_LISTED);
+    return found.slice(0, MAX_LISTED);
+  }
+  /** Give the document a name. It does not change the text. */
+  async rename(id, title, author) {
+    const key = this.key(id);
+    const clean = title.trim();
+    if (clean === "" || [...clean].length > MAX_TITLE || /[\u0000-\u001f\u007f-\u009f\u00ad\u200b-\u200f\u2028-\u202e\u2066-\u2069\ufeff]/.test(clean)) {
+      throw new DocError("INVALID_INPUT", `a title is 1 to ${MAX_TITLE} characters of plain text`);
+    }
+    const found = await this.blobs.get(key);
+    if (!found) throw new DocError("NO_DOCUMENT", `no document with id "${id}"`);
+    const who = { kind: author.kind, name: author.name };
+    const first = AgenticDoc.fromUpdate(found.data, this.options).edits()[0];
+    const created = first ? { createdBy: { kind: first.author.kind, name: first.author.name }, createdAt: Date.parse(first.at) } : { createdBy: who, createdAt: Date.now() };
+    await this.store.transaction(async (tx) => {
+      const entry = await tx.get(CATALOG, id);
+      const now = Date.now();
+      await tx.put(CATALOG, id, entry === null ? { ...created, createdAt: Number.isFinite(created.createdAt) ? created.createdAt : now, title: clean, updatedAt: now, updatedBy: who } : { ...entry, title: clean, updatedAt: now, updatedBy: who });
+    });
+  }
+  /** Delete the document and its catalog entry. An agent needs the remove scope. A live room keeps its own copy of the text. */
+  async remove(id, author) {
+    const key = this.key(id);
+    if (!isPerson(author) && author.scopes?.includes(REMOVE_SCOPE) !== true) throw new DocError("FORBIDDEN", `an agent needs the ${REMOVE_SCOPE} scope to remove a document`);
+    if (!await this.blobs.head(key)) throw new DocError("NO_DOCUMENT", `no document with id "${id}"`);
+    await this.store.delete(CATALOG, id);
+    await this.blobs.delete(key);
+  }
   /** Who created the document and when, or null when it has no catalog entry (made before the catalog, or a failed catalog write). */
   async info(id) {
     this.key(id);
@@ -131,14 +203,17 @@ var DocsService = class {
    * 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.
    */
-  async write(id, run) {
+  async write(id, run, author) {
     const key = this.key(id);
     for (let attempt = 0; attempt < ATTEMPTS; attempt++) {
       const found = await this.blobs.get(key);
       if (!found) throw new DocError("NO_DOCUMENT", `no document with id "${id}"`);
       const doc = AgenticDoc.fromUpdate(found.data, this.options);
       const result = run(doc);
-      if (await this.blobs.put(key, doc.encode(), { ifMatch: found.version })) return result;
+      if (await this.blobs.put(key, doc.encode(), { ifMatch: found.version })) {
+        await this.touch(id, author);
+        return result;
+      }
     }
     throw new DocError("CONFLICT", `document "${id}" kept changing; try again`);
   }

package/dist/cli.js

@@ -2,24 +2,26 @@
 import {
   createFileBlobs,
   createFileStore
-} from "./chunk-TFCRPEEM.js";
+} from "./chunk-7R7ZPPRF.js";
 import {
   LiveService,
   whoAmI
-} from "./chunk-R5XUTBC3.js";
+} from "./chunk-E7B6T5WN.js";
 import {
   DocsService
-} from "./chunk-FZA5LQV3.js";
+} from "./chunk-YNHZCIGO.js";
 import {
   VERSION
 } from "./chunk-5Y66UCTE.js";
 import {
   commands
-} from "./chunk-GYQFTF2E.js";
+} from "./chunk-S6MQDWFK.js";
+import "./chunk-L6W2AQUF.js";
+import "./chunk-UPEGODUV.js";
 import {
   DocError,
   parseAuthor
-} from "./chunk-YBBQNCMC.js";
+} from "./chunk-6QOYS63L.js";
 
 // src/cli.ts
 import { readFileSync, writeFileSync } from "fs";
@@ -118,7 +120,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-ESSEG46C.js");
     await startMcp(service, author);
     return 0;
   }

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 { P as PrincipalKind, S as Section, E as EditEntry } from './doc-mJPajXEQ.js';
+export { A as Anchor } from './doc-mJPajXEQ.js';
+import { E as ExportFormat } from './export-Cwx276UP.js';
+import { D as DocErrorCode, S as Suggestion, T as Thread } from './review-Hgq8OgvD.js';
+import { D as DocSummary } from './service-CqKE9DKz.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-mJPajXEQ.d.ts}

@@ -58,6 +58,8 @@ interface EditEntry {
     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 +89,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 +127,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 { type Anchor as A, type DocOptions as D, type EditEntry as E, type PrincipalKind as P, type Section as S, type Target as T, AgenticDoc as a, type PmNode as b, type Principal 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 };

package/dist/export-Cwx276UP.d.ts

@@ -0,0 +1,17 @@
+import { a as AgenticDoc } from './doc-mJPajXEQ.js';
+
+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;
+
+export { type ExportFormat as E, type ExportOptions as a, EXPORT_FORMATS as b, type ExportResult as c, exportDoc as e };

package/dist/formats.d.ts

@@ -0,0 +1,49 @@
+import { Limits, TextDoc } from 'agentic-formats';
+import { D as DocOptions, a as AgenticDoc, b as PmNode, c as Principal } from './doc-mJPajXEQ.js';
+import { a as ExportOptions } from './export-Cwx276UP.js';
+import 'yjs';
+
+declare const IMPORT_FORMATS: readonly ["md", "odt", "docx"];
+type ImportFormat = (typeof IMPORT_FORMATS)[number];
+declare const FILE_FORMATS: readonly ["md", "html", "odt", "docx"];
+type FileFormat = (typeof FILE_FORMATS)[number];
+declare const DOCX_MIME = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+interface ImportOptions {
+    /** Caps for the file. A file that goes past one is refused, never trimmed. The defaults are those of agentic-formats. */
+    limits?: Partial<Limits>;
+    doc?: DocOptions;
+}
+interface ImportResult {
+    doc: AgenticDoc;
+    /** The title the file holds, if any. */
+    title?: string;
+    /** One line for each part of the file that the document cannot hold. Empty when nothing was lost. */
+    warnings: string[];
+}
+interface FileResult {
+    format: FileFormat;
+    contentType: string;
+    /** Text for `md` and `html`. File bytes for `odt` and `docx`. */
+    data: string | Uint8Array;
+    /** One line for each part of the document that the format cannot hold. Empty when nothing was lost. */
+    warnings: string[];
+}
+/** Map document blocks to the neutral text model. A part the model cannot hold keeps its text and adds a warning. */
+declare function toTextDoc(blocks: PmNode[], title?: string): {
+    model: TextDoc;
+    warnings: string[];
+};
+/** Map the neutral text model to document blocks. A part the editor cannot hold keeps its text and adds a warning. */
+declare function fromTextDoc(model: TextDoc): {
+    blocks: PmNode[];
+    title?: string;
+    warnings: string[];
+};
+/** Read a file into a new document. The author makes the one `create` edit, so text from an agent stays labeled. */
+declare function importFile(input: string | Uint8Array, format: ImportFormat, author: Principal, options?: ImportOptions): ImportResult;
+/** Write a document as a file. `title` goes into the ODT and DOCX metadata. */
+declare function exportFile(doc: AgenticDoc, format: FileFormat, options?: ExportOptions & {
+    title?: string;
+}): FileResult;
+
+export { DOCX_MIME, FILE_FORMATS, type FileFormat, type FileResult, IMPORT_FORMATS, type ImportFormat, type ImportOptions, type ImportResult, exportFile, fromTextDoc, importFile, toTextDoc };

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,10 +1,11 @@
-import { a as Principal, b as PmNode } from './doc-C_8kCsl7.js';
-export { c 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-C_8kCsl7.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, b as EXPORT_FORMATS, E as ExportFormat, c as ExportOptions, d as ExportResult, M as Message, S as Suggestion, e as Suggestions, T as Thread, f as Threads, g as exportDoc } from './review-BQW2Ci2h.js';
+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 { D as DocAccess } from './service-Do2Jwb5U.js';
-export { a as DocInfo, b as DocsPorts, c as DocsService } from './service-Do2Jwb5U.js';
+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';
 

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,