revise 3.1.7 → 4.0.1

package/chunks/chunk-SMTOJL2X.js

@@ -1,2436 +0,0 @@
-// 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 () => {
-      if (options.limit === void 0) {
-        return this.allSections(options.offset ?? 0);
-      }
-      const measured = await this.currentSession.tools.call(
-        "measure_document",
-        {
-          include_sections: true,
-          section_limit: options.limit,
-          section_offset: options.offset ?? 0
-        }
-      );
-      return measured.data;
-    });
-  }
-  /** measure_document with every section from `offset` on, page by page. */
-  async allSections(offset = 0) {
-    let data;
-    const sections = [];
-    let next = offset;
-    for (let page = 0; next !== null && page < 50; page++) {
-      const measured = await this.currentSession.tools.call("measure_document", {
-        include_sections: true,
-        section_limit: 100,
-        section_offset: next
-      });
-      data ??= measured.data;
-      sections.push(...measured.data.sections ?? []);
-      const after = measured.data.hasMoreSections ? measured.data.nextSectionOffset ?? null : null;
-      next = after !== null && after > next ? after : null;
-    }
-    return {
-      ...data,
-      sections,
-      hasMoreSections: false,
-      nextSectionOffset: void 0
-    };
-  }
-  /**
-   * The top-level blocks a selection names, in document order: block ids
-   * and `first..last` ranges (a nested id stands for the block holding it),
-   * a section (its heading's range, subsections included; "4,7,9" for
-   * several), or `count`
-   * blocks from `index`. Naming a block or section that doesn't exist is an
-   * error.
-   */
-  selectBlocks(selection) {
-    return this.serial(async () => {
-      const top = ydocToDocument2(this.currentYDoc).children;
-      const position = /* @__PURE__ */ new Map();
-      top.forEach((block, at2) => {
-        const visit = (node) => {
-          if (!node || typeof node !== "object") return;
-          const n = node;
-          if (typeof n.id === "string" && n.type !== "text") {
-            position.set(n.id, at2);
-          }
-          n.children?.forEach(visit);
-        };
-        visit(block);
-      });
-      const at = (id) => {
-        const found = position.get(id);
-        if (found === void 0) {
-          throw new ReviseError(`No block with id "${id}".`, "block_not_found");
-        }
-        return found;
-      };
-      const picked = /* @__PURE__ */ new Set();
-      const range = (from, to) => {
-        for (let i = from; i <= to; i++) picked.add(i);
-      };
-      for (const item of selection.blocks ? parseBlockQuery(selection.blocks) : []) {
-        if (typeof item === "string") {
-          picked.add(at(item));
-          continue;
-        }
-        const from = at(item.from);
-        const to = at(item.to);
-        if (from > to) {
-          throw new ReviseError(
-            `Block "${item.from}" comes after "${item.to}"; write the range first..last.`,
-            "invalid_selection"
-          );
-        }
-        range(from, to);
-      }
-      if (selection.section !== void 0) {
-        const measured = { data: await this.allSections() };
-        const sections = (measured.data.sections ?? []).map((s) => ({
-          title: s.title,
-          start: at(s.startBlockId),
-          end: at(s.endBlockId)
-        }));
-        const queries = /^[\d.\s]+(,[\d.\s]+)+$/.test(selection.section) ? selection.section.split(",").map((part) => part.trim()) : [selection.section];
-        for (const query of queries) {
-          const q = query.trim().toLowerCase();
-          const exact = sections.filter(
-            (s) => s.title.toLowerCase() === q || s.title.toLowerCase().replace(/^[\d.]+[.)]?\s+/, "") === q
-          );
-          const candidates = exact.length ? exact : sections.filter((s) => headingMatches(s.title, query));
-          const matched = candidates.filter(
-            (s) => !candidates.some(
-              (outer) => outer !== s && outer.start <= s.start && s.end <= outer.end && (outer.start < s.start || s.end < outer.end)
-            )
-          );
-          if (matched.length > 1) {
-            throw new ReviseError(
-              `"${query}" matches ${matched.length} headings: ${matched.map((s) => `"${s.title}"`).join(", ")}. Name one by its number or full title.`,
-              "section_ambiguous"
-            );
-          }
-          if (!matched.length) {
-            throw new ReviseError(
-              sections.length ? `No heading matches "${query}". Headings: ${sections.slice(0, 12).map((s) => `"${s.title}"`).join(", ")}${sections.length > 12 ? ", \u2026" : ""}.` : `No heading matches "${query}": the document has no headings. Select blocks by id instead.`,
-              "section_not_found"
-            );
-          }
-          range(matched[0].start, matched[0].end);
-        }
-      }
-      if (selection.count !== void 0) {
-        const from = selection.index ?? 0;
-        range(from, Math.min(top.length, from + selection.count) - 1);
-      }
-      return [...picked].sort((a, b) => a - b).map((i) => top[i].id);
-    });
-  }
-  /**
-   * Paragraphs that look like section headings but aren't styled as
-   * headings: short, entirely bold, and numbered like the document's real
-   * headings ("12. Overtime" between headings 11 and 13) with a number no
-   * heading has. Word documents often have one typed by hand.
-   */
-  unstyledHeadings() {
-    return this.serial(async () => {
-      const top = ydocToDocument2(this.currentYDoc).children;
-      const textOf = (block) => (block.children ?? []).map((node) => node.type === "text" ? node.text ?? "" : "").join("").trim();
-      const numberOf = (title) => {
-        const m = /^(\d+(?:\.\d+)*)([.)]?)\s+\S/.exec(title);
-        return m ? { number: m[1], mark: m[2] } : void 0;
-      };
-      const headings = top.filter((block) => block.heading !== void 0);
-      const used = /* @__PURE__ */ new Map();
-      for (const heading of headings) {
-        const n = numberOf(textOf(heading));
-        if (!n) continue;
-        const depth = n.number.split(".").length;
-        const entry = used.get(depth) ?? { numbers: /* @__PURE__ */ new Set(), mark: n.mark };
-        entry.numbers.add(n.number);
-        used.set(depth, entry);
-      }
-      const found = [];
-      top.forEach((block, blockIndex) => {
-        if (block.type !== "paragraph" || block.heading !== void 0) return;
-        const text = textOf(block);
-        const n = numberOf(text);
-        if (!n || text.length > 80) return;
-        const depth = n.number.split(".").length;
-        const siblings = used.get(depth);
-        if (!siblings || siblings.numbers.size < 2 || siblings.numbers.has(n.number) || siblings.mark !== n.mark) {
-          return;
-        }
-        const runs = (block.children ?? []).filter(
-          (node) => node.type === "text" && (node.text ?? "").trim()
-        );
-        if (!runs.length || !runs.every((node) => node.marks?.bold)) return;
-        found.push({ id: block.id, blockIndex, text, level: depth });
-      });
-      return found;
-    });
-  }
-  /**
-   * read/search HTML for a reader to look at, leaving out what goes without
-   * saying: in each paragraph or heading, spacing, line height, keep
-   * settings, and text size and color equal to what its paragraph style
-   * (data-style-id, else the default "Normal") already sets; in table
-   * cells, the default 1px border and 8px padding; and grid columns in
-   * tables with no merged cells. Every value left out is one the block
-   * gets anyway when it's written back without it. Starts with a comment
-   * saying so.
-   */
-  compactHtml(html) {
-    this.assertOpen();
-    const raw = ydocToDocument2(this.currentYDoc);
-    const styles = raw.stylesheet?.paragraphStyles ?? [];
-    const byId = new Map(styles.map((style) => [style.styleId, style]));
-    const normal = styles.find((style) => style.default);
-    const near = (value, want, unit = "") => {
-      if (want === void 0 || !value.endsWith(unit)) return false;
-      const n = Number(value.slice(0, value.length - unit.length));
-      return Number.isFinite(n) && Math.abs(n - want) < 0.01;
-    };
-    const sameColor = (value, want) => want !== void 0 && value.toLowerCase() === want.toLowerCase();
-    const restyle = (tag, drop) => tag.replace(/ style="([^"]*)"/, (_, style) => {
-      const left = style.split(";").map((d) => d.trim()).filter(Boolean).filter((d) => {
-        const at = d.indexOf(":");
-        return at < 0 || !drop(d.slice(0, at).trim(), d.slice(at + 1).trim());
-      });
-      return left.length ? ` style="${left.join("; ")}"` : "";
-    });
-    let changed = false;
-    let out = html.replace(/<(p|h[1-6])\b[^>]*>[\s\S]*?<\/\1>/g, (block) => {
-      const open = /^<[^>]*>/.exec(block)[0];
-      const id = / data-style-id="([^"]*)"/.exec(open)?.[1];
-      const style = id === void 0 ? normal : byId.get(id);
-      if (!style) return block;
-      const attrs = style.paragraphAttrs ?? {};
-      const marks = style.runMarks ?? {};
-      const text = (prop, value) => prop === "font-size" && near(value, marks.fontSize, "px") || prop === "color" && sameColor(value, marks.color);
-      const styled = id !== void 0 || /^<h[1-6]/.test(open);
-      const lean = restyle(
-        open,
-        (prop, value) => styled && (prop === "margin-top" && near(value, attrs.spaceBefore, "px") || prop === "margin-bottom" && near(value, attrs.spaceAfter, "px") || prop === "line-height" && near(value, attrs.lineSpacing) || prop === "break-after" && value === "avoid" && !!attrs.keepNext || prop === "break-inside" && value === "avoid" && !!attrs.keepLines) || text(prop, value)
-      );
-      const body = block.slice(open.length).replace(/<span\b[^>]*>/g, (span) => restyle(span, text));
-      const result = lean + body;
-      if (result !== block) changed = true;
-      return result;
-    });
-    out = out.replace(/<t[dh]\b[^>]*>/g, (td) => {
-      const lean = restyle(
-        td,
-        (prop, value) => prop === "border" && value === "1px solid #ccc" || prop === "padding" && value === "8px"
-      );
-      if (lean !== td) changed = true;
-      return lean;
-    });
-    out = out.replace(
-      /<table\b[^>]*>(?:(?!<table\b)[\s\S])*?<\/table>/g,
-      (table) => {
-        if (/ (colspan|rowspan)="/.test(table)) return table;
-        const lean = table.replace(/ data-grid-column="\d+"/g, "");
-        if (lean !== table) changed = true;
-        return lean;
-      }
-    );
-    out = out.replace(/<(table|t[dh])\b[^>]* data-borders=[^>]*>/g, (tag) => {
-      const lean = restyle(
-        tag,
-        (prop) => /^border(-(top|right|bottom|left))?$/.test(prop)
-      );
-      if (lean !== tag) changed = true;
-      return lean;
-    });
-    out = out.replace(
-      / ([\w-]+)="([^"]*&quot;[^"]*)"/g,
-      (whole, name, value) => {
-        if (value.includes("'") || value.includes("&#039;")) return whole;
-        changed = true;
-        return ` ${name}='${value.replace(/&quot;/g, '"')}'`;
-      }
-    );
-    if (!changed) return out;
-    const size = normal?.runMarks?.fontSize;
-    const note = `<!-- Defaults left out: what a block's style sets${size !== void 0 ? `, ${size}px text` : ""}, 1px cell borders, 8px cell padding. -->
-`;
-    return html.length - out.length > note.length ? note + out : html;
-  }
-  /** 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`
-    );
-    const view = options.view ?? "tracked";
-    return textBlocks(ydocToDocument2(this.currentYDoc)).map((block) => {
-      const matches = matchesIn(block.segments, matcher, view);
-      return {
-        id: block.id,
-        blockIndex: block.topIndex,
-        count: matches.length,
-        text: segmentsText(block.segments, view),
-        matches
-      };
-    }).filter((hit) => hit.count > 0);
-  }
-  /**
-   * HTML the read tools returned (`read_blocks_from_index`,
-   * `read_specific_blocks`), in a view. The tools read the accepted view;
-   * "tracked" marks pending changes as `<ins>`/`<del>` with
-   * `data-change-id` and `data-author`, and shows whole blocks a change
-   * deletes where they were; "original" shows the text before every change.
-   * Block ids are unchanged. The editing tools read `<ins>` as its text and
-   * ignore `<del>`, so tracked HTML pasted back edits the accepted text.
-   */
-  viewHtml(html, view) {
-    if (view === "accepted") return Promise.resolve(html);
-    return this.serial(async () => {
-      await installDomShims();
-      const { AgentHtmlConverter } = await engineModules2.agentHtml();
-      const raw = ydocToDocument2(this.currentYDoc);
-      const authors = new Map(
-        this.currentSession.listSuggestions().map((r) => [r.id, r.agentName ?? r.authorType ?? "unknown"])
-      );
-      return renderView(html, raw, view, authors, AgentHtmlConverter);
-    });
-  }
-  /** 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 occurrence everywhere: the body, tables, lists, page
-   * headers and footers, and footnotes and endnotes. Tracked changes in
-   * suggesting mode. Curly and straight quotes and non-breaking spaces match
-   * each other unless `exact`, and the replacement keeps the document's
-   * characters (see matchDocumentCharacters). Replacing text with itself
-   * changes nothing and is not a failure.
-   */
-  replaceAll(find, replace, options = {}) {
-    return this.serial(async () => {
-      if (!find) {
-        throw new ReviseError("Nothing to find: give some text.", "usage");
-      }
-      const only = options.blocks ?? options.ids;
-      const all = replaceTargets(ydocToDocument2(this.currentYDoc)).filter(
-        (block) => !only || only.includes(block.id)
-      );
-      const exactMatch = textMatcher(find, {
-        exact: options.exact,
-        ignoreCase: options.ignoreCase
-      });
-      const loosest = textMatcher(find, { ignoreCase: true });
-      const caseOnly = textMatcher(find, {
-        exact: options.exact,
-        ignoreCase: true
-      });
-      const targets = [];
-      const missed = /* @__PURE__ */ new Map();
-      for (const block of all) {
-        const matches = exactMatch(block.text);
-        if (matches.length) targets.push({ ...block, matches });
-        const left = [...matches];
-        for (const text of loosest(block.text)) {
-          const at = left.indexOf(text);
-          if (at >= 0) {
-            left.splice(at, 1);
-            continue;
-          }
-          const reason = caseOnly(text).length ? "case" : "characters";
-          const entry = missed.get(text) ?? { count: 0, reason };
-          entry.count += 1;
-          missed.set(text, entry);
-        }
-      }
-      const nearMisses = [...missed].map(([text, m]) => ({ text, ...m }));
-      const regions = {};
-      if (find === replace) {
-        return {
-          replaced: 0,
-          blocks: targets.map((t) => t.id),
-          regions,
-          changeIds: [],
-          failures: [],
-          nearMisses
-        };
-      }
-      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 distinct = [...new Set(target.matches)];
-        const result = await this.currentSession.tools.executeDynamic(
-          "replace",
-          {
-            id: target.id,
-            replacements: distinct.map((text) => ({
-              find: text,
-              replace: matchDocumentCharacters(find, text, 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.matches.length;
-          regions[target.region] = (regions[target.region] ?? 0) + target.matches.length;
-          changeIds.push(...result.value.suggestionIds ?? []);
-        }
-      }
-      return {
-        replaced,
-        blocks: targets.map((t) => t.id),
-        regions,
-        changeIds,
-        failures,
-        nearMisses
-      };
-    });
-  }
-  /** @deprecated The 3.0 name of `replaceAll`. */
-  replaceText(find, replace, options = {}) {
-    return this.replaceAll(find, replace, options);
-  }
-  /** The document as it was before every pending change, exported from
-   * a copy: this document keeps its changes. */
-  async exportOriginal(options) {
-    const copy = await _ReviseDocument.restore(await this.snapshot(), {
-      author: this.settings.author
-    });
-    try {
-      await copy.reject({ all: true });
-      const result = await copy.export({
-        ...options,
-        view: void 0,
-        mode: "final"
-      });
-      return { ...result, view: "original" };
-    } finally {
-      copy.dispose();
-    }
-  }
-  // ── review ───────────────────────────────────────────────────────────────
-  /** Pending tracked changes with where they are and what they do. */
-  changes(filter = {}) {
-    return this.serial(() => this.filteredChanges(filter));
-  }
-  async filteredChanges(filter = {}) {
-    return applyChangeFilter(
-      await describeChanges(this.currentYDoc, this.currentSession),
-      filter
-    );
-  }
-  /** 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, blocks, all } = selection;
-    const ids = selection.ids ?? [];
-    const filtered = Boolean(section || exceptSection || blocks?.length);
-    const kinds = [ids.length > 0, Boolean(all), filtered];
-    if (kinds.filter(Boolean).length !== 1) {
-      throw new ReviseError(
-        "Select tracked changes one way: ids, all, or filters (section, exceptSection, blocks).",
-        "invalid_selection"
-      );
-    }
-    if (filtered) {
-      return applyChangeFilter(
-        known ?? await describeChanges(this.currentYDoc, this.currentSession),
-        { section, exceptSection, blocks }
-      ).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. */
-  async export(options) {
-    const view = viewOfMode(options);
-    if (view === "original") return this.exportOriginal(options);
-    return this.serial(async () => {
-      options = {
-        ...options,
-        format: exportFormat(options.format),
-        mode: view === "accepted" ? "final" : options.mode
-      };
-      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,
-        view: mode === "final" ? "accepted" : "tracked",
-        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 view = viewOfMode(options);
-  if (view === "original") {
-    const doc = await ReviseDocument.open(source);
-    try {
-      return (await doc.export({ format, view })).bytes;
-    } finally {
-      doc.dispose();
-    }
-  }
-  if (view === "accepted") options = { mode: "final" };
-  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)
-  });
-}
-function viewOfMode(options) {
-  const { mode, view } = options;
-  if (view !== void 0 && !["tracked", "accepted", "original"].includes(view)) {
-    throw new ReviseError(
-      `Unknown view "${view}". Use tracked, accepted, or original.`,
-      "usage"
-    );
-  }
-  if (view && mode && mode === "final" !== (view !== "tracked")) {
-    throw new ReviseError(
-      `mode "${mode}" and view "${view}" disagree; give one of them.`,
-      "usage"
-    );
-  }
-  return view;
-}
-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 segmentsOf = (node) => {
-    const segments = [];
-    for (const child of node.children ?? []) {
-      const c = child;
-      if (c.type !== "text" || !c.text) continue;
-      const change = c.marks?.deletion ? "deleted" : c.marks?.insertion ? "inserted" : null;
-      const changeId = change ? c.marks?.suggestionId ?? null : null;
-      const last = segments[segments.length - 1];
-      if (last && last.change === change && last.changeId === changeId) {
-        last.text += c.text;
-      } else {
-        segments.push({ text: c.text, change, changeId });
-      }
-    }
-    return segments;
-  };
-  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, segments: segmentsOf(n), topIndex });
-        return;
-      }
-      n.children?.forEach(visit);
-    };
-    visit(block);
-  });
-  return out;
-}
-function replaceTargets(doc) {
-  const out = [];
-  const textOf = (node) => (node.children ?? []).map((child) => {
-    const c = child;
-    return c.type === "text" && !c.marks?.deletion ? c.text ?? "" : "";
-  }).join("");
-  const visit = (node, region) => {
-    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), region });
-      return;
-    }
-    n.children?.forEach((child) => visit(child, region));
-  };
-  doc.children.forEach((block) => visit(block, "body"));
-  for (const block of doc.chrome ?? []) {
-    block.children.forEach((column) => visit(column, block.side));
-  }
-  for (const note of doc.notes ?? []) {
-    const region = note.noteKind === "endnote" ? "endnote" : "footnote";
-    note.children.forEach((child) => visit(child, region));
-  }
-  return out;
-}
-var LOOSE_CHARACTERS = {
-  "\u2018": "'",
-  // ‘
-  "\u2019": "'",
-  // ’
-  "\u201A": "'",
-  // ‚
-  "\u201B": "'",
-  // ‛
-  "\u2032": "'",
-  // ′
-  "\u201C": '"',
-  // “
-  "\u201D": '"',
-  // ”
-  "\u201E": '"',
-  // „
-  "\u201F": '"',
-  // ‟
-  "\u2033": '"',
-  // ″
-  "\xA0": " ",
-  // no-break space
-  "\u202F": " ",
-  // narrow no-break space
-  "\u2007": " ",
-  // figure space
-  "\u2009": " ",
-  // thin space
-  "\u2011": "-",
-  // non-breaking hyphen
-  "\u2010": "-"
-  // hyphen
-};
-function fold(text, options) {
-  return Array.from(text, (char) => {
-    let c = options.exact ? char : LOOSE_CHARACTERS[char] ?? char;
-    if (options.ignoreCase) {
-      const lower = c.toLowerCase();
-      if (lower.length === c.length) c = lower;
-    }
-    return c;
-  });
-}
-function textMatcher(find, options) {
-  const needle = fold(find, options).join("");
-  return (text) => {
-    const chars = Array.from(text);
-    const hay = fold(text, options).join("");
-    const matches = [];
-    const starts = [];
-    let offset = 0;
-    for (const c of fold(text, options)) {
-      starts.push(offset);
-      offset += c.length;
-    }
-    let from = 0;
-    while (needle) {
-      const at = hay.indexOf(needle, from);
-      if (at < 0) break;
-      const first = starts.indexOf(at);
-      let last = first;
-      while (last < starts.length && starts[last] < at + needle.length) last++;
-      if (first >= 0) matches.push(chars.slice(first, last).join(""));
-      from = at + Math.max(needle.length, 1);
-    }
-    return matches;
-  };
-}
-function matchDocumentCharacters(find, matched, replace) {
-  const findChars = Array.from(find);
-  const matchedChars = Array.from(matched);
-  const out = Array.from(replace);
-  for (const plain of ["'", '"', " ", "-"]) {
-    const documentChars = findChars.map((c, i) => c === plain ? matchedChars[i] : void 0).filter((c) => c !== void 0);
-    if (documentChars.every((c) => c === plain)) continue;
-    const slots = out.flatMap((c, i) => c === plain ? [i] : []);
-    if (slots.length !== documentChars.length) continue;
-    slots.forEach((slot, n) => out[slot] = documentChars[n]);
-  }
-  return out.join("");
-}
-var shows = (segment, view) => view === "tracked" || segment.change === null || segment.change === "inserted" === (view === "accepted");
-function segmentsText(segments, view) {
-  return segments.filter((segment) => shows(segment, view)).map(
-    (segment) => view !== "tracked" || segment.change === null ? segment.text : segment.change === "deleted" ? `[-${segment.text}-]` : `{+${segment.text}+}`
-  ).join("");
-}
-function matchesIn(segments, matcher, view) {
-  const found = [];
-  const scan = (side, keep) => {
-    const places = [];
-    const owners = [];
-    let text = "";
-    let at = 0;
-    for (const segment of segments) {
-      if (shows(segment, side)) {
-        for (let i = 0; i < segment.text.length; i++) {
-          places.push(at + i);
-          owners.push(segment);
-        }
-        text += segment.text;
-      }
-      at += segment.text.length;
-    }
-    for (const match of text.matchAll(matcher)) {
-      if (!match[0]) continue;
-      const start = match.index ?? 0;
-      const touched = owners.slice(start, start + match[0].length).find((owner) => owner.change !== null);
-      const change = touched?.change ?? null;
-      if (!keep(change)) continue;
-      found.push({
-        text: match[0],
-        change,
-        changeId: touched?.changeId ?? null,
-        at: places[start]
-      });
-    }
-  };
-  if (view === "tracked") {
-    scan("accepted", (change) => change !== "deleted");
-    scan("original", (change) => change === "deleted");
-  } else {
-    scan(view, () => true);
-  }
-  return found.sort(
-    (a, b) => a.at - b.at || Number(b.change === "deleted") - Number(a.change === "deleted")
-  ).map(({ text, change, changeId }) => ({ text, change, changeId }));
-}
-var OPEN = "\uE000";
-var DELETED = "\uE001";
-var INSERTED = "\uE002";
-var CLOSE = "\uE003";
-var CHANGE_BASE = 57600;
-var SENTINEL_RUN = /([])([-])([\s\S]*?)/g;
-function renderView(html, raw, view, authors, AgentHtmlConverter) {
-  const ids = topLevelIds(html);
-  const blocks = [...raw.children, ...raw.notes ?? []];
-  const position = new Map(blocks.map((block, i) => [block.id, i]));
-  const known = ids.map((id) => position.get(id)).filter((at) => at !== void 0);
-  if (!known.length) return html;
-  const deleted = (block) => block !== void 0 && wholeBlockDeletion(block) !== null;
-  const shown = /* @__PURE__ */ new Set();
-  for (const at of known) {
-    shown.add(at);
-    for (let next = at + 1; next < blocks.length && deleted(blocks[next]); next++) {
-      shown.add(next);
-    }
-  }
-  const first = Math.min(...known);
-  if (blocks.slice(0, first).every((block) => deleted(block))) {
-    for (let at = 0; at < first; at++) shown.add(at);
-  }
-  const order = [...shown].sort((a, b) => a - b);
-  const changes = [];
-  const indexOf = (id) => {
-    let i = changes.indexOf(id);
-    if (i < 0) i = changes.push(id) - 1;
-    return String.fromCharCode(CHANGE_BASE + Math.min(i, 63743 - CHANGE_BASE));
-  };
-  const marked = (node, deletedBy) => {
-    if (!node || typeof node !== "object") return node;
-    const n = node;
-    if (n.type === "text" && n.text) {
-      const deletion = n.marks?.deletion || deletedBy && !n.marks?.insertion;
-      if (!deletion && !n.marks?.insertion) return node;
-      const id = n.marks?.suggestionId ?? deletedBy ?? "";
-      const kind = deletion ? DELETED : INSERTED;
-      return { ...n, text: `${OPEN}${kind}${indexOf(id)}${n.text}${CLOSE}` };
-    }
-    const structural = node;
-    const by = structural.structuralSuggestionKind === "delete" ? structural.structuralSuggestionId : deletedBy;
-    return Array.isArray(n.children) ? { ...n, children: n.children.map((child) => marked(child, by)) } : node;
-  };
-  const children = raw.children.length;
-  const markedBlocks = blocks.map((block) => marked(block));
-  const doc = {
-    ...raw,
-    children: markedBlocks.slice(0, children),
-    notes: raw.notes ? markedBlocks.slice(children) : raw.notes
-  };
-  const found = AgentHtmlConverter.extractSpecificBlocks(
-    doc,
-    order.map((at) => blocks[at].id)
-  ).foundBlocks;
-  const lines = [];
-  found.forEach((block, i) => {
-    const gap = i > 0 ? block.blockIndex - found[i - 1].blockIndex - 1 : 0;
-    if (gap > 0)
-      lines.push(`(${gap} ${gap === 1 ? "block" : "blocks"} omitted...)`);
-    const whole = view === "tracked" ? wholeBlockDeletion(blocks[block.blockIndex]) : null;
-    lines.push(
-      whole && !block.html.includes(OPEN) ? block.html.replace(
-        /^<([a-z][\w-]*)/,
-        `<$1 data-change="deleted" data-change-id="${escapeAttr(whole)}" data-author="${escapeAttr(authors.get(whole) ?? "unknown")}"`
-      ) : block.html
-    );
-  });
-  const header = /^\s*Showing \d+ block\(s\):\s*/.exec(html) ? `Showing ${found.length} block(s):
-
-` : "";
-  return (header + lines.join("\n")).replace(
-    SENTINEL_RUN,
-    (_, kind, index, text) => {
-      const deletion = kind === DELETED;
-      if (view === "original") return deletion ? text : "";
-      const id = changes[index.charCodeAt(0) - CHANGE_BASE] ?? "";
-      const tag = deletion ? "del" : "ins";
-      return `<${tag} data-change-id="${escapeAttr(id)}" data-author="${escapeAttr(authors.get(id) ?? "unknown")}">${text}</${tag}>`;
-    }
-  );
-}
-function wholeBlockDeletion(block) {
-  const b = block;
-  if (b.structuralSuggestionKind === "delete" && b.structuralSuggestionId) {
-    return b.structuralSuggestionId;
-  }
-  let id = null;
-  let all = true;
-  let any = false;
-  const visit = (node) => {
-    if (!all || !node || typeof node !== "object") return;
-    const n = node;
-    if (n.type === "text") {
-      if (!n.text) return;
-      any = true;
-      if (!n.marks?.deletion) all = false;
-      else id ??= n.marks.suggestionId ?? null;
-      return;
-    }
-    n.children?.forEach(visit);
-  };
-  visit(block);
-  return any && all ? id : null;
-}
-function topLevelIds(html) {
-  const body = new DOMParser().parseFromString(
-    `<!doctype html><body>${html}</body>`,
-    "text/html"
-  ).body;
-  return Array.from(body.children).map((el) => el.getAttribute("id")).filter((id) => Boolean(id));
-}
-var escapeAttr = (value) => value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
-var placesByEntries = /* @__PURE__ */ new WeakMap();
-async function describeChanges(ydoc, session) {
-  const records = session.listSuggestions();
-  const doc = ydocToDocument2(ydoc);
-  const { documentHeadingSections } = await engineModules2.outline();
-  const span = /* @__PURE__ */ new Map();
-  let next = 0;
-  const number = (node) => {
-    if (!node || typeof node !== "object") return;
-    const n = node;
-    const isBlock = typeof n.id === "string" && n.type !== "text";
-    const start = next;
-    if (isBlock) next += 1;
-    n.children?.forEach(number);
-    if (isBlock) span.set(n.id, { start, end: next - 1 });
-  };
-  doc.children.forEach(number);
-  const bodyEnd = next;
-  (doc.chrome ?? []).forEach(number);
-  (doc.notes ?? []).forEach(number);
-  const headings = documentHeadingSections(doc, { maxDepth: 3 }).flatMap((h) => {
-    const start = span.get(h.itemId ?? h.blockId)?.start;
-    return start === void 0 ? [] : [{ title: h.title, level: h.level, start }];
-  }).sort((a, b) => a.start - b.start);
-  const sections = headings.map((h, i) => ({
-    ...h,
-    end: (headings.slice(i + 1).find((later) => later.level <= h.level)?.start ?? bodyEnd) - 1
-  }));
-  const sectionAt = (at) => {
-    let title;
-    for (const section of sections) {
-      if (section.start > at) break;
-      title = section.title;
-    }
-    return title;
-  };
-  const positionOf = new Map(
-    doc.children.map((block, index) => [block.id, index])
-  );
-  const found = /* @__PURE__ */ new Map();
-  const collect = (block, blockIndex, label) => {
-    const visit = (node, path) => {
-      if (!node || typeof node !== "object") return;
-      const n = node;
-      const here = typeof n.id === "string" && n.type !== "text" ? [...path, n.id] : path;
-      const id = n.marks?.suggestionId ?? n.suggestionId ?? n.structuralSuggestionId;
-      if (id) {
-        const entry = found.get(id) ?? {
-          blockIndex,
-          blockId: block.id ?? "",
-          label,
-          path: here,
-          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((child) => visit(child, here));
-    };
-    visit(block, []);
-  };
-  doc.children.forEach(
-    (block, blockIndex) => collect(block, blockIndex, void 0)
-  );
-  for (const block of doc.chrome ?? []) {
-    collect(block, void 0, block.side === "header" ? "Header" : "Footer");
-  }
-  const noteCount = { footnote: 0, endnote: 0 };
-  for (const note of doc.notes ?? []) {
-    const kind = note.noteKind === "endnote" ? "endnote" : "footnote";
-    noteCount[kind] += 1;
-    collect(
-      note,
-      void 0,
-      `${kind === "endnote" ? "Endnote" : "Footnote"} ${noteCount[kind]}`
-    );
-  }
-  const changes = /* @__PURE__ */ new WeakMap();
-  const entries = 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);
-    const path = at?.path ?? [record.tableId, record.blockId].filter(
-      (id) => Boolean(id && span.has(id))
-    );
-    const place = path.length ? span.get(path[path.length - 1]) : void 0;
-    const entry = {
-      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 } : {},
-      ...at?.label ? { section: at.label } : place && place.start < bodyEnd ? { section: sectionAt(place.start) } : {},
-      deleted: at?.deleted ?? "",
-      inserted: at?.inserted ?? ""
-    };
-    if (place) changes.set(entry, { at: place.start, path });
-    return entry;
-  });
-  placesByEntries.set(entries, { span, sections, changes });
-  return entries;
-}
-function headingMatches(title, query) {
-  const heading = title.trim().toLowerCase();
-  const q = query.trim().toLowerCase().replace(/\.$/, "");
-  if (/^[\d.]+$/.test(q)) {
-    return new RegExp(`^${q.replace(/\./g, "\\.")}(?:[.\\s)]|$)`).test(heading);
-  }
-  return heading.includes(q);
-}
-function parseBlockQuery(query) {
-  return query.split(",").map((part) => part.trim()).filter(Boolean).map((part) => {
-    const [from, to, ...rest] = part.split(/\.\.\.?|…/).map((id) => id.trim());
-    if (to === void 0) return from;
-    if (!from || !to || rest.length) {
-      throw new ReviseError(
-        `"${part}" is not a block range; write first..last.`,
-        "invalid_selection"
-      );
-    }
-    return { from, to };
-  });
-}
-function applyChangeFilter(entries, filter) {
-  const { section, exceptSection, blocks } = filter;
-  if (!section && !exceptSection && !blocks?.length) return entries;
-  const places = placesByEntries.get(entries);
-  if (!places) return entries;
-  const sectionRanges = (query) => {
-    const q = query.trim().toLowerCase();
-    const exact = places.sections.filter(
-      (s) => s.title.toLowerCase() === q || s.title.toLowerCase().replace(/^[\d.]+[.)]?\s+/, "") === q
-    );
-    const candidates = exact.length ? exact : places.sections.filter((s) => headingMatches(s.title, query));
-    const matched = candidates.filter(
-      (s) => !candidates.some(
-        (outer) => outer !== s && outer.start < s.start && s.end <= outer.end
-      )
-    );
-    if (matched.length > 1) {
-      throw new ReviseError(
-        `"${query}" matches ${matched.length} headings: ${matched.map((s) => `"${s.title}"`).join(", ")}. Name one by its number or full title.`,
-        "section_ambiguous"
-      );
-    }
-    if (!matched.length) {
-      throw new ReviseError(
-        places.sections.length ? `No heading matches "${query}". Headings: ${places.sections.slice(0, 12).map((s) => `"${s.title}"`).join(", ")}${places.sections.length > 12 ? ", \u2026" : ""}.` : `No heading matches "${query}": the document has no headings. Select by blocks or change ids instead.`,
-        "section_not_found"
-      );
-    }
-    return matched;
-  };
-  const spanOf = (id) => {
-    const found = places.span.get(id);
-    if (!found) {
-      throw new ReviseError(`No block with id "${id}".`, "block_not_found");
-    }
-    return found;
-  };
-  const inside = sectionRanges;
-  const keepSections = section ? inside(section) : void 0;
-  const dropSections = exceptSection ? inside(exceptSection) : void 0;
-  const ids = /* @__PURE__ */ new Set();
-  const ranges = [];
-  for (const item of blocks ?? []) {
-    if (typeof item === "string") {
-      spanOf(item);
-      ids.add(item);
-      continue;
-    }
-    const from = spanOf(item.from);
-    const to = spanOf(item.to);
-    if (from.start > to.start) {
-      throw new ReviseError(
-        `Block "${item.from}" comes after "${item.to}"; write the range first..last.`,
-        "invalid_selection"
-      );
-    }
-    ranges.push({ start: from.start, end: to.end });
-  }
-  const within = (at, r) => at >= r.start && at <= r.end;
-  return entries.filter((entry) => {
-    const place = places.changes.get(entry);
-    if (!place) return false;
-    if (keepSections && !keepSections.some((r) => within(place.at, r))) {
-      return false;
-    }
-    if (dropSections?.some((r) => within(place.at, r))) return false;
-    if (blocks?.length && !place.path.some((id) => ids.has(id)) && !ranges.some((r) => within(place.at, r))) {
-      return false;
-    }
-    return true;
-  });
-}
-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,
-  parseBlockQuery,
-  formatToolResult,
-  agentTools
-};