agentic-documents 0.0.0-stage → 0.1.0

package/dist/chunk-4YVWD5PH.js

@@ -0,0 +1,1123 @@
+// src/errors.ts
+var DocError = class extends Error {
+  constructor(code, message, matches = []) {
+    super(message);
+    this.code = code;
+    this.matches = matches;
+    this.name = "DocError";
+  }
+  code;
+  matches;
+};
+
+// src/markdown.ts
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { gfmFromMarkdown, gfmToMarkdown } from "mdast-util-gfm";
+import { toMarkdown } from "mdast-util-to-markdown";
+import { gfm } from "micromark-extension-gfm";
+var definitions = /* @__PURE__ */ new Map();
+function unsupported(what) {
+  throw new DocError("INVALID_INPUT", `Markdown ${what} is not supported and would be lost; remove it or write it inline`);
+}
+function collectDefinitions(nodes2, into) {
+  for (const node of nodes2) {
+    if (node.type === "definition") into.set(node.identifier, node);
+    const children = node.children;
+    if (children) collectDefinitions(children, into);
+  }
+}
+var withContent = (node, content2) => content2.length ? { ...node, content: content2 } : node;
+function inline(nodes2, marks2 = []) {
+  return nodes2.flatMap((node) => {
+    const text2 = (value, own) => value ? [{ type: "text", text: value, ...own.length ? { marks: own } : {} }] : [];
+    switch (node.type) {
+      case "text":
+        return text2(node.value, marks2);
+      case "html":
+        return text2(node.value, marks2);
+      case "inlineCode":
+        return text2(node.value, [{ type: "code" }]);
+      case "strong":
+        return inline(node.children, [...marks2, { type: "bold" }]);
+      case "emphasis":
+        return inline(node.children, [...marks2, { type: "italic" }]);
+      case "delete":
+        return inline(node.children, [...marks2, { type: "strike" }]);
+      case "link":
+        return inline(node.children, [...marks2, { type: "link", attrs: { href: node.url } }]);
+      case "image":
+        return [{ type: "image", attrs: { src: node.url, alt: node.alt ?? null, title: node.title ?? null } }];
+      case "break":
+        return [{ type: "hardBreak" }];
+      case "linkReference":
+        return inline(node.children, [...marks2, { type: "link", attrs: { href: definitions.get(node.identifier)?.url ?? unsupported("link reference without a definition") } }]);
+      case "imageReference": {
+        const url2 = definitions.get(node.identifier)?.url ?? unsupported("image reference without a definition");
+        return [{ type: "image", attrs: { src: url2, alt: node.alt ?? null, title: null } }];
+      }
+      default:
+        return unsupported(`"${node.type}"`);
+    }
+  });
+}
+function itemContent(children) {
+  const content2 = blocks(children);
+  return content2[0]?.type === "paragraph" ? content2 : [{ type: "paragraph" }, ...content2];
+}
+function cell(type, node) {
+  return { type, content: [withContent({ type: "paragraph" }, inline(node.children))] };
+}
+function blocks(nodes2) {
+  return nodes2.flatMap((node) => {
+    switch (node.type) {
+      case "heading":
+        return [withContent({ type: "heading", attrs: { level: node.depth } }, inline(node.children))];
+      case "paragraph":
+        return [withContent({ type: "paragraph" }, inline(node.children))];
+      case "html":
+        return [withContent({ type: "paragraph" }, inline([node]))];
+      case "blockquote":
+        return [{ type: "blockquote", content: blocks(node.children) }];
+      case "code":
+        return [withContent({ type: "codeBlock", attrs: { language: node.lang ?? null } }, node.value ? [{ type: "text", text: node.value }] : [])];
+      case "thematicBreak":
+        return [{ type: "horizontalRule" }];
+      case "list": {
+        const task = node.children.some((item) => item.checked != null);
+        const items = node.children.map(
+          (item) => ({
+            type: task ? "taskItem" : "listItem",
+            ...task ? { attrs: { checked: item.checked === true } } : {},
+            content: itemContent(item.children)
+          })
+        );
+        if (task) return [{ type: "taskList", content: items }];
+        return node.ordered ? [{ type: "orderedList", attrs: { start: node.start ?? 1 }, content: items }] : [{ type: "bulletList", content: items }];
+      }
+      case "table":
+        return [
+          {
+            type: "table",
+            content: node.children.map((row, i) => ({
+              type: "tableRow",
+              content: row.children.map((c) => cell(i === 0 ? "tableHeader" : "tableCell", c))
+            }))
+          }
+        ];
+      case "definition":
+        return [];
+      default:
+        return unsupported(`"${node.type}"`);
+    }
+  });
+}
+function markdownToBlocks(markdown) {
+  const tree = fromMarkdown(markdown, { extensions: [gfm()], mdastExtensions: [gfmFromMarkdown()] });
+  definitions = /* @__PURE__ */ new Map();
+  collectDefinitions(tree.children, definitions);
+  let out;
+  try {
+    out = blocks(tree.children);
+  } finally {
+    definitions = /* @__PURE__ */ new Map();
+  }
+  return out.length ? out : [{ type: "paragraph" }];
+}
+var MARK_ORDER = ["link", "bold", "italic", "strike", "code"];
+function leaf(node) {
+  if (node.type === "image") {
+    return { type: "image", url: String(node.attrs?.src ?? ""), alt: node.attrs?.alt ?? null, title: node.attrs?.title ?? null };
+  }
+  if (node.type === "hardBreak") return { type: "break" };
+  return { type: "text", value: node.text ?? "" };
+}
+function wrap(nodes2, depth) {
+  if (depth === MARK_ORDER.length) return nodes2.map(leaf);
+  const name = MARK_ORDER[depth];
+  const find = (node) => node.marks?.find((m) => m.type === name);
+  const out = [];
+  for (let i = 0; i < nodes2.length; ) {
+    const mark = find(nodes2[i]);
+    let j = i + 1;
+    while (j < nodes2.length && JSON.stringify(find(nodes2[j])?.attrs?.href) === JSON.stringify(mark?.attrs?.href) && !!find(nodes2[j]) === !!mark) j++;
+    const run = nodes2.slice(i, j);
+    i = j;
+    if (!mark) out.push(...wrap(run, depth + 1));
+    else if (name === "code") out.push({ type: "inlineCode", value: run.map((n) => n.text ?? "").join("") });
+    else {
+      const children = wrap(run, depth + 1);
+      if (name === "link") out.push({ type: "link", url: String(mark.attrs?.href ?? ""), children });
+      else out.push({ type: name === "bold" ? "strong" : name === "italic" ? "emphasis" : "delete", children });
+    }
+  }
+  return out;
+}
+function phrasing(node) {
+  const nodes2 = [...node.content ?? []];
+  const first = nodes2[0];
+  if (first?.type === "text") nodes2[0] = { ...first, text: first.text?.trimStart() };
+  const last = nodes2[nodes2.length - 1];
+  if (last?.type === "text") nodes2[nodes2.length - 1] = { ...last, text: last.text?.trimEnd() };
+  return wrap(nodes2.filter((n) => n.type !== "text" || n.text), 0);
+}
+function cellText(node) {
+  return (node.content ?? []).flatMap((p, i) => i ? [{ type: "break" }, ...phrasing(p)] : phrasing(p));
+}
+function blocksOut(nodes2) {
+  return nodes2.flatMap((node) => {
+    const children = node.content ?? [];
+    switch (node.type) {
+      case "paragraph":
+        return children.length ? [{ type: "paragraph", children: phrasing(node) }] : [];
+      case "heading":
+        return [{ type: "heading", depth: Math.min(6, Math.max(1, Number(node.attrs?.level ?? 1))), children: phrasing(node) }];
+      case "blockquote":
+        return [{ type: "blockquote", children: blocksOut(children) }];
+      case "codeBlock":
+        return [{ type: "code", lang: node.attrs?.language ?? null, value: children.map((c) => c.text ?? "").join("") }];
+      case "horizontalRule":
+        return [{ type: "thematicBreak" }];
+      case "bulletList":
+      case "orderedList":
+      case "taskList": {
+        const task = node.type === "taskList";
+        return [
+          {
+            type: "list",
+            ordered: node.type === "orderedList",
+            start: node.type === "orderedList" ? Number(node.attrs?.start ?? 1) : null,
+            spread: false,
+            children: children.map((item) => ({
+              type: "listItem",
+              spread: false,
+              ...task ? { checked: item.attrs?.checked === true } : {},
+              children: blocksOut(item.content ?? [])
+            }))
+          }
+        ];
+      }
+      case "table":
+        return [
+          {
+            type: "table",
+            children: children.map((row) => ({
+              type: "tableRow",
+              children: (row.content ?? []).map((c) => ({ type: "tableCell", children: cellText(c) }))
+            }))
+          }
+        ];
+      default:
+        return [];
+    }
+  });
+}
+function blocksToMarkdown(nodes2) {
+  const root = { type: "root", children: blocksOut(nodes2) };
+  return toMarkdown(root, { extensions: [gfmToMarkdown()], bullet: "-", rule: "-", fences: true, emphasis: "*", strong: "*" });
+}
+
+// src/schema.ts
+import { Schema } from "prosemirror-model";
+var cell2 = {
+  content: "block+",
+  attrs: { colspan: { default: 1 }, rowspan: { default: 1 }, colwidth: { default: null } }
+};
+var nodes = {
+  doc: { content: "block+" },
+  paragraph: { group: "block", content: "inline*" },
+  text: { group: "inline" },
+  heading: { group: "block", content: "inline*", attrs: { level: { default: 1 } } },
+  blockquote: { group: "block", content: "block+" },
+  codeBlock: { group: "block", content: "text*", marks: "", code: true, attrs: { language: { default: null } } },
+  horizontalRule: { group: "block" },
+  bulletList: { group: "block", content: "listItem+" },
+  orderedList: { group: "block", content: "listItem+", attrs: { start: { default: 1 }, type: { default: null } } },
+  listItem: { content: "paragraph block*" },
+  taskList: { group: "block", content: "taskItem+" },
+  taskItem: { content: "paragraph block*", attrs: { checked: { default: false } } },
+  hardBreak: { group: "inline", inline: true },
+  image: {
+    group: "inline",
+    inline: true,
+    attrs: { src: { default: null }, alt: { default: null }, title: { default: null } }
+  },
+  table: { group: "block", content: "tableRow+" },
+  tableRow: { content: "(tableCell | tableHeader)*" },
+  tableCell: cell2,
+  tableHeader: cell2
+};
+var marks = {
+  bold: {},
+  italic: {},
+  strike: {},
+  code: { excludes: "_" },
+  link: {
+    inclusive: false,
+    attrs: {
+      href: { default: null },
+      target: { default: "_blank" },
+      rel: { default: "noopener noreferrer nofollow" },
+      class: { default: null }
+    }
+  }
+};
+var schema = new Schema({ nodes, marks });
+
+// src/doc.ts
+import { prosemirrorJSONToYXmlFragment, yXmlFragmentToProsemirrorJSON } from "y-prosemirror";
+import * as Y2 from "yjs";
+
+// src/settle.ts
+import * as Y from "yjs";
+var APPLIED = "applied";
+var clientOf = (key) => Number(key.slice(key.lastIndexOf(":") + 1));
+function settle(ydoc) {
+  const applied = ydoc.getMap(APPLIED);
+  const groups = /* @__PURE__ */ new Map();
+  for (const [key, record] of applied) {
+    const id2 = key.slice(0, key.lastIndexOf(":"));
+    groups.set(id2, [...groups.get(id2) ?? [], [key, record]]);
+  }
+  if (groups.size === 0) return;
+  const suggestions = ydoc.getMap("suggestions");
+  const log = ydoc.getArray("edits");
+  ydoc.transact(() => {
+    for (const [id2, records] of groups) {
+      records.sort((a, b) => clientOf(a[0]) - clientOf(b[0]));
+      const [[, winner], ...losers] = records;
+      const fields = suggestions.get(id2);
+      const decided = (key) => JSON.stringify(fields?.get(key));
+      if (fields && (decided("status") !== '"accepted"' || decided("decidedBy") !== JSON.stringify(winner.by) || decided("decidedAt") !== JSON.stringify(winner.at))) {
+        fields.set("status", "accepted");
+        fields.set("decidedBy", winner.by);
+        fields.set("decidedAt", winner.at);
+      }
+      if (losers.length === 0) continue;
+      for (const [key, loser] of losers) {
+        applied.delete(key);
+        if (!loser.start || !loser.end) continue;
+        const from = Y.createAbsolutePositionFromRelativePosition(Y.createRelativePositionFromJSON(loser.start), ydoc);
+        const to = Y.createAbsolutePositionFromRelativePosition(Y.createRelativePositionFromJSON(loser.end), ydoc);
+        if (from && to && from.type === to.type && to.index > from.index && from.type instanceof Y.XmlText) {
+          from.type.delete(from.index, to.index - from.index);
+        }
+      }
+      const entries = log.toArray().flatMap((e, i) => e.suggestion?.id === id2 ? [{ e, i }] : []);
+      const keep = entries.find(({ e }) => e.at === winner.at && JSON.stringify(e.author) === JSON.stringify(winner.by)) ?? entries[0];
+      for (const { i } of entries.reverse()) if (i !== keep?.i) log.delete(i, 1);
+    }
+  });
+}
+
+// src/doc.ts
+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) {
+  const scopes = author?.scopes;
+  const ok2 = typeof author === "object" && author !== null && PRINCIPAL_KINDS.includes(author.kind) && typeof author.name === "string" && author.name.trim() !== "" && (scopes === void 0 || Array.isArray(scopes) && scopes.every((s) => typeof s === "string" && s !== ""));
+  if (!ok2) throw new DocError("INVALID_AUTHOR", `author needs a kind (${PRINCIPAL_KINDS.join(", ")}), a name, and scopes that are a list of text`);
+  return { kind: author.kind, name: author.name };
+}
+function parseAuthor(value) {
+  if (value === void 0) return void 0;
+  const cut = value.indexOf(":");
+  return { kind: cut < 0 ? value : value.slice(0, cut), name: cut < 0 ? "" : value.slice(cut + 1) };
+}
+var unitText = (unit) => unit.toDelta().map((d) => typeof d.insert === "string" ? d.insert : "").join("");
+function unitsOf(node) {
+  return node.toArray().flatMap((child) => child instanceof Y2.XmlText ? [child] : child instanceof Y2.XmlElement ? unitsOf(child) : []);
+}
+function attrsAt(unit, index) {
+  let pos = 0;
+  for (const op of unit.toDelta()) {
+    pos += typeof op.insert === "string" ? op.insert.length : 1;
+    if (index < pos) return { ...op.attributes };
+  }
+  return {};
+}
+function sectionId(el) {
+  const { client, clock } = el._item.id;
+  return `s${client.toString(36)}-${clock}`;
+}
+function toYBlocks(content2) {
+  const scratch = new Y2.Doc().getXmlFragment(FRAGMENT);
+  prosemirrorJSONToYXmlFragment(schema, { type: "doc", content: content2 }, scratch);
+  return scratch.toArray().map((el) => el.clone());
+}
+var AgenticDoc = class _AgenticDoc {
+  ydoc;
+  now;
+  constructor(ydoc = new Y2.Doc(), options = {}) {
+    this.ydoc = ydoc;
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    const watched = [ydoc.getMap(APPLIED), ydoc.getMap("suggestions")];
+    ydoc.on("afterTransaction", (tr) => {
+      if (!tr.local && watched.some((type) => tr.changedParentTypes.has(type))) settle(ydoc);
+    });
+  }
+  static fromMarkdown(markdown, author, options) {
+    const who = checkAuthor(author);
+    const doc = new _AgenticDoc(new Y2.Doc(), options);
+    const content2 = markdownToBlocks(markdown);
+    doc.change("create", who, () => {
+      doc.fragment.insert(0, toYBlocks(content2));
+      return { inserted: content2.length, deleted: 0 };
+    });
+    return doc;
+  }
+  static fromUpdate(update, options) {
+    const doc = new _AgenticDoc(new Y2.Doc(), options);
+    doc.applyUpdate(update);
+    return doc;
+  }
+  encode() {
+    return Y2.encodeStateAsUpdate(this.ydoc);
+  }
+  applyUpdate(update) {
+    Y2.applyUpdate(this.ydoc, update);
+  }
+  /** A new replica with its own client id, holding the same state. */
+  fork() {
+    return _AgenticDoc.fromUpdate(this.encode(), { now: this.now });
+  }
+  get fragment() {
+    return this.ydoc.getXmlFragment(FRAGMENT);
+  }
+  get log() {
+    return this.ydoc.getArray("edits");
+  }
+  edits() {
+    return this.log.toArray();
+  }
+  change(op, author, run, extra = {}) {
+    const at = this.now().toISOString();
+    this.ydoc.transact(() => {
+      const entry = { op, at, author, ...run(), ...extra };
+      if (entry.section === void 0) delete entry.section;
+      this.log.push([entry]);
+    });
+    return at;
+  }
+  toJSON() {
+    return yXmlFragmentToProsemirrorJSON(this.fragment);
+  }
+  toMarkdown() {
+    return blocksToMarkdown(this.toJSON().content ?? []);
+  }
+  /** Sections in order. Blocks before the first heading come first, as the `preamble` section at level 0. */
+  outline() {
+    const headings = this.headings();
+    const sections = headings.map(({ el }) => ({
+      id: sectionId(el),
+      level: Number(el.getAttribute("level") ?? 1),
+      title: unitsOf(el).map(unitText).join("")
+    }));
+    const before = headings.length ? headings[0].index : this.fragment.length;
+    return before > 0 ? [{ id: PREAMBLE, level: 0, title: "Preamble" }, ...sections] : sections;
+  }
+  readSection(id2) {
+    const { start, end } = this.range(id2);
+    return blocksToMarkdown((this.toJSON().content ?? []).slice(start, end));
+  }
+  headings() {
+    return this.fragment.toArray().flatMap((el, index) => el instanceof Y2.XmlElement && el.nodeName === "heading" ? [{ el, index }] : []);
+  }
+  /**
+   * A section runs from its heading to the next heading of the same or a higher level. The preamble
+   * has no heading and runs to the first heading. It is always a valid target, even when empty.
+   */
+  range(id2) {
+    const all = this.headings();
+    if (id2 === PREAMBLE) return { start: 0, end: all.length ? all[0].index : this.fragment.length, headed: false };
+    const at = all.findIndex(({ el }) => sectionId(el) === id2);
+    if (at < 0) throw new DocError("NO_SECTION", `no section with id "${id2}"`);
+    const level = Number(all[at].el.getAttribute("level") ?? 1);
+    const next = all.slice(at + 1).find(({ el }) => Number(el.getAttribute("level") ?? 1) <= level);
+    return { start: all[at].index, end: next ? next.index : this.fragment.length, headed: true };
+  }
+  find(text2) {
+    if (text2 === "") return [];
+    return unitsOf(this.fragment).flatMap((unit) => {
+      const found = [];
+      const value = unitText(unit);
+      for (let at = value.indexOf(text2); at >= 0; at = value.indexOf(text2, at + 1)) {
+        found.push({ unit, start: at, end: at + text2.length });
+      }
+      return found;
+    });
+  }
+  pick(text2, occurrence2) {
+    const found = this.find(text2);
+    if (found.length === 0) throw new DocError("NO_MATCH", `no text matches "${text2}"`);
+    if (occurrence2 !== void 0) {
+      if (found[occurrence2 - 1] === void 0) throw new DocError("NO_MATCH", `"${text2}" has ${found.length} matches, not ${occurrence2}`);
+      return found[occurrence2 - 1];
+    }
+    if (found.length > 1) {
+      const matches = found.map((m, i) => {
+        const value = unitText(m.unit);
+        return { occurrence: i + 1, context: value.slice(Math.max(0, m.start - CONTEXT_CHARS), m.end + CONTEXT_CHARS) };
+      });
+      throw new DocError("AMBIGUOUS_MATCH", `"${text2}" matches ${found.length} places; pass an occurrence`, matches);
+    }
+    return found[0];
+  }
+  /** Pin a text range so later edits by other replicas do not move it. */
+  anchor(text2, occurrence2) {
+    const { unit, start, end } = this.pick(text2, occurrence2);
+    return {
+      text: text2,
+      start: Y2.relativePositionToJSON(Y2.createRelativePositionFromTypeIndex(unit, start, 0)),
+      end: Y2.relativePositionToJSON(Y2.createRelativePositionFromTypeIndex(unit, end, -1))
+    };
+  }
+  resolve(target2) {
+    if (!isAnchor(target2)) return this.pick(target2.text, target2.occurrence);
+    const { anchor } = target2;
+    const start = Y2.createAbsolutePositionFromRelativePosition(Y2.createRelativePositionFromJSON(anchor.start), this.ydoc);
+    const end = Y2.createAbsolutePositionFromRelativePosition(Y2.createRelativePositionFromJSON(anchor.end), this.ydoc);
+    const unit = start?.type;
+    if (!(unit instanceof Y2.XmlText) || end?.type !== unit || unitText(unit).slice(start.index, end.index) !== anchor.text) {
+      throw new DocError("STALE_ANCHOR", `the anchored text "${anchor.text}" changed or was removed`);
+    }
+    return { unit, start: start.index, end: end.index };
+  }
+  edit(op, target2, content2, author, extra = {}) {
+    const who = checkAuthor(author);
+    const { unit, start, end } = this.resolve(target2);
+    let inserted;
+    const at = this.change(op, who, () => {
+      const marks2 = attrsAt(unit, op === "insert" && target2.at !== "before" ? end - 1 : start);
+      if (op === "insert") delete marks2.link;
+      const index = op === "insert" ? target2.at === "before" ? start : end : start;
+      if (op !== "insert") unit.delete(start, end - start);
+      if (op !== "delete") {
+        unit.insert(index, content2, marks2);
+        inserted = {
+          start: Y2.relativePositionToJSON(Y2.createRelativePositionFromTypeIndex(unit, index, 0)),
+          end: Y2.relativePositionToJSON(Y2.createRelativePositionFromTypeIndex(unit, index + content2.length, -1))
+        };
+      }
+      return { inserted: op === "delete" ? 0 : content2.length, deleted: op === "insert" ? 0 : end - start };
+    }, extra);
+    return { at, inserted };
+  }
+  editSection(op, target2, markdown, author) {
+    const who = checkAuthor(author);
+    const { start, end, headed } = this.range(target2.section);
+    const body = headed ? start + 1 : start;
+    const content2 = op === "delete" ? [] : markdownToBlocks(markdown);
+    this.change(op, who, () => {
+      const deleted = op === "insert" ? 0 : op === "delete" ? end - start : end - body;
+      const from = op === "delete" ? start : op === "replace" || target2.at === "start" ? body : end;
+      if (op === "replace") this.fragment.delete(body, end - body);
+      if (op === "delete") this.fragment.delete(start, end - start);
+      if (content2.length) this.fragment.insert(from, toYBlocks(content2));
+      return { inserted: content2.length, deleted, section: target2.section };
+    });
+  }
+  /** Insert Markdown into a section, or plain text next to matched text. */
+  insert(target2, content2, author) {
+    if (isSection(target2)) this.editSection("insert", target2, content2, author);
+    else this.edit("insert", target2, content2, author);
+  }
+  /** Replace a section body (the heading stays), or the matched text. */
+  replace(target2, content2, author) {
+    if (isSection(target2)) this.editSection("replace", target2, content2, author);
+    else this.edit("replace", target2, content2, author);
+  }
+  /** Delete a whole section with its subsections, or the matched text. */
+  delete(target2, author) {
+    if (isSection(target2)) this.editSection("delete", target2, "", author);
+    else this.edit("delete", target2, "", author);
+  }
+  append(markdown, author) {
+    const who = checkAuthor(author);
+    const content2 = markdownToBlocks(markdown);
+    this.change("append", who, () => {
+      this.fragment.insert(this.fragment.length, toYBlocks(content2));
+      return { inserted: content2.length, deleted: 0 };
+    });
+  }
+};
+
+// src/odt.ts
+import { strToU8, zipSync } from "fflate";
+
+// src/package.ts
+var IMAGE_TYPES = { png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", gif: "image/gif", webp: "image/webp" };
+var DATA_IMAGE = /^data:(image\/(?:png|jpeg|gif|webp));base64,([a-z0-9+/=]+)$/i;
+var FIXED_DATE = new Date(2e3, 0, 1);
+function toBase64(bytes) {
+  let text2 = "";
+  for (let i = 0; i < bytes.length; i += 32768) text2 += String.fromCharCode(...bytes.subarray(i, i + 32768));
+  return btoa(text2);
+}
+var fromBase64 = (value) => Uint8Array.from(atob(value), (c) => c.charCodeAt(0));
+function imageSize(b) {
+  const v = new DataView(b.buffer, b.byteOffset, b.byteLength);
+  if (b.length > 24 && v.getUint32(0) === 2303741511) return [v.getUint32(16), v.getUint32(20)];
+  if (b.length > 10 && v.getUint32(0) === 1195984440) return [v.getUint16(6, true), v.getUint16(8, true)];
+  if (b.length > 4 && v.getUint16(0) === 65496) {
+    for (let i = 2; i + 9 < b.length && b[i] === 255; i += 2 + v.getUint16(i + 2)) {
+      if (b[i + 1] >= 192 && b[i + 1] <= 207 && ![196, 200, 204].includes(b[i + 1])) return [v.getUint16(i + 7), v.getUint16(i + 5)];
+    }
+  }
+  return void 0;
+}
+
+// src/xml.ts
+var xmlEscape = (value) => String(value ?? "").replace(/[^\u0009\u000A\u000D -퟿-�\u{10000}-\u{10FFFF}]/gu, "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+var safeHref = (value) => {
+  const href = String(value ?? "").trim();
+  return /^(https?:|mailto:|#|[^:]*$)/i.test(href) ? href : void 0;
+};
+
+// src/odt.ts
+var ODT_MIME = "application/vnd.oasis.opendocument.text";
+var NS = 'xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0" xmlns:text="urn:oasis:names:tc:opendocument:xmlns:text:1.0" xmlns:table="urn:oasis:names:tc:opendocument:xmlns:table:1.0" xmlns:style="urn:oasis:names:tc:opendocument:xmlns:style:1.0" xmlns:fo="urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:draw="urn:oasis:names:tc:opendocument:xmlns:drawing:1.0" xmlns:svg="urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0" xmlns:meta="urn:oasis:names:tc:opendocument:xmlns:meta:1.0" xmlns:manifest="urn:oasis:names:tc:opendocument:xmlns:manifest:1.0" office:version="1.3"';
+var XML = '<?xml version="1.0" encoding="UTF-8"?>\n';
+var SPANS = { bold: "B", italic: "I", strike: "S", code: "Source_20_Text" };
+var TASK = ["\u2610 ", "\u2611 "];
+var LEVELS = (kind) => Array.from(
+  { length: 10 },
+  (_, i) => kind === "bullet" ? `<text:list-level-style-bullet text:level="${i + 1}" text:bullet-char="\u2022"><style:list-level-properties text:list-level-position-and-space-mode="label-alignment"><style:list-level-label-alignment text:label-followed-by="listtab" fo:margin-left="${(i + 1) * 0.63}cm" fo:text-indent="-0.63cm"/></style:list-level-properties></text:list-level-style-bullet>` : `<text:list-level-style-number text:level="${i + 1}" style:num-suffix="." style:num-format="1"><style:list-level-properties text:list-level-position-and-space-mode="label-alignment"><style:list-level-label-alignment text:label-followed-by="listtab" fo:margin-left="${(i + 1) * 0.63}cm" fo:text-indent="-0.63cm"/></style:list-level-properties></text:list-level-style-number>`
+).join("");
+var SIZES = [24, 18, 14, 12, 11, 10];
+var STYLES = `${XML}<office:document-styles ${NS}><office:styles>
+<style:style style:name="Standard" style:family="paragraph" style:class="text"/>
+${SIZES.map((s, i) => `<style:style style:name="Heading_20_${i + 1}" style:display-name="Heading ${i + 1}" style:family="paragraph" style:parent-style-name="Standard" style:class="text"><style:text-properties fo:font-size="${s}pt" fo:font-weight="bold"/></style:style>`).join("\n")}
+<style:style style:name="Quotations" style:family="paragraph" style:parent-style-name="Standard" style:class="html"><style:paragraph-properties fo:margin-left="1cm" fo:margin-right="1cm"/></style:style>
+<style:style style:name="Preformatted_20_Text" style:display-name="Preformatted Text" style:family="paragraph" style:parent-style-name="Standard" style:class="html"><style:text-properties fo:font-family="Liberation Mono, Courier New, monospace" fo:font-size="10pt"/></style:style>
+<style:style style:name="Horizontal_20_Line" style:display-name="Horizontal Line" style:family="paragraph" style:parent-style-name="Standard" style:class="html"><style:paragraph-properties fo:border-bottom="0.5pt solid #808080" fo:padding="0cm" fo:margin-bottom="0.3cm"/></style:style>
+<style:style style:name="Source_20_Text" style:display-name="Source Text" style:family="text"><style:text-properties fo:font-family="Liberation Mono, Courier New, monospace"/></style:style>
+</office:styles></office:document-styles>`;
+var AUTO = `<style:style style:name="B" style:family="text"><style:text-properties fo:font-weight="bold"/></style:style>
+<style:style style:name="I" style:family="text"><style:text-properties fo:font-style="italic"/></style:style>
+<style:style style:name="S" style:family="text"><style:text-properties style:text-line-through-style="solid"/></style:style>
+<text:list-style style:name="Bullets">${LEVELS("bullet")}</text:list-style>
+<text:list-style style:name="Numbering">${LEVELS("number")}</text:list-style>`;
+var spaced = (s) => xmlEscape(s).replace(/\t/g, "<text:tab/>").replace(/\n/g, "<text:line-break/>").replace(/ +/g, (run, at, all) => at === 0 || at + run.length === all.length ? `<text:s text:c="${run.length}"/>` : run.length > 1 ? ` <text:s text:c="${run.length - 1}"/>` : run);
+function image(node, out) {
+  const alt = String(node.attrs?.alt ?? "");
+  const found = DATA_IMAGE.exec(String(node.attrs?.src ?? "").trim());
+  let data;
+  try {
+    data = found ? fromBase64(found[2]) : void 0;
+  } catch {
+    data = void 0;
+  }
+  if (!found || !data) return spaced(`[image${alt ? `: ${alt}` : ""}]`);
+  const ext = Object.keys(IMAGE_TYPES).find((k) => IMAGE_TYPES[k] === found[1].toLowerCase());
+  const name = `Image${out.images.length + 1}`;
+  out.images.push({ name: `Pictures/${name}.${ext}`, type: found[1].toLowerCase(), data });
+  const [w, h] = imageSize(data) ?? [320, 240];
+  const scale = Math.min(1, 16 / (w * 2.54 / 96));
+  const cm = (px) => (px * 2.54 * scale / 96).toFixed(2);
+  return `<draw:frame draw:name="${name}" text:anchor-type="as-char" svg:width="${cm(w)}cm" svg:height="${cm(h)}cm"><draw:image xlink:href="Pictures/${name}.${ext}" xlink:type="simple" xlink:show="embed" xlink:actuate="onLoad"/><svg:title>${xmlEscape(alt)}</svg:title></draw:frame>`;
+}
+function inline2(nodes2, out) {
+  return nodes2.map((node) => {
+    if (node.type === "hardBreak") return "<text:line-break/>";
+    if (node.type === "image") return image(node, out);
+    return (node.marks ?? []).reduce((xml, mark) => {
+      if (mark.type === "link") {
+        const href = safeHref(mark.attrs?.href);
+        return href ? `<text:a xlink:type="simple" xlink:href="${xmlEscape(href)}">${xml}</text:a>` : xml;
+      }
+      return SPANS[mark.type] ? `<text:span text:style-name="${SPANS[mark.type]}">${xml}</text:span>` : xml;
+    }, spaced(node.text ?? ""));
+  }).join("");
+}
+function block(node, out, style = "Standard") {
+  const kids = node.content ?? [];
+  const p = (name, inner) => `<text:p text:style-name="${name}">${inner}</text:p>`;
+  switch (node.type) {
+    case "paragraph":
+      return p(style, inline2(kids, out));
+    case "heading": {
+      const level = Math.min(6, Math.max(1, Math.trunc(Number(node.attrs?.level)) || 1));
+      return `<text:h text:style-name="Heading_20_${level}" text:outline-level="${level}">${inline2(kids, out)}</text:h>`;
+    }
+    case "blockquote":
+      return kids.map((k) => block(k, out, "Quotations")).join("");
+    case "codeBlock":
+      return p("Preformatted_20_Text", spaced(kids.map((k) => k.text ?? "").join("")));
+    case "horizontalRule":
+      return `<text:p text:style-name="Horizontal_20_Line"/>`;
+    case "bulletList":
+    case "orderedList":
+    case "taskList": {
+      const ordered = node.type === "orderedList";
+      const start = Number(node.attrs?.start ?? 1);
+      const items = kids.map((item, i) => {
+        const [first, ...rest] = item.content ?? [];
+        const mark = item.type === "taskItem" && first ? { ...first, content: [{ type: "text", text: TASK[item.attrs?.checked ? 1 : 0] }, ...first.content ?? []] } : first;
+        const attr = ordered && i === 0 && start !== 1 ? ` text:start-value="${Math.trunc(start) || 1}"` : "";
+        return `<text:list-item${attr}>${[mark, ...rest].filter(Boolean).map((k) => block(k, out)).join("")}</text:list-item>`;
+      });
+      return `<text:list text:style-name="${ordered ? "Numbering" : "Bullets"}">${items.join("")}</text:list>`;
+    }
+    case "table": {
+      const cols = Math.max(0, ...kids.map((r) => r.content?.length ?? 0));
+      const row = (r) => `<table:table-row>${(r.content ?? []).map((c) => `<table:table-cell office:value-type="string">${(c.content ?? []).map((b) => block(b, out)).join("")}</table:table-cell>`).join("")}</table:table-row>`;
+      const header = kids[0]?.content?.length && kids[0].content.every((c) => c.type === "tableHeader");
+      const rows = header ? `<table:table-header-rows>${row(kids[0])}</table:table-header-rows>${kids.slice(1).map(row).join("")}` : kids.map(row).join("");
+      return `<table:table table:name="Table${++out.tables}">${cols ? `<table:table-column table:number-columns-repeated="${cols}"/>` : ""}${rows}</table:table>`;
+    }
+    default:
+      return "";
+  }
+}
+function exportOdt(blocks2) {
+  const out = { images: [], tables: 0 };
+  const body = blocks2.map((b) => block(b, out)).join("\n");
+  const content2 = `${XML}<office:document-content ${NS}><office:automatic-styles>${AUTO}</office:automatic-styles><office:body><office:text>${body}</office:text></office:body></office:document-content>`;
+  const entries = [
+    `<manifest:file-entry manifest:full-path="/" manifest:version="1.3" manifest:media-type="${ODT_MIME}"/>`,
+    ...["content.xml", "styles.xml", "meta.xml"].map((n) => `<manifest:file-entry manifest:full-path="${n}" manifest:media-type="text/xml"/>`),
+    ...out.images.map((i) => `<manifest:file-entry manifest:full-path="${i.name}" manifest:media-type="${i.type}"/>`)
+  ];
+  const meta = `${XML}<office:document-meta ${NS}><office:meta><meta:generator>agentic-documents</meta:generator></office:meta></office:document-meta>`;
+  const part = (text2) => [strToU8(text2), { mtime: FIXED_DATE }];
+  return zipSync({
+    mimetype: [strToU8(ODT_MIME), { level: 0, mtime: FIXED_DATE }],
+    // first and stored, so file sniffers can read it
+    "META-INF/manifest.xml": part(`${XML}<manifest:manifest ${NS}>${entries.join("")}</manifest:manifest>`),
+    "content.xml": part(content2),
+    "styles.xml": part(STYLES),
+    "meta.xml": part(meta),
+    ...Object.fromEntries(out.images.map((i) => [i.name, [i.data, { mtime: FIXED_DATE }]]))
+  });
+}
+
+// src/export.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 image2(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 inline3(node, remote) {
+  if (node.type === "hardBreak") return "<br>";
+  if (node.type === "image") return image2(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 block2(node, remote) {
+  const kids = (node.content ?? []).map((n) => block2(n, remote)).join("");
+  const text2 = (node.content ?? []).map((n) => inline3(n, remote)).join("");
+  switch (node.type) {
+    case "paragraph":
+      return `<p>${text2}</p>
+`;
+    case "heading": {
+      const level = Math.min(6, Math.max(1, integer(node.attrs?.level, 1)));
+      return `<h${level}>${text2}</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(blocks2, remote) {
+  const title = textOf(blocks2.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>
+${blocks2.map((b) => block2(b, remote)).join("")}</body>
+</html>
+`;
+}
+function exportDoc(doc, format, options = {}) {
+  if (format === "html") {
+    return { format, contentType: "text/html; charset=utf-8", encoding: "utf8", data: toHtml(doc.toJSON().content ?? [], options.remoteImages === true) };
+  }
+  if (format === "odt") return { format, contentType: ODT_MIME, encoding: "base64", data: toBase64(exportOdt(doc.toJSON().content ?? [])) };
+  return { format, contentType: "text/markdown; charset=utf-8", encoding: "utf8", data: doc.toMarkdown() };
+}
+
+// src/review.ts
+import * as Y3 from "yjs";
+var newId = () => globalThis.crypto.randomUUID();
+function nonEmpty(value, what) {
+  if (typeof value !== "string" || value.trim() === "") throw new DocError("INVALID_INPUT", `${what} must not be empty`);
+  return value;
+}
+function anchorFor(doc, target2) {
+  if ("anchor" in target2) {
+    doc.resolve(target2);
+    return target2.anchor;
+  }
+  return doc.anchor(target2.text, target2.occurrence);
+}
+function isStale(doc, anchor) {
+  try {
+    doc.resolve({ anchor });
+    return { stale: false, currentText: anchor.text };
+  } catch (error) {
+    if (!(error instanceof DocError) || error.code !== "STALE_ANCHOR") throw error;
+    return { stale: true, currentText: null };
+  }
+}
+function fieldsOf(doc, name) {
+  return doc.ydoc.getMap(name);
+}
+var optional = (map, key) => map.has(key) ? { [key]: map.get(key) } : {};
+function setAll(map, values) {
+  for (const [key, value] of Object.entries(values)) if (value !== void 0) map.set(key, value);
+}
+var Threads = class {
+  constructor(doc) {
+    this.doc = doc;
+  }
+  doc;
+  get map() {
+    return fieldsOf(this.doc, "threads");
+  }
+  get(id2) {
+    const thread2 = this.map.get(id2);
+    if (!thread2) throw new DocError("NO_THREAD", `no thread with id "${id2}"`);
+    return thread2;
+  }
+  message(body, author) {
+    return { id: newId(), at: this.doc.now().toISOString(), author, body };
+  }
+  add(target2, body, author) {
+    const who = checkAuthor(author);
+    nonEmpty(body, "a comment");
+    const anchor = anchorFor(this.doc, target2);
+    const id2 = newId();
+    this.doc.ydoc.transact(() => {
+      const thread2 = new Y3.Map();
+      this.map.set(id2, thread2);
+      setAll(thread2, { anchor, status: "open" });
+      const messages = new Y3.Array();
+      thread2.set("messages", messages);
+      messages.push([this.message(body, who)]);
+    });
+    return id2;
+  }
+  reply(id2, body, author) {
+    const who = checkAuthor(author);
+    nonEmpty(body, "a reply");
+    this.get(id2).get("messages").push([this.message(body, who)]);
+  }
+  setStatus(id2, status, author) {
+    const who = checkAuthor(author);
+    const thread2 = this.get(id2);
+    this.doc.ydoc.transact(() => {
+      thread2.set("status", status);
+      if (status === "open") {
+        thread2.delete("resolvedBy");
+        thread2.delete("resolvedAt");
+      } else setAll(thread2, { resolvedBy: who, resolvedAt: this.doc.now().toISOString() });
+    });
+  }
+  resolve(id2, author) {
+    this.setStatus(id2, "resolved", author);
+  }
+  reopen(id2, author) {
+    this.setStatus(id2, "open", author);
+  }
+  list(filter = {}) {
+    return [...this.map.entries()].map(([id2, t]) => {
+      const anchor = t.get("anchor");
+      return {
+        id: id2,
+        anchor,
+        status: t.get("status"),
+        ...optional(t, "resolvedBy"),
+        ...optional(t, "resolvedAt"),
+        messages: t.get("messages").toArray(),
+        ...isStale(this.doc, anchor)
+      };
+    }).filter((t) => filter.status === void 0 || t.status === filter.status).sort((a, b) => a.messages[0].at.localeCompare(b.messages[0].at) || a.id.localeCompare(b.id));
+  }
+};
+var ACCEPT_SCOPE = "docs:accept";
+var sameWho = (a, b) => a.kind === b.kind && a.name === b.name;
+var isPerson = (who) => who.kind === "human" || who.kind === "user_token";
+var mayDecide = (who) => isPerson(who) || who.scopes?.includes(ACCEPT_SCOPE) === true;
+var Suggestions = class {
+  constructor(doc) {
+    this.doc = doc;
+  }
+  doc;
+  get map() {
+    return fieldsOf(this.doc, "suggestions");
+  }
+  get(id2) {
+    const fields = this.map.get(id2);
+    if (!fields) throw new DocError("NO_SUGGESTION", `no suggestion with id "${id2}"`);
+    return { fields, suggestion: this.read(id2, fields) };
+  }
+  read(id2, f) {
+    const anchor = f.get("anchor");
+    return {
+      id: id2,
+      kind: f.get("kind"),
+      ...optional(f, "at"),
+      anchor,
+      replacement: f.get("replacement"),
+      author: f.get("author"),
+      createdAt: f.get("createdAt"),
+      status: f.get("status"),
+      ...optional(f, "decidedBy"),
+      ...optional(f, "decidedAt"),
+      stale: isStale(this.doc, anchor).stale
+    };
+  }
+  /** An `at` on the target means insert. An empty replacement means delete. */
+  add(target2, replacement, author) {
+    const who = checkAuthor(author);
+    const kind = target2.at ? "insert" : replacement === "" ? "delete" : "replace";
+    if (kind === "insert") nonEmpty(replacement, "an inserted text");
+    const anchor = anchorFor(this.doc, target2);
+    const id2 = newId();
+    this.doc.ydoc.transact(() => {
+      const fields = new Y3.Map();
+      this.map.set(id2, fields);
+      setAll(fields, { kind, at: target2.at, anchor, replacement, author: who, createdAt: this.doc.now().toISOString(), status: "pending" });
+    });
+    return id2;
+  }
+  decide(fields, status, author, at) {
+    setAll(fields, { status, decidedBy: author, decidedAt: at });
+  }
+  /**
+   * 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(id2, author) {
+    const who = checkAuthor(author);
+    this.doc.ydoc.transact(() => {
+      const { fields, suggestion: s } = this.get(id2);
+      if (!mayDecide(author) || sameWho(s.author, who)) {
+        throw new DocError("FORBIDDEN", `${who.kind}:${who.name} cannot accept this suggestion: a person who is not its author, or an agent with the ${ACCEPT_SCOPE} scope, can`);
+      }
+      if (s.status === "accepted") return;
+      if (s.status !== "pending") throw new DocError("ALREADY_DECIDED", `suggestion "${id2}" is already ${s.status}`);
+      const { at, inserted } = this.doc.edit(s.kind, { anchor: s.anchor, at: s.at }, s.replacement, who, { suggestion: { id: id2, author: s.author } });
+      const record = { by: who, at, ...inserted };
+      this.doc.ydoc.getMap(APPLIED).set(`${id2}:${this.doc.ydoc.clientID}`, record);
+      this.decide(fields, "accepted", who, at);
+    });
+  }
+  /** Same right as accept. A person can withdraw their own suggestion. An agent can never decide its own. */
+  reject(id2, author) {
+    const who = checkAuthor(author);
+    this.doc.ydoc.transact(() => {
+      const { fields, suggestion: s } = this.get(id2);
+      if (!mayDecide(author) || !isPerson(who) && sameWho(s.author, who)) {
+        throw new DocError("FORBIDDEN", `${who.kind}:${who.name} cannot reject this suggestion: a person, or an agent with the ${ACCEPT_SCOPE} scope that did not write it, can`);
+      }
+      if (s.status !== "pending") throw new DocError("ALREADY_DECIDED", `suggestion "${id2}" is already ${s.status}`);
+      this.decide(fields, "rejected", who, this.doc.now().toISOString());
+    });
+  }
+  list(filter = {}) {
+    return [...this.map.entries()].map(([id2, f]) => this.read(id2, f)).filter((s) => filter.status === void 0 || s.status === filter.status).sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id));
+  }
+};
+
+// src/commands.ts
+import { z } from "zod";
+var id = z.string().describe("Document id.");
+var content = z.string().describe("Markdown for a section target. Plain text for a text target.");
+var text = z.string().describe("Exact text to match. It must sit inside one block.");
+var occurrence = z.coerce.number().int().min(1).optional().describe("Which match, counting from 1, when the text matches more than once.");
+var side = z.enum(["before", "after"]).optional().describe("Put the new text before or after the match.");
+var thread = z.string().describe("Thread id.");
+var where = {
+  section: z.string().optional().describe("Section id from the outline. Use this or text."),
+  text: text.optional(),
+  occurrence,
+  at: z.enum(["start", "end", "before", "after"]).optional().describe("Insert at the start or end of a section, or before or after matched text.")
+};
+function target(input) {
+  const { section, text: text2, occurrence: occurrence2, at } = input;
+  if (section !== void 0) {
+    if (at !== void 0 && at !== "start" && at !== "end") throw new DocError("INVALID_INPUT", `at "${at}" does not fit a section; use start or end`);
+    return { section, at };
+  }
+  if (text2 !== void 0) {
+    if (at === "start" || at === "end") throw new DocError("INVALID_INPUT", `at "${at}" does not fit text; use before or after`);
+    return { text: text2, occurrence: occurrence2, at };
+  }
+  throw new DocError("INVALID_INPUT", "pass section or text");
+}
+var textTarget = (input) => ({
+  text: input.text,
+  occurrence: input.occurrence,
+  at: input.at
+});
+function command(name, description, readOnly, shape, run) {
+  return {
+    name,
+    description,
+    shape,
+    readOnly,
+    async run(service, raw, author) {
+      const parsed = z.object(shape).strict().safeParse(raw);
+      if (!parsed.success) {
+        throw new DocError("INVALID_INPUT", parsed.error.issues.map((i) => `${i.path.join(".") || "input"}: ${i.message}`).join("; "));
+      }
+      return run(service, parsed.data, author);
+    }
+  };
+}
+var ok = () => ({ ok: true });
+var commands = [
+  command("new", "Create a document, from Markdown if given.", false, { id, markdown: z.string().optional() }, async (s, i, a) => {
+    await s.create(i.id, i.markdown ?? "", a);
+    return { id: i.id };
+  }),
+  command(
+    "read",
+    "Read a document, or one section, as Markdown.",
+    true,
+    { id, section: where.section },
+    (s, i) => s.read(i.id, (d) => i.section ? d.readSection(i.section) : d.toMarkdown())
+  ),
+  command("outline", "List sections with their ids, levels, and titles.", true, { id }, (s, i) => s.read(i.id, (d) => d.outline())),
+  command("edits", "Read the edit log. It names each author kind and holds no content.", true, { id }, (s, i) => s.read(i.id, (d) => d.edits())),
+  command("insert", "Insert Markdown into a section, or plain text next to matched text.", false, { id, ...where, content }, async (s, i, a) => {
+    await s.write(i.id, (d) => d.insert(target(i), i.content, a));
+    return ok();
+  }),
+  command("replace", "Replace a section body (the heading stays), or the matched text.", false, { id, ...where, content }, async (s, i, a) => {
+    await s.write(i.id, (d) => d.replace(target(i), i.content, a));
+    return ok();
+  }),
+  command("delete", "Delete a section with its subsections, or the matched text.", false, { id, ...where }, async (s, i, a) => {
+    await s.write(i.id, (d) => d.delete(target(i), a));
+    return ok();
+  }),
+  command("append", "Add Markdown at the end of the document.", false, { id, content: z.string() }, async (s, i, a) => {
+    await s.write(i.id, (d) => d.append(i.content, a));
+    return ok();
+  }),
+  command("suggest", "Suggest an edit to matched text. An empty replacement suggests a delete.", false, { id, text, occurrence, at: side, replacement: z.string() }, async (s, i, a) => ({
+    suggestion: await s.write(i.id, (d) => new Suggestions(d).add(textTarget(i), i.replacement, a))
+  })),
+  command(
+    "suggestions",
+    "List suggested edits.",
+    true,
+    { id, status: z.enum(["pending", "accepted", "rejected"]).optional() },
+    (s, i) => s.read(i.id, (d) => new Suggestions(d).list({ status: i.status }))
+  ),
+  command("accept", "Accept a suggestion. The text changes now.", false, { id, suggestion: z.string() }, async (s, i, a) => {
+    await s.write(i.id, (d) => new Suggestions(d).accept(i.suggestion, a));
+    return ok();
+  }),
+  command("reject", "Reject a suggestion. The text stays.", false, { id, suggestion: z.string() }, async (s, i, a) => {
+    await s.write(i.id, (d) => new Suggestions(d).reject(i.suggestion, a));
+    return ok();
+  }),
+  command("comment", "Start a comment thread on matched text.", false, { id, text, occurrence, body: z.string() }, async (s, i, a) => ({
+    thread: await s.write(i.id, (d) => new Threads(d).add(textTarget(i), i.body, a))
+  })),
+  command("reply", "Reply in a comment thread.", false, { id, thread, body: z.string() }, async (s, i, a) => {
+    await s.write(i.id, (d) => new Threads(d).reply(i.thread, i.body, a));
+    return ok();
+  }),
+  command("resolve", "Resolve a comment thread.", false, { id, thread }, async (s, i, a) => {
+    await s.write(i.id, (d) => new Threads(d).resolve(i.thread, a));
+    return ok();
+  }),
+  command("reopen", "Reopen a comment thread.", false, { id, thread }, async (s, i, a) => {
+    await s.write(i.id, (d) => new Threads(d).reopen(i.thread, a));
+    return ok();
+  }),
+  command(
+    "threads",
+    "List comment threads with their messages.",
+    true,
+    { id, status: z.enum(["open", "resolved"]).optional() },
+    (s, i) => s.read(i.id, (d) => new Threads(d).list({ status: i.status }))
+  ),
+  command(
+    "export",
+    "Export the document as Markdown (md), self-contained HTML (html), or OpenDocument text (odt, base64). HTML shows no remote image unless remoteImages is true.",
+    true,
+    { id, format: z.enum(EXPORT_FORMATS), remoteImages: z.union([z.boolean(), z.enum(["true", "false"])]).optional() },
+    (s, i) => s.read(i.id, (d) => exportDoc(d, i.format, { remoteImages: i.remoteImages === true || i.remoteImages === "true" }))
+  )
+];
+
+export {
+  DocError,
+  markdownToBlocks,
+  blocksToMarkdown,
+  schema,
+  PRINCIPAL_KINDS,
+  parseAuthor,
+  AgenticDoc,
+  ODT_MIME,
+  exportOdt,
+  EXPORT_FORMATS,
+  exportDoc,
+  Threads,
+  Suggestions,
+  commands
+};