agentic-documents 0.3.0 → 0.5.0

package/dist/{chunk-GYQFTF2E.js → chunk-L6W2AQUF.js}

@@ -1,20 +1,11 @@
-import {
-  DocError,
-  Suggestions,
-  Threads
-} from "./chunk-YBBQNCMC.js";
-
-// 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);
+  let text = "";
+  for (let i = 0; i < bytes.length; i += 32768) text += String.fromCharCode(...bytes.subarray(i, i + 32768));
+  return btoa(text);
 }
 var fromBase64 = (value) => Uint8Array.from(atob(value), (c) => c.charCodeAt(0));
 function imageSize(b) {
@@ -37,6 +28,7 @@ var safeHref = (value) => {
 };
 
 // src/odt.ts
+import { strToU8, zipSync } from "fflate";
 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';
@@ -135,19 +127,19 @@ function block(node, out, style = "Standard") {
 function exportOdt(blocks) {
   const out = { images: [], tables: 0 };
   const body = blocks.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 content = `${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 }];
+  const part = (text) => [strToU8(text), { 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),
+    "content.xml": part(content),
     "styles.xml": part(STYLES),
     "meta.xml": part(meta),
     ...Object.fromEntries(out.images.map((i) => [i.name, [i.data, { mtime: FIXED_DATE }]]))
@@ -180,14 +172,14 @@ function inline2(node, remote) {
 }
 function block2(node, remote) {
   const kids = (node.content ?? []).map((n) => block2(n, remote)).join("");
-  const text2 = (node.content ?? []).map((n) => inline2(n, remote)).join("");
+  const text = (node.content ?? []).map((n) => inline2(n, remote)).join("");
   switch (node.type) {
     case "paragraph":
-      return `<p>${text2}</p>
+      return `<p>${text}</p>
 `;
     case "heading": {
       const level = Math.min(6, Math.max(1, integer(node.attrs?.level, 1)));
-      return `<h${level}>${text2}</h${level}>
+      return `<h${level}>${text}</h${level}>
 `;
     }
     case "blockquote":
@@ -254,136 +246,13 @@ function exportDoc(doc, format, options = {}) {
   return { format, contentType: "text/markdown; charset=utf-8", encoding: "utf8", data: doc.toMarkdown() };
 }
 
-// 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 {
+  DATA_IMAGE,
+  toBase64,
+  fromBase64,
+  safeHref,
   ODT_MIME,
   exportOdt,
   EXPORT_FORMATS,
-  exportDoc,
-  commands
+  exportDoc
 };

package/dist/chunk-S6MQDWFK.js

@@ -0,0 +1,150 @@
+import {
+  EXPORT_FORMATS,
+  exportDoc
+} from "./chunk-L6W2AQUF.js";
+import {
+  Suggestions,
+  Threads
+} from "./chunk-UPEGODUV.js";
+import {
+  DocError
+} from "./chunk-6QOYS63L.js";
+
+// 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("list", "List documents with their titles, creators, and last edits.", true, {}, (s) => s.list()),
+  command("rename", "Give a document a title. The text stays.", false, { id, title: z.string().describe("1 to 120 characters of plain text.") }, async (s, i, a) => {
+    await s.rename(i.id, i.title, a);
+    return ok();
+  }),
+  command("remove", "Delete a whole document. A person may. An agent needs the docs:remove scope.", false, { id }, async (s, i, a) => {
+    await s.remove(i.id, a);
+    return ok();
+  }),
+  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), 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), 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), 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), 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), 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), 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), 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), 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), 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), 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), 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 {
+  commands
+};

package/dist/chunk-UPEGODUV.js

@@ -0,0 +1,195 @@
+import {
+  APPLIED,
+  DocError,
+  checkAuthor
+} from "./chunk-6QOYS63L.js";
+
+// src/review.ts
+import * as Y 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 Y.Map();
+      this.map.set(id, thread);
+      setAll(thread, { anchor, status: "open" });
+      const messages = new Y.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 Y.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 {
+  Threads,
+  isPerson,
+  Suggestions
+};