agentic-documents 0.1.0 → 0.2.0

package/dist/chunk-YBBQNCMC.js

@@ -0,0 +1,744 @@
+// src/errors.ts
+var DOC_ERROR_CODES = ["NO_MATCH", "AMBIGUOUS_MATCH", "STALE_ANCHOR", "NO_SECTION", "INVALID_AUTHOR", "INVALID_INPUT", "NO_THREAD", "NO_SUGGESTION", "ALREADY_DECIDED", "FORBIDDEN", "NO_DOCUMENT", "DOCUMENT_EXISTS", "LOCKED", "CONFLICT", "MISCONFIGURED"];
+var DocError = class extends Error {
+  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, content) => content.length ? { ...node, content } : node;
+function inline(nodes2, marks2 = []) {
+  return nodes2.flatMap((node) => {
+    const text = (value, own) => value ? [{ type: "text", text: value, ...own.length ? { marks: own } : {} }] : [];
+    switch (node.type) {
+      case "text":
+        return text(node.value, marks2);
+      case "html":
+        return text(node.value, marks2);
+      case "inlineCode":
+        return text(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 url = definitions.get(node.identifier)?.url ?? unsupported("image reference without a definition");
+        return [{ type: "image", attrs: { src: url, alt: node.alt ?? null, title: null } }];
+      }
+      default:
+        return unsupported(`"${node.type}"`);
+    }
+  });
+}
+function itemContent(children) {
+  const content = blocks(children);
+  return content[0]?.type === "paragraph" ? content : [{ type: "paragraph" }, ...content];
+}
+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 id = key.slice(0, key.lastIndexOf(":"));
+    groups.set(id, [...groups.get(id) ?? [], [key, record]]);
+  }
+  if (groups.size === 0) return;
+  const suggestions = ydoc.getMap("suggestions");
+  const log = ydoc.getArray("edits");
+  ydoc.transact(() => {
+    for (const [id, records] of groups) {
+      records.sort((a, b) => clientOf(a[0]) - clientOf(b[0]));
+      const [[, winner], ...losers] = records;
+      const fields = suggestions.get(id);
+      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 === id ? [{ 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 ok = 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 (!ok) 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(content) {
+  const scratch = new Y2.Doc().getXmlFragment(FRAGMENT);
+  prosemirrorJSONToYXmlFragment(schema, { type: "doc", content }, 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 content = markdownToBlocks(markdown);
+    doc.change("create", who, () => {
+      doc.fragment.insert(0, toYBlocks(content));
+      return { inserted: content.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(id) {
+    const { start, end } = this.range(id);
+    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(id) {
+    const all = this.headings();
+    if (id === PREAMBLE) return { start: 0, end: all.length ? all[0].index : this.fragment.length, headed: false };
+    const at = all.findIndex(({ el }) => sectionId(el) === id);
+    if (at < 0) throw new DocError("NO_SECTION", `no section with id "${id}"`);
+    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(text) {
+    if (text === "") return [];
+    return unitsOf(this.fragment).flatMap((unit) => {
+      const found = [];
+      const value = unitText(unit);
+      for (let at = value.indexOf(text); at >= 0; at = value.indexOf(text, at + 1)) {
+        found.push({ unit, start: at, end: at + text.length });
+      }
+      return found;
+    });
+  }
+  pick(text, occurrence) {
+    const found = this.find(text);
+    if (found.length === 0) throw new DocError("NO_MATCH", `no text matches "${text}"`);
+    if (occurrence !== void 0) {
+      if (found[occurrence - 1] === void 0) throw new DocError("NO_MATCH", `"${text}" has ${found.length} matches, not ${occurrence}`);
+      return found[occurrence - 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", `"${text}" 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(text, occurrence) {
+    const { unit, start, end } = this.pick(text, occurrence);
+    return {
+      text,
+      start: Y2.relativePositionToJSON(Y2.createRelativePositionFromTypeIndex(unit, start, 0)),
+      end: Y2.relativePositionToJSON(Y2.createRelativePositionFromTypeIndex(unit, end, -1))
+    };
+  }
+  resolve(target) {
+    if (!isAnchor(target)) return this.pick(target.text, target.occurrence);
+    const { anchor } = target;
+    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, target, content, author, extra = {}) {
+    const who = checkAuthor(author);
+    const { unit, start, end } = this.resolve(target);
+    let inserted;
+    const at = this.change(op, who, () => {
+      const marks2 = attrsAt(unit, op === "insert" && target.at !== "before" ? end - 1 : start);
+      if (op === "insert") delete marks2.link;
+      const index = op === "insert" ? target.at === "before" ? start : end : start;
+      if (op !== "insert") unit.delete(start, end - start);
+      if (op !== "delete") {
+        unit.insert(index, content, marks2);
+        inserted = {
+          start: Y2.relativePositionToJSON(Y2.createRelativePositionFromTypeIndex(unit, index, 0)),
+          end: Y2.relativePositionToJSON(Y2.createRelativePositionFromTypeIndex(unit, index + content.length, -1))
+        };
+      }
+      return { inserted: op === "delete" ? 0 : content.length, deleted: op === "insert" ? 0 : end - start };
+    }, extra);
+    return { at, inserted };
+  }
+  editSection(op, target, markdown, author) {
+    const who = checkAuthor(author);
+    const { start, end, headed } = this.range(target.section);
+    const body = headed ? start + 1 : start;
+    const content = 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" || target.at === "start" ? body : end;
+      if (op === "replace") this.fragment.delete(body, end - body);
+      if (op === "delete") this.fragment.delete(start, end - start);
+      if (content.length) this.fragment.insert(from, toYBlocks(content));
+      return { inserted: content.length, deleted, section: target.section };
+    });
+  }
+  /** Insert Markdown into a section, or plain text next to matched text. */
+  insert(target, content, author) {
+    if (isSection(target)) this.editSection("insert", target, content, author);
+    else this.edit("insert", target, content, author);
+  }
+  /** Replace a section body (the heading stays), or the matched text. */
+  replace(target, content, author) {
+    if (isSection(target)) this.editSection("replace", target, content, author);
+    else this.edit("replace", target, content, author);
+  }
+  /** Delete a whole section with its subsections, or the matched text. */
+  delete(target, author) {
+    if (isSection(target)) this.editSection("delete", target, "", author);
+    else this.edit("delete", target, "", author);
+  }
+  append(markdown, author) {
+    const who = checkAuthor(author);
+    const content = markdownToBlocks(markdown);
+    this.change("append", who, () => {
+      this.fragment.insert(this.fragment.length, toYBlocks(content));
+      return { inserted: content.length, deleted: 0 };
+    });
+  }
+};
+
+// 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, target) {
+  if ("anchor" in target) {
+    doc.resolve(target);
+    return target.anchor;
+  }
+  return doc.anchor(target.text, target.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(id) {
+    const thread = this.map.get(id);
+    if (!thread) throw new DocError("NO_THREAD", `no thread with id "${id}"`);
+    return thread;
+  }
+  message(body, author) {
+    return { id: newId(), at: this.doc.now().toISOString(), author, body };
+  }
+  add(target, body, author) {
+    const who = checkAuthor(author);
+    nonEmpty(body, "a comment");
+    const anchor = anchorFor(this.doc, target);
+    const id = newId();
+    this.doc.ydoc.transact(() => {
+      const thread = new Y3.Map();
+      this.map.set(id, thread);
+      setAll(thread, { anchor, status: "open" });
+      const messages = new Y3.Array();
+      thread.set("messages", messages);
+      messages.push([this.message(body, who)]);
+    });
+    return id;
+  }
+  reply(id, body, author) {
+    const who = checkAuthor(author);
+    nonEmpty(body, "a reply");
+    this.get(id).get("messages").push([this.message(body, who)]);
+  }
+  setStatus(id, status, author) {
+    const who = checkAuthor(author);
+    const thread = this.get(id);
+    this.doc.ydoc.transact(() => {
+      thread.set("status", status);
+      if (status === "open") {
+        thread.delete("resolvedBy");
+        thread.delete("resolvedAt");
+      } else setAll(thread, { resolvedBy: who, resolvedAt: this.doc.now().toISOString() });
+    });
+  }
+  resolve(id, author) {
+    this.setStatus(id, "resolved", author);
+  }
+  reopen(id, author) {
+    this.setStatus(id, "open", author);
+  }
+  list(filter = {}) {
+    return [...this.map.entries()].map(([id, t]) => {
+      const anchor = t.get("anchor");
+      return {
+        id,
+        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(id) {
+    const fields = this.map.get(id);
+    if (!fields) throw new DocError("NO_SUGGESTION", `no suggestion with id "${id}"`);
+    return { fields, suggestion: this.read(id, fields) };
+  }
+  read(id, f) {
+    const anchor = f.get("anchor");
+    return {
+      id,
+      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(target, replacement, author) {
+    const who = checkAuthor(author);
+    const kind = target.at ? "insert" : replacement === "" ? "delete" : "replace";
+    if (kind === "insert") nonEmpty(replacement, "an inserted text");
+    const anchor = anchorFor(this.doc, target);
+    const id = newId();
+    this.doc.ydoc.transact(() => {
+      const fields = new Y3.Map();
+      this.map.set(id, fields);
+      setAll(fields, { kind, at: target.at, anchor, replacement, author: who, createdAt: this.doc.now().toISOString(), status: "pending" });
+    });
+    return id;
+  }
+  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(id, author) {
+    const who = checkAuthor(author);
+    this.doc.ydoc.transact(() => {
+      const { fields, suggestion: s } = this.get(id);
+      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 "${id}" is already ${s.status}`);
+      const { at, inserted } = this.doc.edit(s.kind, { anchor: s.anchor, at: s.at }, s.replacement, who, { suggestion: { id, author: s.author } });
+      const record = { by: who, at, ...inserted };
+      this.doc.ydoc.getMap(APPLIED).set(`${id}:${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(id, author) {
+    const who = checkAuthor(author);
+    this.doc.ydoc.transact(() => {
+      const { fields, suggestion: s } = this.get(id);
+      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 "${id}" is already ${s.status}`);
+      this.decide(fields, "rejected", who, this.doc.now().toISOString());
+    });
+  }
+  list(filter = {}) {
+    return [...this.map.entries()].map(([id, f]) => this.read(id, f)).filter((s) => filter.status === void 0 || s.status === filter.status).sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id));
+  }
+};
+
+export {
+  DOC_ERROR_CODES,
+  DocError,
+  markdownToBlocks,
+  blocksToMarkdown,
+  schema,
+  PRINCIPAL_KINDS,
+  parseAuthor,
+  AgenticDoc,
+  Threads,
+  Suggestions
+};