revise 2.2.0 → 3.0.0

package/chunks/chunk-ZLQVPMBN.js

@@ -0,0 +1,1650 @@
+// revise: MIT License. https://revise.io/developer/docs
+import {
+  ReviseError
+} from "./chunk-U6YKQBKL.js";
+
+// src/embed-sdk/lib/document.ts
+import { engineModules as engineModules2 } from "@reviseio/engine";
+import * as Y from "yjs";
+import {
+  createReviseYDoc as createReviseYDoc2,
+  createServerDocumentSession,
+  decodeYDoc,
+  encodeYDoc,
+  exportDocument,
+  fileToYDoc,
+  installDomShims,
+  parseDocument as parseDocument2,
+  ydocSourceFidelity as ydocSourceFidelity2,
+  ydocToDocument as ydocToDocument2
+} from "@reviseio/engine";
+import { seedDocRootWithClaim as seedDocRootWithClaim2, seedYDocFromFile } from "@reviseio/engine";
+
+// src/embed-sdk/lib/docx.ts
+import { engineModules } from "@reviseio/engine";
+import {
+  createReviseYDoc,
+  documentToDocx,
+  parseDocument,
+  ydocSourceFidelity,
+  ydocToDocument
+} from "@reviseio/engine";
+import { createHash } from "node:crypto";
+import { seedDocRootWithClaim } from "@reviseio/engine";
+async function exportSessionDocx(ydoc, pkg, mode = "review") {
+  let doc = ydocToDocument(ydoc);
+  const grafting = Boolean(pkg && doc.docxSource);
+  const regenerated = grafting ? new Set((await ydocSourceFidelity(ydoc)).regeneratedBlockIds) : null;
+  if (mode === "final") {
+    const { scrubDocument } = await engineModules.scrubber();
+    doc = scrubDocument(doc, {
+      removeComments: true,
+      resolveSuggestions: "accept"
+    }).doc;
+  }
+  doc = stampParaIds(
+    doc,
+    regenerated,
+    grafting ? graftKeptParts(doc, await engineModules.docxGraft()) : void 0
+  );
+  if (!grafting || !pkg || !doc.docxSource) {
+    return {
+      bytes: await documentToDocx(doc),
+      outcome: {
+        method: "regenerated",
+        exact: false,
+        regeneratedBlocks: doc.children.length,
+        fallbackCode: doc.docxSource ? "no-original-package" : "not-from-docx"
+      }
+    };
+  }
+  const { hashBytes } = await engineModules.docxGraft();
+  doc = {
+    ...doc,
+    docxSource: { ...doc.docxSource, sourceHash: await hashBytes(pkg) }
+  };
+  let reported = {
+    method: "regenerated",
+    exact: false,
+    regeneratedBlocks: doc.children.length,
+    fallbackCode: "no-outcome"
+  };
+  const bytes = await documentToDocx(doc, {
+    originalDocx: pkg,
+    onGraftOutcome: (outcome) => {
+      reported = outcome.mode === "regenerated" ? {
+        method: "regenerated",
+        exact: false,
+        regeneratedBlocks: doc.children.length,
+        fallbackCode: outcome.fallbackCode
+      } : {
+        method: "graft",
+        exact: outcome.mode === "exact",
+        regeneratedBlocks: outcome.regeneratedBlockCount ?? 0
+      };
+    }
+  });
+  return { bytes, outcome: reported };
+}
+var PARA_ID_KEY = "w14:paraId";
+function paraIdOf(node) {
+  if (!node.oxmlAttrs) return void 0;
+  try {
+    const attrs = JSON.parse(node.oxmlAttrs);
+    const value = attrs[PARA_ID_KEY];
+    return typeof value === "string" ? value.toUpperCase() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function derivedParaId(blockId, salt = 0) {
+  const value = createHash("sha1").update(salt ? `${blockId}:${salt}` : blockId).digest().readUInt32BE(0) & 2147483647;
+  return (value || 1).toString(16).toUpperCase().padStart(8, "0");
+}
+function childrenOf(node) {
+  return (Array.isArray(node.children) ? node.children : []).filter(
+    (child) => child !== null && typeof child === "object" && "type" in child
+  );
+}
+function contentSignature(node) {
+  const n = node;
+  if (!n || typeof n !== "object") return "";
+  if (n.type === "text") return JSON.stringify(n.text ?? "");
+  const children = Array.isArray(n.children) ? n.children : [];
+  return `${n.type ?? "?"}(${children.map(contentSignature).join(",")})`;
+}
+function walkIds(node, visit) {
+  visit(node);
+  for (const child of childrenOf(node)) walkIds(child, visit);
+}
+function graftKeptParts(doc, graft) {
+  const kept = { whole: /* @__PURE__ */ new Set(), head: /* @__PURE__ */ new Set() };
+  const source = doc.docxSource;
+  if (!source?.parts) return kept;
+  const version = source.signatureVersion === graft.CURRENT_GRAFT_SIGNATURE_VERSION ? graft.CURRENT_GRAFT_SIGNATURE_VERSION : 1;
+  for (const block of doc.children) {
+    const captured = block.id ? source.parts[block.id] : void 0;
+    if (!captured || block.type !== "table" && block.type !== "list") {
+      continue;
+    }
+    for (const part of block.children) {
+      const entry = captured.parts.find((p) => p.id === part.id);
+      if (!entry || !part.id) continue;
+      if (entry.signature === graft.partSignature(part, version)) {
+        kept.whole.add(part.id);
+        continue;
+      }
+      if (block.type === "table" && entry.cells && entry.head === graft.partHeadSignature(part, version)) {
+        kept.head.add(part.id);
+        part.children?.forEach((cell, c) => {
+          const cellEntry = entry.cells[c];
+          if (cell.id && cellEntry?.id === cell.id && cellEntry.signature === graft.partSignature(cell, version)) {
+            kept.whole.add(cell.id);
+          }
+        });
+      }
+    }
+  }
+  return kept;
+}
+function stampParaIds(doc, regenerated, kept = { whole: /* @__PURE__ */ new Set(), head: /* @__PURE__ */ new Set() }) {
+  const used = /* @__PURE__ */ new Set();
+  for (const block of doc.children) {
+    walkIds(block, (node) => {
+      const id = paraIdOf(node);
+      if (id) used.add(id);
+    });
+  }
+  const stamp = (node) => {
+    if (node.id && kept.whole.has(node.id)) return node;
+    const copy = { ...node };
+    if ((copy.type === "paragraph" || copy.type === "table-row") && copy.id && !kept.head.has(copy.id) && !paraIdOf(copy)) {
+      let salt = 0;
+      let candidate = derivedParaId(copy.id);
+      while (used.has(candidate)) candidate = derivedParaId(copy.id, ++salt);
+      used.add(candidate);
+      let attrs = {};
+      try {
+        attrs = copy.oxmlAttrs ? JSON.parse(copy.oxmlAttrs) : {};
+      } catch {
+        attrs = {};
+      }
+      copy.oxmlAttrs = JSON.stringify({ ...attrs, [PARA_ID_KEY]: candidate });
+    }
+    if (Array.isArray(node.children)) {
+      copy.children = node.children.map(
+        (child) => child && typeof child === "object" && "type" in child ? stamp(child) : child
+      );
+    }
+    return copy;
+  };
+  return {
+    ...doc,
+    children: doc.children.map(
+      (block) => !regenerated || block.id && regenerated.has(block.id) ? stamp(block) : block
+    )
+  };
+}
+function lcsIndexPairs(a, b) {
+  const n = a.length;
+  const m = b.length;
+  if (n === 0 || m === 0) return [];
+  if (n * m > 4e6) {
+    const pairs2 = [];
+    let i2 = 0;
+    while (i2 < n && i2 < m && a[i2] === b[i2]) pairs2.push([i2, i2++]);
+    let k = 1;
+    while (k <= n - i2 && k <= m - i2 && a[n - k] === b[m - k]) {
+      pairs2.push([n - k, m - k]);
+      k += 1;
+    }
+    return pairs2.sort((x, y) => x[0] - y[0]);
+  }
+  const table = new Uint32Array((n + 1) * (m + 1));
+  for (let i2 = n - 1; i2 >= 0; i2 -= 1) {
+    for (let j2 = m - 1; j2 >= 0; j2 -= 1) {
+      table[i2 * (m + 1) + j2] = a[i2] === b[j2] ? table[(i2 + 1) * (m + 1) + j2 + 1] + 1 : Math.max(table[(i2 + 1) * (m + 1) + j2], table[i2 * (m + 1) + j2 + 1]);
+    }
+  }
+  const pairs = [];
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (a[i] === b[j]) {
+      pairs.push([i, j]);
+      i += 1;
+      j += 1;
+    } else if (table[(i + 1) * (m + 1) + j] >= table[i * (m + 1) + j + 1]) {
+      i += 1;
+    } else {
+      j += 1;
+    }
+  }
+  return pairs;
+}
+function matchIds(previous, next) {
+  const renamed = /* @__PURE__ */ new Map();
+  const changed = /* @__PURE__ */ new Set();
+  const oldIds = /* @__PURE__ */ new Set();
+  for (const block of previous.children) {
+    walkIds(block, (node) => node.id && oldIds.add(node.id));
+  }
+  const byParaId = /* @__PURE__ */ new Map();
+  for (const block of previous.children) {
+    walkIds(block, (node) => {
+      const explicit = paraIdOf(node);
+      if (explicit && !byParaId.has(explicit)) byParaId.set(explicit, node);
+    });
+  }
+  for (const block of previous.children) {
+    walkIds(block, (node) => {
+      if (!node.id) return;
+      const derived = derivedParaId(node.id);
+      if (!byParaId.has(derived)) byParaId.set(derived, node);
+    });
+  }
+  const oldParent = /* @__PURE__ */ new Map();
+  const indexParents = (node) => {
+    for (const child of childrenOf(node)) {
+      oldParent.set(child, node);
+      indexParents(child);
+    }
+  };
+  previous.children.forEach((block) => indexParents(block));
+  const seenParaIds = /* @__PURE__ */ new Set();
+  const duplicated = /* @__PURE__ */ new Set();
+  for (const block of next.children) {
+    walkIds(block, (node) => {
+      const pid = paraIdOf(node);
+      if (!pid) return;
+      if (seenParaIds.has(pid)) duplicated.add(pid);
+      seenParaIds.add(pid);
+    });
+  }
+  const claimed = /* @__PURE__ */ new Set();
+  let fresh = 0;
+  const carrySubtree = (from, to) => {
+    if (from.id && to.id) {
+      renamed.set(to.id, from.id);
+      to.id = from.id;
+    }
+    claimed.add(from);
+    const a = childrenOf(from);
+    const b = childrenOf(to);
+    b.forEach((child, i) => {
+      if (a[i] && a[i].type === child.type) carrySubtree(a[i], child);
+    });
+  };
+  const matchLists = (olds, news) => {
+    const pairs = /* @__PURE__ */ new Map();
+    for (const node of news) {
+      const pid = paraIdOf(node);
+      if (pid && duplicated.has(pid)) continue;
+      const old = pid ? byParaId.get(pid) : void 0;
+      if (old && !claimed.has(old) && old.type === node.type) {
+        pairs.set(node, old);
+        claimed.add(old);
+      }
+    }
+    const oldSet = new Set(olds);
+    for (const node of news) {
+      if (pairs.has(node) || paraIdOf(node)) continue;
+      let found;
+      walkIds(node, (inner) => {
+        if (found || inner === node) return;
+        const pid = paraIdOf(inner);
+        let at = pid && !duplicated.has(pid) ? byParaId.get(pid) : void 0;
+        while (at && !oldSet.has(at)) at = oldParent.get(at);
+        if (at && !claimed.has(at) && at.type === node.type) found = at;
+      });
+      if (found) {
+        pairs.set(node, found);
+        claimed.add(found);
+      }
+    }
+    const restOld = olds.filter((node) => !claimed.has(node));
+    const restNew = news.filter((node) => !pairs.has(node));
+    const lcs = lcsIndexPairs(
+      restOld.map(contentSignature),
+      restNew.map(contentSignature)
+    );
+    for (const [i, j] of lcs) {
+      if (restOld[i].type === restNew[j].type) {
+        pairs.set(restNew[j], restOld[i]);
+        claimed.add(restOld[i]);
+      }
+    }
+    for (const node of news) {
+      const old = pairs.get(node);
+      if (!old) {
+        walkIds(node, (n) => {
+          if (n.id && n.type !== "text") fresh += 1;
+          if (n.id && oldIds.has(n.id)) n.id = void 0;
+        });
+        continue;
+      }
+      if (contentSignature(old) === contentSignature(node)) {
+        carrySubtree(old, node);
+      } else {
+        if (old.id && node.id) {
+          renamed.set(node.id, old.id);
+          node.id = old.id;
+          changed.add(old.id);
+        }
+        matchLists(childrenOf(old), childrenOf(node));
+      }
+    }
+  };
+  matchLists(previous.children, next.children);
+  for (const block of next.children) {
+    walkIds(block, (node) => {
+      if (node.type !== "text" && node.id === void 0 && "id" in node) {
+        node.id = freshId(oldIds);
+      }
+    });
+  }
+  const source = next.docxSource;
+  if (source) {
+    source.spans = source.spans.map((span) => ({
+      ...span,
+      blockIds: span.blockIds.map((id) => renamed.get(id) ?? id)
+    }));
+  }
+  const nextIds = /* @__PURE__ */ new Set();
+  for (const block of next.children) {
+    walkIds(block, (node) => node.id && nextIds.add(node.id));
+  }
+  return {
+    kept: renamed.size,
+    fresh,
+    changedIds: [...changed],
+    removedIds: [...oldIds].filter((id) => !nextIds.has(id))
+  };
+}
+function freshId(avoid) {
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  for (; ; ) {
+    let id = "";
+    for (let i = 0; i < 6; i += 1) {
+      id += alphabet[Math.floor(Math.random() * alphabet.length)];
+    }
+    if (!avoid.has(id)) return id;
+  }
+}
+async function relearn(ydoc, bytes, filename) {
+  let next;
+  try {
+    next = await parseDocument(bytes, filename);
+  } catch (error) {
+    throw new ReviseError(
+      `${filename} does not open: ${error.message}. Nothing was changed.`,
+      "import_failed"
+    );
+  }
+  const previous = ydocToDocument(ydoc);
+  const ids = matchIds(previous, next);
+  const { refreshDocxSourceSignatures, storeDocxCarrier } = await engineModules.docxGraft();
+  refreshDocxSourceSignatures(next);
+  const synced = createReviseYDoc();
+  seedDocRootWithClaim(synced, next);
+  if (next.docxSource?.sourceHash) {
+    await storeDocxCarrier(synced, bytes, {
+      hash: next.docxSource.sourceHash
+    });
+  }
+  const styleMap = (doc) => new Map(
+    (doc.stylesheet?.paragraphStyles ?? []).map((style) => [
+      style.styleId,
+      JSON.stringify(style)
+    ])
+  );
+  const stylesBefore = styleMap(previous);
+  const changedStyles = [...styleMap(next)].filter(([id, json]) => stylesBefore.get(id) !== json).map(([id]) => id);
+  return {
+    ydoc: synced,
+    pkg: bytes,
+    idsKept: ids.kept,
+    idsNew: ids.fresh,
+    changedIds: ids.changedIds,
+    removedIds: ids.removedIds,
+    changedBlocks: ids.changedIds.length,
+    changedStyles
+  };
+}
+
+// src/embed-sdk/lib/document.ts
+var READABLE = /\.(docx|md|markdown|html?|odt|rtf|txt)$/i;
+var PLAIN_FORMATS = /\.(md|markdown|html?|txt)$/i;
+var EXTENSION_FORMATS = {
+  ".docx": "docx",
+  ".pdf": "pdf",
+  ".md": "markdown",
+  ".markdown": "markdown",
+  ".html": "html",
+  ".htm": "html",
+  ".txt": "txt"
+};
+function formatForPath(file) {
+  const match = /\.[^./\\]+$/.exec(file);
+  return match ? EXTENSION_FORMATS[match[0].toLowerCase()] : void 0;
+}
+async function readSource(source) {
+  if (typeof source !== "string") return source;
+  const fs = await import("node:fs");
+  if (!fs.existsSync(source)) {
+    throw new ReviseError(`No such file: ${source}`, "not_found");
+  }
+  try {
+    return { bytes: new Uint8Array(fs.readFileSync(source)), filename: source };
+  } catch (error) {
+    throw new ReviseError(
+      `Could not read ${baseName(source)}: ${error.message}`,
+      "read_failed",
+      { cause: error }
+    );
+  }
+}
+async function importYDoc(bytes, filename) {
+  try {
+    return await fileToYDoc(bytes, filename);
+  } catch (error) {
+    throw new ReviseError(
+      `${baseName(filename)} does not open: ${error.message}`,
+      "import_failed",
+      { cause: error }
+    );
+  }
+}
+function assertReadable(filename) {
+  if (!READABLE.test(filename)) {
+    throw new ReviseError(
+      `Cannot read ${baseName(filename)}. Supported: .docx, .md, .html, .odt, .rtf, .txt.`,
+      "unsupported_format"
+    );
+  }
+}
+function baseName(file) {
+  return file.split(/[/\\]/).pop() ?? file;
+}
+function stem(file) {
+  return baseName(file).replace(/\.[^.]+$/, "");
+}
+async function exportYDoc(ydoc, pkg, { format, mode = "review", title = "Document" }) {
+  if (format === "pdf")
+    return { bytes: await exportPdf(ydoc, title), outcome: null };
+  if (format === "docx") return exportSessionDocx(ydoc, pkg, mode);
+  return {
+    bytes: await exportDocument(ydoc, { format, mode, title }),
+    outcome: null
+  };
+}
+async function exportPdf(ydoc, title) {
+  const [{ serializeDocumentFormat }, { DocumentMutator }] = await Promise.all([
+    engineModules2.documentFormats(),
+    engineModules2.mutator()
+  ]);
+  const doc = DocumentMutator.materializeAcceptedSuggestions(
+    ydocToDocument2(ydoc)
+  );
+  const output = await serializeDocumentFormat(doc, "pdf", { title });
+  return typeof output === "string" ? new TextEncoder().encode(output) : new Uint8Array(await output.arrayBuffer());
+}
+var SNAPSHOT_MAGIC = "RVSNAP";
+var SNAPSHOT_SCHEMA = 1;
+function encodeSnapshot2(header, state, pkg) {
+  const json = new TextEncoder().encode(
+    JSON.stringify({
+      ...header,
+      schema: SNAPSHOT_SCHEMA,
+      stateBytes: state.length,
+      packageBytes: pkg?.length ?? 0
+    })
+  );
+  const magic = new TextEncoder().encode(SNAPSHOT_MAGIC);
+  const out = new Uint8Array(
+    magic.length + 4 + json.length + state.length + (pkg?.length ?? 0)
+  );
+  out.set(magic, 0);
+  new DataView(out.buffer).setUint32(magic.length, json.length);
+  out.set(json, magic.length + 4);
+  out.set(state, magic.length + 4 + json.length);
+  if (pkg) out.set(pkg, magic.length + 4 + json.length + state.length);
+  return out;
+}
+function decodeSnapshot(bytes) {
+  const magic = new TextDecoder().decode(
+    bytes.subarray(0, SNAPSHOT_MAGIC.length)
+  );
+  if (magic !== SNAPSHOT_MAGIC) {
+    return { header: null, state: bytes, pkg: null };
+  }
+  try {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const jsonLength = view.getUint32(SNAPSHOT_MAGIC.length);
+    const start = SNAPSHOT_MAGIC.length + 4;
+    const header = JSON.parse(
+      new TextDecoder().decode(bytes.subarray(start, start + jsonLength))
+    );
+    const valid = Number.isInteger(header.schema) && header.schema >= 1 && typeof header.documentId === "string" && (header.mode === "suggesting" || header.mode === "editing") && typeof header.title === "string" && (header.author === void 0 || typeof header.author === "string") && Number.isInteger(header.stateBytes) && header.stateBytes > 0 && Number.isInteger(header.packageBytes) && header.packageBytes >= 0 && start + jsonLength + header.stateBytes + header.packageBytes === bytes.length;
+    if (!valid && !(header.schema > SNAPSHOT_SCHEMA)) throw new Error("header");
+    if (header.schema > SNAPSHOT_SCHEMA) {
+      throw new ReviseError(
+        `This snapshot uses schema ${header.schema}; this version of revise reads up to ${SNAPSHOT_SCHEMA}. Upgrade revise.`,
+        "snapshot_too_new"
+      );
+    }
+    const stateStart = start + jsonLength;
+    const state = bytes.subarray(stateStart, stateStart + header.stateBytes);
+    const pkg = header.packageBytes ? bytes.subarray(
+      stateStart + header.stateBytes,
+      stateStart + header.stateBytes + header.packageBytes
+    ) : null;
+    if (state.length !== header.stateBytes || pkg && pkg.length !== header.packageBytes) {
+      throw new Error("truncated");
+    }
+    return { header, state, pkg };
+  } catch (error) {
+    if (error instanceof ReviseError) throw error;
+    throw new ReviseError(
+      "This snapshot is damaged or incomplete.",
+      "snapshot_corrupt",
+      {
+        cause: error
+      }
+    );
+  }
+}
+var documentCounter = 0;
+var ReviseDocument = class _ReviseDocument {
+  constructor(currentYDoc, currentSession, settings, originalPackage, ownsYDoc) {
+    this.currentYDoc = currentYDoc;
+    this.currentSession = currentSession;
+    this.settings = settings;
+    this.originalPackage = originalPackage;
+    this.ownsYDoc = ownsYDoc;
+    this.disposed = false;
+    this.queue = Promise.resolve();
+    // ── tools ────────────────────────────────────────────────────────────────
+    this.tools = {
+      /** Every editing tool's name, description, and JSON input schema. */
+      definitions: () => {
+        this.assertOpen();
+        return this.currentSession.tools.getDefinitions();
+      },
+      /** Run a known tool with typed input. Expected failures come back as
+       * `{ ok: false, error }`; nothing throws for a bad edit. */
+      call: (name, ...args) => this.serial(
+        async () => this.afterTool(
+          name,
+          await this.currentSession.tools.execute(name, ...args)
+        )
+      ),
+      /** Run a tool by name with untyped input (agent tool calls). Unknown
+       * tools and bad input come back as `{ ok: false, error }` too. */
+      run: (name, input = {}, options = {}) => this.serial(async () => {
+        const definition = this.currentSession.tools.getDefinitions().find((tool) => tool.name === name);
+        if (!definition) {
+          return {
+            ok: false,
+            error: {
+              code: "unknown_tool",
+              message: `Unknown tool "${name}".`
+            }
+          };
+        }
+        const required = definition.inputSchema.required ?? [];
+        const filled = required.includes("context_notes") && input.context_notes === void 0 ? { ...input, context_notes: "N/A" } : input;
+        return this.afterTool(
+          name,
+          await this.currentSession.tools.executeDynamic(
+            name,
+            filled,
+            options.direct ? { directMode: true } : void 0
+          )
+        );
+      })
+    };
+  }
+  /** Open a file (path) or bytes. Word files keep their original package,
+   * so untouched content exports byte for byte. */
+  static async open(source, options = {}) {
+    const { bytes, filename } = await readSource(source);
+    assertReadable(filename);
+    const ydoc = await importYDoc(bytes, filename);
+    return _ReviseDocument.build(ydoc, {
+      mode: PLAIN_FORMATS.test(filename) ? "editing" : "suggesting",
+      ...options,
+      title: stem(filename),
+      package: /\.docx$/i.test(filename) ? bytes : null,
+      owned: true
+    });
+  }
+  /** Start a document from the HTML the tools read and write (headings,
+   * `data-style-id="Title"`, lists, tables), or from Markdown. */
+  static async create(content = {}, options = {}) {
+    let ydoc;
+    if (content.html !== void 0) {
+      await installDomShims();
+      const { AgentHtmlConverter } = await engineModules2.agentHtml();
+      const body = /<body[^>]*>([\s\S]*)<\/body>/i.exec(content.html)?.[1] ?? content.html;
+      ydoc = createReviseYDoc2();
+      seedDocRootWithClaim2(ydoc, AgentHtmlConverter.fromAgentHtml(body));
+    } else {
+      const markdown = content.markdown ?? (content.title ? `# ${content.title}
+` : "\n");
+      ydoc = await importYDoc(new TextEncoder().encode(markdown), "new.md");
+    }
+    return _ReviseDocument.build(ydoc, {
+      mode: "editing",
+      ...options,
+      title: content.title ?? "Document",
+      package: null,
+      owned: true
+    });
+  }
+  /** Restore a document from `snapshot()` (or a bare Y.js update). Options
+   * override what the snapshot recorded. */
+  static async restore(snapshot2, options = {}) {
+    const { header, state, pkg } = decodeSnapshot(snapshot2);
+    let ydoc;
+    try {
+      ydoc = decodeYDoc(state);
+    } catch (error) {
+      throw new ReviseError("This snapshot is damaged.", "snapshot_corrupt", {
+        cause: error
+      });
+    }
+    return _ReviseDocument.build(ydoc, {
+      ...header ? {
+        documentId: header.documentId,
+        mode: header.mode,
+        title: header.title,
+        ...header.author ? { author: header.author } : {}
+      } : {},
+      ...options,
+      package: pkg,
+      owned: true
+    });
+  }
+  /** Wrap an existing Revise Y.Doc, e.g. one shared with an editor. The
+   * Y.Doc stays yours: `dispose()` leaves it intact, and `reload()` is not
+   * available (it would have to replace it). */
+  static async fromYDoc(ydoc, options = {}) {
+    let pkg = options.package;
+    if (pkg === void 0) {
+      const { loadDocxCarrier } = await engineModules2.docxGraft();
+      pkg = loadDocxCarrier(ydoc)?.bytes ?? null;
+    }
+    return _ReviseDocument.build(ydoc, {
+      ...options,
+      package: pkg,
+      owned: false
+    });
+  }
+  static async build(ydoc, options) {
+    const { package: pkg, owned, ...rest } = options;
+    const settings = {
+      ...rest,
+      documentId: rest.documentId ?? `revise-${Date.now()}-${++documentCounter}`,
+      mode: rest.mode ?? "suggesting",
+      title: rest.title ?? "Document"
+    };
+    return new _ReviseDocument(
+      ydoc,
+      await _ReviseDocument.startSession(ydoc, settings),
+      settings,
+      pkg ?? null,
+      owned
+    );
+  }
+  static async startSession(ydoc, settings) {
+    (await engineModules2.serverSession()).requireDocxRoundTrip(ydoc);
+    return createServerDocumentSession(ydoc, {
+      documentId: settings.documentId,
+      mode: settings.mode,
+      ...settings.author ? { agentName: settings.author } : {},
+      ...settings.images ? { images: settings.images } : {}
+    });
+  }
+  assertOpen() {
+    if (this.disposed) {
+      throw new ReviseError("This document was disposed.", "disposed");
+    }
+  }
+  /** Run `work` after every operation already queued on this document. */
+  serial(work) {
+    if (this.disposed) {
+      return Promise.reject(
+        new ReviseError("This document was disposed.", "disposed")
+      );
+    }
+    const run = this.queue.then(() => {
+      this.assertOpen();
+      return work();
+    });
+    this.queue = run.catch(() => void 0);
+    return run;
+  }
+  /** The live document model. Shared with `@reviseio/editor`. */
+  get ydoc() {
+    return this.currentYDoc;
+  }
+  /** The low-level tool session behind `tools`: an escape hatch for what
+   * the methods here don't cover. */
+  get session() {
+    return this.currentSession;
+  }
+  get mode() {
+    return this.currentSession.getMode();
+  }
+  /** Switch between tracked changes ("suggesting") and direct edits. */
+  setMode(mode) {
+    return this.serial(() => {
+      if (mode === "suggesting") this.currentSession.setSuggestingMode();
+      else this.currentSession.setEditingMode();
+      this.settings.mode = mode;
+    });
+  }
+  get author() {
+    return this.settings.author;
+  }
+  get documentId() {
+    return this.settings.documentId;
+  }
+  /** The original Word package that export grafts onto, if any. */
+  get package() {
+    return this.originalPackage;
+  }
+  /** The complete document (versioned; includes the original Word package)
+   * to store or hand to `@reviseio/editor`, as of every operation queued
+   * before this call. Restore with `restore()`. */
+  snapshot() {
+    return this.serial(
+      () => encodeSnapshot2(
+        {
+          documentId: this.settings.documentId,
+          mode: this.mode,
+          ...this.settings.author ? { author: this.settings.author } : {},
+          title: this.settings.title
+        },
+        encodeYDoc(this.currentYDoc),
+        this.originalPackage
+      )
+    );
+  }
+  /** An opaque value that changes whenever the document does (including
+   * edits that only delete, which a state vector misses). */
+  version() {
+    this.assertOpen();
+    return Y.encodeSnapshot(Y.snapshot(this.currentYDoc));
+  }
+  /**
+   * Re-read the document from new bytes (it changed elsewhere). Block ids
+   * carry over only where identity is provable (Word's paragraph ids, or
+   * identical content); `changedIds` lists kept ids whose content changed,
+   * so earlier reads of them are stale. Replaces the Y.Doc, so it is not
+   * available on a document made with `fromYDoc`.
+   */
+  reload(bytes, filename) {
+    return this.serial(async () => {
+      if (!this.ownsYDoc) {
+        throw new ReviseError(
+          "reload() would replace a Y.Doc you own (fromYDoc). Open a new document instead.",
+          "borrowed_ydoc"
+        );
+      }
+      const fresh = await relearn(this.currentYDoc, bytes, filename);
+      const session = await _ReviseDocument.startSession(
+        fresh.ydoc,
+        this.settings
+      );
+      this.currentSession.dispose();
+      this.currentYDoc.destroy();
+      this.currentYDoc = fresh.ydoc;
+      this.currentSession = session;
+      if (/\.docx$/i.test(filename)) this.originalPackage = bytes;
+      return {
+        idsKept: fresh.idsKept,
+        idsNew: fresh.idsNew,
+        changedIds: fresh.changedIds,
+        removedIds: fresh.removedIds
+      };
+    });
+  }
+  /** Start the tool session over: forget what the agent has read and
+   * searched (e.g. after the host compacts its transcript). */
+  resetToolContext() {
+    return this.serial(async () => {
+      const session = await _ReviseDocument.startSession(
+        this.currentYDoc,
+        this.settings
+      );
+      this.currentSession.dispose();
+      this.currentSession = session;
+    });
+  }
+  /** Release the tool session. The document can't be used afterwards; a
+   * Y.Doc it created is destroyed, one passed to fromYDoc is left alone. */
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.currentSession.dispose();
+    if (this.ownsYDoc) this.currentYDoc.destroy();
+  }
+  /** The document's title for exports: its saved title property (dc:title
+   * in a .docx, or set_title's), else the name it was opened under. */
+  title() {
+    const core = this.currentYDoc.getMap("metadata").get("coreProperties");
+    return typeof core?.title === "string" && core.title.trim() ? core.title : this.settings.title;
+  }
+  /** set_title renames the document in the editor. In a file, the title is
+   * the document property (docProps/core.xml in a .docx, the PDF title), so
+   * it is saved there too; without this, the tool reported success and the
+   * saved file kept its old title. */
+  afterTool(name, result) {
+    if (name !== "set_title" || !result.ok) return result;
+    const metadata = this.currentYDoc.getMap("metadata");
+    const title = metadata.get("title");
+    if (typeof title !== "string") return result;
+    const core = metadata.get("coreProperties");
+    this.currentYDoc.transact(() => {
+      metadata.set("coreProperties", {
+        ...core && typeof core === "object" ? core : {},
+        title
+      });
+    });
+    this.settings.title = title;
+    return result;
+  }
+  // ── reading ──────────────────────────────────────────────────────────────
+  /** Sections with their block ranges and word counts. */
+  outline(options = {}) {
+    return this.serial(async () => {
+      const measured = await this.currentSession.tools.call(
+        "measure_document",
+        {
+          include_sections: true,
+          section_limit: options.limit ?? 200,
+          section_offset: options.offset ?? 0
+        }
+      );
+      return measured.data;
+    });
+  }
+  /** Blocks, words, pending changes, and how faithfully it exports to Word. */
+  status() {
+    return this.serial(async () => {
+      const measured = await this.currentSession.tools.call(
+        "measure_document",
+        {}
+      );
+      return {
+        blocks: measured.data.totalBlocks,
+        words: measured.data.wordCount,
+        pendingSuggestions: this.currentSession.listSuggestions().length,
+        fidelity: this.originalPackage ? await ydocSourceFidelity2(this.currentYDoc) : null
+      };
+    });
+  }
+  /** Text-bearing blocks matching a pattern (paragraphs, headings, list
+   * items, table-cell paragraphs), with their ids. */
+  grep(pattern, options = {}) {
+    this.assertOpen();
+    const matcher = typeof pattern === "string" ? new RegExp(
+      pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"),
+      options.ignoreCase ? "gi" : "g"
+    ) : new RegExp(
+      pattern.source,
+      pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`
+    );
+    return textBlocks(ydocToDocument2(this.currentYDoc)).map((block) => ({
+      id: block.id,
+      blockIndex: block.topIndex,
+      count: (block.text.match(matcher) ?? []).length,
+      text: block.text
+    })).filter((hit) => hit.count > 0);
+  }
+  /** What the document holds, in one glance: page setup, header and footer
+   * text with live fields, title, headings, lists, tables, review state. */
+  summary() {
+    return this.serial(
+      () => documentSummary(this.currentYDoc, this.currentSession)
+    );
+  }
+  // ── editing ──────────────────────────────────────────────────────────────
+  /** Replace every exact occurrence, block by block (tracked changes in
+   * suggesting mode). `ids` limits it to those blocks. Replacing text with
+   * itself changes nothing and is not a failure. */
+  replaceText(find, replace, options = {}) {
+    return this.serial(async () => {
+      if (!find) {
+        throw new ReviseError("Nothing to find: give some text.", "usage");
+      }
+      const targets = textBlocks(ydocToDocument2(this.currentYDoc)).filter(
+        (block) => block.text.includes(find) && (!options.ids || options.ids.includes(block.id))
+      );
+      if (find === replace) {
+        return {
+          replaced: 0,
+          blocks: targets.map((t) => t.id),
+          changeIds: [],
+          failures: []
+        };
+      }
+      const failures = [];
+      const changeIds = [];
+      let replaced = 0;
+      for (const target of targets) {
+        await this.currentSession.tools.executeDynamic("read_specific_blocks", {
+          block_ids: [target.id],
+          context_notes: "N/A"
+        });
+        const result = await this.currentSession.tools.executeDynamic(
+          "replace",
+          {
+            id: target.id,
+            replacements: [{ find, replace, occurrence: "all" }],
+            context_notes: "N/A"
+          }
+        );
+        if ("error" in result) {
+          if (!/^No changes detected/i.test(result.error.message)) {
+            failures.push({
+              blockId: target.id,
+              code: result.error.code,
+              message: result.error.message
+            });
+          }
+        } else {
+          replaced += target.text.split(find).length - 1;
+          changeIds.push(...result.value.suggestionIds ?? []);
+        }
+      }
+      return {
+        replaced,
+        blocks: targets.map((t) => t.id),
+        changeIds,
+        failures
+      };
+    });
+  }
+  // ── review ───────────────────────────────────────────────────────────────
+  /** Pending tracked changes with where they are and what they do. */
+  changes(filter = {}) {
+    return this.serial(() => this.filteredChanges(filter));
+  }
+  async filteredChanges(filter = {}) {
+    return (await describeChanges(this.currentYDoc, this.currentSession)).filter((c) => filter.section ? inSection(c, filter.section) : true).filter(
+      (c) => filter.exceptSection ? !inSection(c, filter.exceptSection) : true
+    );
+  }
+  /** The tracked changes a selection would settle, without settling them. */
+  preview(selection) {
+    return this.serial(async () => {
+      const changes = await this.filteredChanges();
+      const ids = await this.selectedIds(selection, changes);
+      return ids === "all" ? changes : changes.filter((c) => ids.includes(c.id));
+    });
+  }
+  accept(selection) {
+    return this.serial(() => this.settle(selection, true));
+  }
+  reject(selection) {
+    return this.serial(() => this.settle(selection, false));
+  }
+  async selectedIds(selection, known) {
+    const { section, exceptSection, all } = selection;
+    const ids = selection.ids ?? [];
+    const kinds = [
+      ids.length > 0,
+      Boolean(all),
+      Boolean(section || exceptSection)
+    ];
+    if (kinds.filter(Boolean).length !== 1) {
+      throw new ReviseError(
+        "Select tracked changes one way: ids, all, or a section filter (section/exceptSection).",
+        "invalid_selection"
+      );
+    }
+    if (section || exceptSection) {
+      const changes = known ?? await this.filteredChanges();
+      return changes.filter((c) => section ? inSection(c, section) : true).filter((c) => exceptSection ? !inSection(c, exceptSection) : true).map((c) => c.id);
+    }
+    return all ? "all" : ids;
+  }
+  async settle(selection, accept) {
+    const ids = await this.selectedIds(selection);
+    const session = this.currentSession;
+    if (ids === "all") {
+      return accept ? session.acceptAllSuggestions() : session.rejectAllSuggestions();
+    }
+    if (!ids.length) return { resolved: [], missing: [], unresolved: [] };
+    return accept ? session.acceptSuggestions(ids) : session.rejectSuggestions(ids);
+  }
+  /**
+   * What the pending tracked changes do to the text (before → after), or
+   * what changed since `baseline` (a snapshot).
+   */
+  diff(baseline) {
+    return this.serial(async () => {
+      let before;
+      if (baseline) {
+        before = decodeYDoc(decodeSnapshot(baseline).state);
+      } else {
+        before = decodeYDoc(encodeYDoc(this.currentYDoc));
+        const copy = await createServerDocumentSession(before, {
+          documentId: `${this.settings.documentId}-diff`
+        });
+        copy.rejectAllSuggestions();
+        copy.dispose();
+      }
+      return textDiff(
+        await markdownOf(before),
+        await markdownOf(this.currentYDoc)
+      );
+    });
+  }
+  // ── output ───────────────────────────────────────────────────────────────
+  /** Write the document in a format. Reports what the output actually
+   * contains: its pending changes, and for .docx how much of the original
+   * file was carried over byte for byte. */
+  export(options) {
+    return this.serial(async () => {
+      options = { ...options, format: exportFormat(options.format) };
+      const mode = options.format === "docx" ? options.mode ?? "review" : "final";
+      const pending = this.currentSession.listSuggestions().length;
+      const { bytes, outcome } = await exportYDoc(
+        this.currentYDoc,
+        this.originalPackage,
+        { title: this.title(), ...options, mode }
+      );
+      const warnings = [];
+      if (options.format !== "docx" && (options.mode ?? "review") === "review" && pending) {
+        warnings.push(
+          `A .${options.format === "markdown" ? "md" : options.format} file can't hold tracked changes: it shows the ${pending} pending change${pending === 1 ? "" : "s"} accepted.`
+        );
+      }
+      if (outcome?.method === "regenerated") {
+        if (outcome.fallbackCode === "no-original-package") {
+          warnings.push(
+            "The original Word file isn't available (e.g. restored from a bare Y.js state), so the whole .docx was written fresh."
+          );
+        } else if (outcome.fallbackCode !== "not-from-docx") {
+          warnings.push(
+            `Couldn't carry untouched content over from the original Word file (${outcome.fallbackCode}); the whole .docx was written fresh.`
+          );
+        }
+      }
+      return {
+        bytes,
+        format: options.format,
+        mode,
+        pendingTrackedChanges: mode === "final" ? 0 : pending,
+        fidelity: outcome,
+        warnings
+      };
+    });
+  }
+  /** Pages as images, laid out exactly as the editor lays them out. */
+  renderPages(options = {}) {
+    return this.serial(async () => {
+      try {
+        const { renderPages } = await import("./render-QD5VWKSV.js");
+        return await renderPages(
+          this.currentYDoc,
+          this.settings.documentId,
+          options
+        );
+      } catch (error) {
+        if (error instanceof ReviseError) throw error;
+        throw new ReviseError(
+          `Rendering failed: ${error.message}`,
+          "render_failed",
+          { cause: error }
+        );
+      }
+    });
+  }
+};
+async function seedYDoc(ydoc, source) {
+  const { bytes, filename } = await readSource(source);
+  assertReadable(filename);
+  return seedYDocFromFile(ydoc, bytes, filename);
+}
+async function compare(originalSource, revisedSource, options = {}) {
+  const [originalFile, revisedFile] = await Promise.all([
+    readSource(originalSource),
+    readSource(revisedSource)
+  ]);
+  assertReadable(originalFile.filename);
+  assertReadable(revisedFile.filename);
+  const [original, revised] = await Promise.all([
+    parseDocument2(originalFile.bytes, originalFile.filename),
+    parseDocument2(revisedFile.bytes, revisedFile.filename)
+  ]);
+  const author = options.author ?? baseName(revisedFile.filename);
+  const { compareDocuments } = await engineModules2.compare();
+  const comparison = compareDocuments(original, revised, {
+    authorName: author
+  });
+  if (!comparison) {
+    throw new ReviseError(
+      "These documents are too large to compare.",
+      "too_large"
+    );
+  }
+  const ydoc = createReviseYDoc2();
+  seedDocRootWithClaim2(ydoc, comparison.doc);
+  const isDocx = /\.docx$/i.test(revisedFile.filename);
+  if (comparison.doc.docxSource?.sourceHash && isDocx) {
+    const { storeDocxCarrier } = await engineModules2.docxGraft();
+    await storeDocxCarrier(ydoc, revisedFile.bytes, {
+      hash: comparison.doc.docxSource.sourceHash
+    });
+  }
+  const document = await ReviseDocument.restore(
+    encodeSnapshot2(
+      {
+        documentId: options.documentId ?? `revise-compare-${Date.now()}`,
+        mode: options.mode ?? "suggesting",
+        author,
+        title: stem(revisedFile.filename)
+      },
+      encodeYDoc(ydoc),
+      isDocx ? revisedFile.bytes : null
+    ),
+    options.images ? { images: options.images } : {}
+  );
+  const plainOf = async (y) => new TextDecoder().decode(await exportDocument(y, { format: "txt", mode: "final" })).replace(/\s+/g, " ").trim();
+  const redline = isDocx ? await fileToYDoc(
+    (await exportSessionDocx(document.ydoc, document.package)).bytes,
+    "redline.docx"
+  ) : decodeYDoc(encodeYDoc(document.ydoc));
+  const rejected = decodeYDoc(encodeYDoc(redline));
+  const rejecter = await createServerDocumentSession(rejected, {
+    documentId: `${document.documentId}-verify`
+  });
+  rejecter.rejectAllSuggestions();
+  rejecter.dispose();
+  const [acceptedText, rejectedText, revisedText, originalText] = await Promise.all([
+    plainOf(redline),
+    plainOf(rejected),
+    plainOf(await fileToYDoc(revisedFile.bytes, revisedFile.filename)),
+    plainOf(await fileToYDoc(originalFile.bytes, originalFile.filename))
+  ]);
+  return {
+    document,
+    stats: comparison.stats,
+    untrackedRegions: comparison.untrackedRegions,
+    verified: {
+      acceptAllGivesRevised: acceptedText === revisedText,
+      rejectAllGivesOriginal: rejectedText === originalText
+    }
+  };
+}
+async function convert(source, format, options = {}) {
+  format = exportFormat(format);
+  const { bytes, filename } = await readSource(source);
+  assertReadable(filename);
+  const ydoc = await importYDoc(bytes, filename);
+  return format === "pdf" ? exportPdf(ydoc, stem(filename)) : exportDocument(ydoc, {
+    format,
+    mode: options.mode ?? "review",
+    title: stem(filename)
+  });
+}
+var EXPORT_FORMATS = ["docx", "pdf", "markdown", "html", "txt"];
+function exportFormat(format) {
+  const name = String(format).toLowerCase();
+  if (name === "md") return "markdown";
+  if (!EXPORT_FORMATS.includes(name)) {
+    throw new ReviseError(
+      `Unknown export format "${format}". Use one of: ${EXPORT_FORMATS.join(", ")}.`,
+      "unsupported_format"
+    );
+  }
+  return name;
+}
+function textBlocks(doc) {
+  const out = [];
+  const textOf = (node) => (node.children ?? []).map((child) => {
+    const c = child;
+    return c.type === "text" && !c.marks?.deletion ? c.text ?? "" : "";
+  }).join("");
+  doc.children.forEach((block, topIndex) => {
+    const visit = (node) => {
+      const n = node;
+      if (!n || typeof n !== "object") return;
+      if ((n.type === "paragraph" || n.type === "list-item") && n.id) {
+        out.push({ id: n.id, text: textOf(n), topIndex });
+        return;
+      }
+      n.children?.forEach(visit);
+    };
+    visit(block);
+  });
+  return out;
+}
+async function describeChanges(ydoc, session) {
+  const records = session.listSuggestions();
+  const doc = ydocToDocument2(ydoc);
+  const measured = await session.tools.call("measure_document", {
+    include_sections: true,
+    section_limit: 1e3
+  });
+  const sections = measured.data.sections ?? [];
+  const positionOf = new Map(
+    doc.children.map((block, index) => [block.id, index])
+  );
+  const starts = sections.map((s) => ({ title: s.title, at: positionOf.get(s.startBlockId) })).filter((s) => s.at !== void 0).sort((a, b) => a.at - b.at);
+  const sectionAt = (index) => {
+    let title;
+    for (const start of starts) {
+      if (start.at > index) break;
+      title = start.title;
+    }
+    return title;
+  };
+  const found = /* @__PURE__ */ new Map();
+  doc.children.forEach((block, blockIndex) => {
+    const visit = (node) => {
+      if (!node || typeof node !== "object") return;
+      const n = node;
+      const id = n.marks?.suggestionId ?? n.suggestionId ?? n.structuralSuggestionId;
+      if (id) {
+        const entry = found.get(id) ?? {
+          blockIndex,
+          blockId: block.id ?? "",
+          deleted: "",
+          inserted: ""
+        };
+        if (n.type === "text") {
+          if (n.marks?.deletion) entry.deleted += n.text ?? "";
+          else if (n.marks?.insertion) entry.inserted += n.text ?? "";
+        }
+        found.set(id, entry);
+      }
+      n.children?.forEach(visit);
+    };
+    visit(block);
+  });
+  return records.map((record) => {
+    const at = found.get(record.id);
+    const blockIndex = at?.blockIndex ?? (record.blockId ? positionOf.get(record.blockId) : void 0) ?? (record.tableId ? positionOf.get(record.tableId) : void 0);
+    return {
+      id: record.id,
+      type: record.type ?? "text",
+      author: record.agentName ?? record.authorType ?? "unknown",
+      ...at?.blockId || record.blockId ? { blockId: at?.blockId || record.blockId } : {},
+      ...blockIndex !== void 0 ? { blockIndex, section: sectionAt(blockIndex) } : {},
+      deleted: at?.deleted ?? "",
+      inserted: at?.inserted ?? ""
+    };
+  });
+}
+function inSection(entry, query) {
+  if (!entry.section) return false;
+  const title = entry.section.trim().toLowerCase();
+  const q = query.trim().toLowerCase().replace(/\.$/, "");
+  if (/^[\d.]+$/.test(q)) {
+    return new RegExp(`^${q.replace(/\./g, "\\.")}(?:[.\\s)]|$)`).test(title);
+  }
+  return title.includes(q);
+}
+async function markdownOf(ydoc) {
+  const bytes = await exportDocument(ydoc, {
+    format: "markdown",
+    mode: "final"
+  });
+  return new TextDecoder().decode(bytes);
+}
+function lcsPairs(a, b) {
+  let head = 0;
+  while (head < a.length && head < b.length && a[head] === b[head]) head += 1;
+  let tail = 0;
+  while (tail < a.length - head && tail < b.length - head && a[a.length - 1 - tail] === b[b.length - 1 - tail]) {
+    tail += 1;
+  }
+  const pairs = [];
+  for (let k = 0; k < head; k += 1) pairs.push([k, k]);
+  const midA = a.slice(head, a.length - tail);
+  const midB = b.slice(head, b.length - tail);
+  if (midA.length * midB.length <= 4e6) {
+    for (const [i, j] of lcsTable(midA, midB)) pairs.push([i + head, j + head]);
+  }
+  for (let k = tail; k > 0; k -= 1) {
+    pairs.push([a.length - k, b.length - k]);
+  }
+  return pairs;
+}
+function lcsTable(a, b) {
+  const n = a.length;
+  const m = b.length;
+  const table = new Uint32Array((n + 1) * (m + 1));
+  for (let i2 = n - 1; i2 >= 0; i2 -= 1) {
+    for (let j2 = m - 1; j2 >= 0; j2 -= 1) {
+      table[i2 * (m + 1) + j2] = a[i2] === b[j2] ? table[(i2 + 1) * (m + 1) + j2 + 1] + 1 : Math.max(table[(i2 + 1) * (m + 1) + j2], table[i2 * (m + 1) + j2 + 1]);
+    }
+  }
+  const pairs = [];
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (a[i] === b[j]) {
+      pairs.push([i, j]);
+      i += 1;
+      j += 1;
+    } else if (table[(i + 1) * (m + 1) + j] >= table[i * (m + 1) + j + 1]) {
+      i += 1;
+    } else {
+      j += 1;
+    }
+  }
+  return pairs;
+}
+function wordDiff(before, after) {
+  const a = before.split(/(\s+)/);
+  const b = after.split(/(\s+)/);
+  if (a.length * b.length > 4e6) return `[-${before}-]{+${after}+}`;
+  const pairs = lcsPairs(a, b);
+  let i = 0;
+  let j = 0;
+  let output = "";
+  const flush = (ai, bj) => {
+    const removed = a.slice(i, ai).join("");
+    const added = b.slice(j, bj).join("");
+    if (removed) output += `[-${removed}-]`;
+    if (added) output += `{+${added}+}`;
+  };
+  for (const [ai, bj] of pairs) {
+    flush(ai, bj);
+    output += a[ai];
+    i = ai + 1;
+    j = bj + 1;
+  }
+  flush(a.length, b.length);
+  return output;
+}
+function textDiff(before, after) {
+  const split = (s) => s.split(/\n+/).filter((line) => line.trim());
+  const a = split(before);
+  const b = split(after);
+  const pairs = lcsPairs(a, b);
+  const hunks = [];
+  let changed = 0;
+  let i = 0;
+  let j = 0;
+  const flush = (ai, bj) => {
+    const removed = a.slice(i, ai);
+    const added = b.slice(j, bj);
+    const paired = Math.min(removed.length, added.length);
+    for (let k = 0; k < paired; k += 1) {
+      hunks.push(`~ ${wordDiff(removed[k], added[k])}`);
+      changed += 1;
+    }
+    for (const line of removed.slice(paired)) {
+      hunks.push(`- ${line}`);
+      changed += 1;
+    }
+    for (const line of added.slice(paired)) {
+      hunks.push(`+ ${line}`);
+      changed += 1;
+    }
+  };
+  for (const [ai, bj] of pairs) {
+    flush(ai, bj);
+    i = ai + 1;
+    j = bj + 1;
+  }
+  flush(a.length, b.length);
+  return { text: hunks.join("\n"), changed };
+}
+async function documentSummary(ydoc, session) {
+  const doc = ydocToDocument2(ydoc);
+  const { resolvePageLayoutSettings, getPageDimensionsPx } = await engineModules2.pageLayout();
+  const layout = resolvePageLayoutSettings(doc.pageLayout);
+  const { pageWidth, pageHeight } = getPageDimensionsPx(layout);
+  const inches = (px) => Number((px / 96).toFixed(2));
+  const margins = [
+    layout.marginTopPx,
+    layout.marginRightPx,
+    layout.marginBottomPx,
+    layout.marginLeftPx
+  ].map(inches);
+  const measured = await session.tools.call("measure_document", {});
+  const textWithFields = (node) => {
+    const n = node;
+    if (n?.type === "text") {
+      const field = n.marks?.field?.toLowerCase();
+      if (field) {
+        return field === "numpages" || field === "pages" ? "{PAGES}" : `{${field.toUpperCase()}}`;
+      }
+      return n.text ?? "";
+    }
+    return (n?.children ?? []).map(textWithFields).join(n?.type === "table-row" ? " | " : "");
+  };
+  const chrome = (doc.chrome ?? []).filter((block) => block.type === "header-footer").map((block) => {
+    const b = block;
+    return {
+      side: b.side,
+      slot: b.slot ?? "default",
+      text: textWithFields(block).replace(/\s+/g, " ").trim()
+    };
+  }).filter((c) => c.text);
+  let title;
+  const headings = {};
+  const lists = [];
+  const tables = [];
+  let images = 0;
+  for (const block of doc.children) {
+    if (block.type === "paragraph") {
+      if (block.styleId === "Title" && title === void 0) {
+        title = textWithFields(block);
+      }
+      if (block.heading) {
+        headings[`H${block.heading}`] = (headings[`H${block.heading}`] ?? 0) + 1;
+      }
+    } else if (block.type === "list") {
+      lists.push(block.children.length);
+    } else if (block.type === "table") {
+      tables.push(
+        `${block.children.length}\xD7${block.children[0]?.children.length ?? 0}`
+      );
+    } else if (block.type === "image") {
+      images += 1;
+    }
+  }
+  const pending = session.listSuggestions().length;
+  const data = {
+    pages: measured.data.pageCount,
+    words: measured.data.wordCount,
+    pageSize: layout.pageSize,
+    orientation: layout.orientation,
+    pageInches: [inches(pageWidth), inches(pageHeight)],
+    marginsInches: margins,
+    title,
+    headings,
+    lists,
+    tables,
+    images,
+    headersFooters: chrome,
+    pendingTrackedChanges: pending
+  };
+  const marginText = margins.every((m) => m === margins[0]) ? `${margins[0]} in` : `${margins.join("/")} in (top/right/bottom/left)`;
+  const parts = [
+    title ? `title "${title}"` : "",
+    Object.keys(headings).length ? `headings ${Object.entries(headings).map(([level, n]) => `${n}\xD7${level}`).join(", ")}` : "",
+    lists.length ? `${lists.length} list${lists.length > 1 ? "s" : ""} (${lists.join(", ")} items)` : "",
+    tables.length ? `${tables.length} table${tables.length > 1 ? "s" : ""} (${tables.join(", ")})` : "",
+    images ? `${images} image${images > 1 ? "s" : ""}` : ""
+  ].filter(Boolean);
+  const text = [
+    `${data.pages ?? "?"} page${data.pages === 1 ? "" : "s"}, ${measured.data.wordCount} words; ${layout.pageSize} ${layout.orientation} (${inches(pageWidth)} \xD7 ${inches(pageHeight)} in), margins ${marginText}.`,
+    ...parts.length ? [`Contents: ${parts.join("; ")}.`] : [],
+    ...chrome.map(
+      (c) => `${c.side[0].toUpperCase()}${c.side.slice(1)}${c.slot === "default" ? "" : ` (${c.slot})`}: ${c.text}`
+    ),
+    ...pending ? [`Pending tracked changes: ${pending}.`] : []
+  ].join("\n");
+  return { text, data };
+}
+
+// src/embed-sdk/lib/agent.ts
+function formatToolResult(result, maxChars = 1e5) {
+  if ("error" in result) {
+    return {
+      text: `error ${result.error.code}: ${result.error.message}`,
+      isError: true
+    };
+  }
+  const value = result.value;
+  const lines = [];
+  if (value.message) lines.push(value.message);
+  if (value.suggestionIds?.length) {
+    lines.push(`Tracked changes: ${value.suggestionIds.join(", ")}`);
+  }
+  if (value.data !== null && value.data !== void 0) {
+    const data = JSON.stringify(value.data);
+    if (data !== "{}" && data !== "[]") {
+      lines.push(
+        `data: ${data.length <= 4e3 ? data : compactData(value.data)}`
+      );
+    }
+  }
+  if (value.context?.html) lines.push("", value.context.html);
+  let text = lines.join("\n") || "Done.";
+  if (text.length > maxChars) {
+    text = `${text.slice(0, maxChars)}
+\u2026 (result cut at ${maxChars} characters; read fewer blocks at a time, e.g. a later index or specific ids)`;
+  }
+  return { text, isError: false };
+}
+function compactData(data) {
+  const summarize = (value, depth) => {
+    if (Array.isArray(value)) {
+      return value.length <= 5 && depth < 2 ? value.map((item) => summarize(item, depth + 1)) : `[${value.length} items]`;
+    }
+    if (value && typeof value === "object") {
+      if (depth >= 2) return "{\u2026}";
+      return Object.fromEntries(
+        Object.entries(value).map(([key, inner]) => [
+          key,
+          summarize(inner, depth + 1)
+        ])
+      );
+    }
+    return typeof value === "string" && value.length > 200 ? `${value.slice(0, 200)}\u2026` : value;
+  };
+  return `${JSON.stringify(summarize(data, 0))} (summarized; the full data is larger)`;
+}
+function agentTools(doc, options) {
+  const definitions = doc.tools.definitions().filter((d) => !options.include || options.include.includes(d.name)).filter((d) => !options.exclude?.includes(d.name));
+  const allowed = new Set(definitions.map((d) => d.name));
+  const tools = definitions.map((d) => {
+    switch (options.provider) {
+      case "anthropic":
+        return {
+          name: d.name,
+          description: d.description,
+          input_schema: { ...d.inputSchema, type: "object" }
+        };
+      case "openai":
+        return {
+          type: "function",
+          function: {
+            name: d.name,
+            description: d.description,
+            parameters: d.inputSchema
+          }
+        };
+      default:
+        return {
+          type: "function",
+          name: d.name,
+          description: d.description,
+          parameters: d.inputSchema,
+          strict: false
+        };
+    }
+  });
+  const run = async (name, rawInput) => {
+    if (!allowed.has(name)) {
+      return {
+        text: `error unknown_tool: There is no tool named "${name}".`,
+        isError: true
+      };
+    }
+    let input = rawInput;
+    if (typeof rawInput === "string") {
+      try {
+        input = rawInput.trim() ? JSON.parse(rawInput) : {};
+      } catch (error) {
+        return {
+          text: `error invalid_json: The arguments are not valid JSON (${error.message}).`,
+          isError: true
+        };
+      }
+    }
+    if (!input || typeof input !== "object" || Array.isArray(input)) {
+      return {
+        text: "error invalid_arguments: Tool arguments must be a JSON object.",
+        isError: true
+      };
+    }
+    return formatToolResult(
+      await doc.tools.run(name, input),
+      options.maxResultChars
+    );
+  };
+  const handle = async (call) => {
+    switch (options.provider) {
+      case "anthropic": {
+        const c = call;
+        const { text, isError } = await run(c.name, c.input);
+        return {
+          type: "tool_result",
+          tool_use_id: c.id,
+          content: text,
+          ...isError ? { is_error: true } : {}
+        };
+      }
+      case "openai": {
+        const c = call;
+        const { text } = await run(c.function.name, c.function.arguments);
+        return {
+          role: "tool",
+          tool_call_id: c.id,
+          content: text
+        };
+      }
+      default: {
+        const c = call;
+        const { text } = await run(c.name, c.arguments);
+        return {
+          type: "function_call_output",
+          call_id: c.call_id,
+          output: text
+        };
+      }
+    }
+  };
+  return {
+    tools,
+    handle,
+    version: () => doc.version(),
+    reset: () => doc.resetToolContext()
+  };
+}
+
+export {
+  relearn,
+  READABLE,
+  formatForPath,
+  exportYDoc,
+  ReviseDocument,
+  seedYDoc,
+  compare,
+  convert,
+  formatToolResult,
+  agentTools
+};