@eigenpal/docx-editor-agents 0.0.28

package/dist/index.js

@@ -0,0 +1,896 @@
+import { parseDocx, isHeadingStyle, parseHeadingLevel, getRunText, getHyperlinkText } from '@eigenpal/docx-core/headless';
+
+// src/DocxReviewer.ts
+function isTrackedChange(item) {
+  return item.type === "insertion" || item.type === "deletion" || item.type === "moveFrom" || item.type === "moveTo";
+}
+function getTrackedChangeText(content) {
+  const parts = [];
+  for (const item of content) {
+    if (item.type === "run") {
+      parts.push(getRunText(item));
+    } else if (item.type === "hyperlink") {
+      parts.push(getHyperlinkText(item));
+    }
+  }
+  return parts.join("");
+}
+function getParagraphAtIndex(body, paragraphIndex) {
+  let index = 0;
+  for (const block of body.content) {
+    if (block.type === "paragraph") {
+      if (index === paragraphIndex) return block;
+      index++;
+    } else if (block.type === "table") {
+      for (const row of block.rows) {
+        for (const cell of row.cells) {
+          for (const cellBlock of cell.content) {
+            if (cellBlock.type === "paragraph") {
+              if (index === paragraphIndex) return cellBlock;
+              index++;
+            }
+          }
+        }
+      }
+    } else {
+      index++;
+    }
+  }
+  throw new Error(`Paragraph index ${paragraphIndex} out of bounds (max: ${index - 1})`);
+}
+function forEachParagraph(body, fn) {
+  let index = 0;
+  for (const block of body.content) {
+    if (block.type === "paragraph") {
+      if (fn(block, index) === false) return;
+      index++;
+    } else if (block.type === "table") {
+      for (const row of block.rows) {
+        for (const cell of row.cells) {
+          for (const cellBlock of cell.content) {
+            if (cellBlock.type === "paragraph") {
+              if (fn(cellBlock, index) === false) return;
+              index++;
+            }
+          }
+        }
+      }
+    } else {
+      index++;
+    }
+  }
+}
+
+// src/content.ts
+function getContent(body, options = {}) {
+  const {
+    fromIndex,
+    toIndex,
+    includeTrackedChanges = true,
+    includeCommentAnchors = true
+  } = options;
+  const blocks = [];
+  let index = 0;
+  for (const block of body.content) {
+    if (block.type === "paragraph") {
+      if (isInRange(index, fromIndex, toIndex)) {
+        blocks.push(
+          buildParagraphBlock(block, index, includeTrackedChanges, includeCommentAnchors)
+        );
+      }
+      index++;
+    } else if (block.type === "table") {
+      if (isInRange(index, fromIndex, toIndex)) {
+        blocks.push(buildTableBlock(block, index, includeTrackedChanges, includeCommentAnchors));
+      }
+      for (const row of block.rows) {
+        for (const cell of row.cells) {
+          for (const cellBlock of cell.content) {
+            if (cellBlock.type === "paragraph") {
+              index++;
+            }
+          }
+        }
+      }
+    } else {
+      index++;
+    }
+  }
+  return blocks;
+}
+function isInRange(index, from, to) {
+  return (from === void 0 || index >= from) && (to === void 0 || index <= to);
+}
+function buildParagraphBlock(para, index, includeTrackedChanges, includeCommentAnchors) {
+  const text = buildParagraphText(para, includeTrackedChanges, includeCommentAnchors);
+  const styleId = para.formatting?.styleId;
+  if (isHeadingStyle(styleId)) {
+    return {
+      type: "heading",
+      index,
+      level: parseHeadingLevel(styleId) ?? 1,
+      text
+    };
+  }
+  if (para.listRendering) {
+    return {
+      type: "list-item",
+      index,
+      text,
+      listLevel: para.listRendering.level ?? 0,
+      listType: para.listRendering.isBullet ? "bullet" : "number"
+    };
+  }
+  return { type: "paragraph", index, text };
+}
+function buildTableBlock(table, index, includeTrackedChanges, includeCommentAnchors) {
+  const rows = [];
+  for (const row of table.rows) {
+    const cells = [];
+    for (const cell of row.cells) {
+      const cellTexts = [];
+      for (const block of cell.content) {
+        if (block.type === "paragraph") {
+          cellTexts.push(buildParagraphText(block, includeTrackedChanges, includeCommentAnchors));
+        }
+      }
+      cells.push(cellTexts.join("\n"));
+    }
+    rows.push(cells);
+  }
+  return { type: "table", index, rows };
+}
+function formatContentForLLM(blocks) {
+  const lines = [];
+  for (const block of blocks) {
+    switch (block.type) {
+      case "heading":
+        lines.push(`[${block.index}] (h${block.level}) ${block.text}`);
+        break;
+      case "paragraph":
+        lines.push(`[${block.index}] ${block.text}`);
+        break;
+      case "list-item": {
+        const indent = "  ".repeat(block.listLevel);
+        const bullet = block.listType === "bullet" ? "\u2022" : "-";
+        lines.push(`[${block.index}] ${indent}${bullet} ${block.text}`);
+        break;
+      }
+      case "table": {
+        let idx = block.index;
+        for (let r = 0; r < block.rows.length; r++) {
+          for (let c = 0; c < block.rows[r].length; c++) {
+            const cellText = block.rows[r][c];
+            const paras = cellText.split("\n");
+            for (const para of paras) {
+              lines.push(`[${idx}] (table, row ${r + 1}, col ${c + 1}) ${para}`);
+              idx++;
+            }
+          }
+        }
+        break;
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function buildParagraphText(para, includeTrackedChanges, includeCommentAnchors) {
+  const parts = [];
+  const activeCommentIds = /* @__PURE__ */ new Set();
+  for (const item of para.content) {
+    if (item.type === "commentRangeStart" && includeCommentAnchors) {
+      activeCommentIds.add(item.id);
+      parts.push(`[comment:${item.id}]`);
+      continue;
+    }
+    if (item.type === "commentRangeEnd" && includeCommentAnchors) {
+      if (activeCommentIds.has(item.id)) {
+        activeCommentIds.delete(item.id);
+        parts.push("[/comment]");
+      }
+      continue;
+    }
+    if (item.type === "run") {
+      parts.push(getRunText(item));
+    } else if (item.type === "hyperlink") {
+      parts.push(getHyperlinkText(item));
+    } else if (isTrackedChange(item)) {
+      const text = getTrackedChangeText(item.content);
+      if (item.type === "insertion" || item.type === "moveTo") {
+        if (includeTrackedChanges) {
+          parts.push(`[+${text}+]{by:${item.info.author}}`);
+        } else {
+          parts.push(text);
+        }
+      } else {
+        if (includeTrackedChanges) {
+          parts.push(`[-${text}-]{by:${item.info.author}}`);
+        }
+      }
+    }
+  }
+  return parts.join("");
+}
+
+// src/errors.ts
+var TextNotFoundError = class extends Error {
+  constructor(search, paragraphIndex) {
+    const location = paragraphIndex !== void 0 ? ` in paragraph ${paragraphIndex}` : " in document";
+    super(`Text not found${location}: "${search}"`);
+    this.name = "TextNotFoundError";
+  }
+};
+var ChangeNotFoundError = class extends Error {
+  constructor(id) {
+    super(`Tracked change not found: id=${id}`);
+    this.name = "ChangeNotFoundError";
+  }
+};
+var CommentNotFoundError = class extends Error {
+  constructor(id) {
+    super(`Comment not found: id=${id}`);
+    this.name = "CommentNotFoundError";
+  }
+};
+
+// src/textSearch.ts
+function flattenRuns(paragraph) {
+  const result = [];
+  let pos = 0;
+  for (let ci = 0; ci < paragraph.content.length; ci++) {
+    const item = paragraph.content[ci];
+    if (item.type === "run") {
+      const text = getRunText(item);
+      result.push({ contentIndex: ci, run: item, text, startPos: pos });
+      pos += text.length;
+    } else if (item.type === "hyperlink") {
+      for (let hi = 0; hi < item.children.length; hi++) {
+        const child = item.children[hi];
+        if (child.type === "run") {
+          const text = getRunText(child);
+          result.push({ contentIndex: ci, run: child, text, startPos: pos });
+          pos += text.length;
+        }
+      }
+    } else if (isTrackedChange(item)) {
+      for (let ri = 0; ri < item.content.length; ri++) {
+        const child = item.content[ri];
+        if (child.type === "run") {
+          const text = getRunText(child);
+          result.push({ contentIndex: ci, run: child, text, startPos: pos });
+          pos += text.length;
+        } else if (child.type === "hyperlink") {
+          for (const hc of child.children) {
+            if (hc.type === "run") {
+              const text = getRunText(hc);
+              result.push({ contentIndex: ci, run: hc, text, startPos: pos });
+              pos += text.length;
+            }
+          }
+        }
+      }
+    }
+  }
+  return result;
+}
+function getParagraphPlainText(paragraph) {
+  return flattenRuns(paragraph).map((r) => r.text).join("");
+}
+function findTextInParagraph(paragraph, search, paragraphIndex) {
+  const runs = flattenRuns(paragraph);
+  const fullText = runs.map((r) => r.text).join("");
+  const match = findMatch(fullText, search);
+  if (!match) throw new TextNotFoundError(search, paragraphIndex);
+  let startRunIdx = -1;
+  let startOffset = 0;
+  for (let i = 0; i < runs.length; i++) {
+    if (match.start < runs[i].startPos + runs[i].text.length) {
+      startRunIdx = i;
+      startOffset = match.start - runs[i].startPos;
+      break;
+    }
+  }
+  let endRunIdx = -1;
+  let endOffset = 0;
+  for (let i = runs.length - 1; i >= 0; i--) {
+    if (match.end > runs[i].startPos) {
+      endRunIdx = i;
+      endOffset = match.end - runs[i].startPos;
+      break;
+    }
+  }
+  if (startRunIdx === -1 || endRunIdx === -1) {
+    throw new TextNotFoundError(search, paragraphIndex);
+  }
+  return {
+    startRunIndex: runs[startRunIdx].contentIndex,
+    startOffset,
+    endRunIndex: runs[endRunIdx].contentIndex,
+    endOffset
+  };
+}
+function isolateMatchedText(paragraph, search, paragraphIndex) {
+  const result = findTextInParagraph(paragraph, search, paragraphIndex);
+  let { startRunIndex, endRunIndex } = result;
+  const { startOffset, endOffset } = result;
+  const endItem = paragraph.content[endRunIndex];
+  if (endItem.type === "run") {
+    const endText = getRunText(endItem);
+    if (endOffset < endText.length) {
+      const afterRun = makeRunWithText(endText.slice(endOffset), endItem);
+      setRunText(endItem, endText.slice(0, endOffset));
+      paragraph.content.splice(endRunIndex + 1, 0, afterRun);
+    }
+  }
+  const startItem = paragraph.content[startRunIndex];
+  if (startItem.type === "run" && startOffset > 0) {
+    const startText = getRunText(startItem);
+    const beforeRun = makeRunWithText(startText.slice(0, startOffset), startItem);
+    setRunText(startItem, startText.slice(startOffset));
+    paragraph.content.splice(startRunIndex, 0, beforeRun);
+    startRunIndex++;
+    endRunIndex++;
+  }
+  return { startIndex: startRunIndex, endIndex: endRunIndex };
+}
+function makeRunWithText(text, template) {
+  return {
+    type: "run",
+    content: [{ type: "text", text }],
+    formatting: template.formatting ? { ...template.formatting } : void 0
+  };
+}
+function setRunText(run, text) {
+  const textContent = run.content.find((c) => c.type === "text");
+  if (textContent) {
+    textContent.text = text;
+  }
+}
+function normalize(original) {
+  const chars = [];
+  const posMap = [];
+  let prevSpace = true;
+  for (let i = 0; i < original.length; i++) {
+    let ch = original[i];
+    if ("\u200B\u200C\u200D\uFEFF\xAD".includes(ch)) continue;
+    if ("\u201C\u201D\u201E\u201F".includes(ch)) ch = '"';
+    if ("\u2018\u2019\u201A\u201B".includes(ch)) ch = "'";
+    if ("\u2013\u2014\u2012\u2015".includes(ch)) ch = "-";
+    if (ch === "\u2026") {
+      chars.push(".", ".", ".");
+      posMap.push(i, i, i);
+      prevSpace = false;
+      continue;
+    }
+    if (/\s/.test(ch) || ch === "\xA0") {
+      if (!prevSpace) {
+        chars.push(" ");
+        posMap.push(i);
+        prevSpace = true;
+      }
+      continue;
+    }
+    chars.push(ch.toLowerCase());
+    posMap.push(i);
+    prevSpace = false;
+  }
+  if (chars.length > 0 && chars[chars.length - 1] === " ") {
+    chars.pop();
+    posMap.pop();
+  }
+  return { text: chars.join(""), posMap };
+}
+function mapBack(norm, idx, len, original) {
+  const start = norm.posMap[idx];
+  let end = norm.posMap[idx + len - 1] + 1;
+  while (end < original.length && "\u200B\u200C\u200D\uFEFF\xAD".includes(original[end])) end++;
+  return { start, end };
+}
+function findMatch(text, search) {
+  if (!search || !text) return null;
+  const exact = text.indexOf(search);
+  if (exact !== -1) return { start: exact, end: exact + search.length };
+  const normText = normalize(text);
+  const normSearch = normalize(search);
+  if (!normSearch.text) return null;
+  const idx = normText.text.indexOf(normSearch.text);
+  if (idx !== -1) return mapBack(normText, idx, normSearch.text.length, text);
+  const words = normSearch.text.split(" ");
+  if (words.length >= 3) {
+    for (let drop = 1; drop <= Math.min(2, words.length - 2); drop++) {
+      const trimmed = words.slice(0, -drop).join(" ");
+      const trimIdx = normText.text.indexOf(trimmed);
+      if (trimIdx !== -1) return mapBack(normText, trimIdx, trimmed.length, text);
+    }
+  }
+  return null;
+}
+
+// src/discovery.ts
+function getChanges(body, filter) {
+  const grouped = /* @__PURE__ */ new Map();
+  forEachParagraph(body, (para, paragraphIndex) => {
+    let context = null;
+    for (const item of para.content) {
+      if (isTrackedChange(item)) {
+        if (context === null) context = getParagraphPlainText(para);
+        const text = getTrackedChangeText(item.content);
+        const id = item.info.id;
+        const existing = grouped.get(id);
+        if (existing && existing.paragraphIndex === paragraphIndex) {
+          existing.text += text;
+        } else {
+          grouped.set(id, {
+            id,
+            type: item.type,
+            author: item.info.author,
+            date: item.info.date ?? null,
+            text,
+            context,
+            paragraphIndex
+          });
+        }
+      }
+    }
+  });
+  const changes = Array.from(grouped.values());
+  return changes.filter((c) => {
+    if (filter?.author && c.author !== filter.author) return false;
+    if (filter?.type && c.type !== filter.type) return false;
+    return true;
+  });
+}
+function getComments(body, filter) {
+  const comments = body.comments ?? [];
+  if (comments.length === 0) return [];
+  const anchoredTextMap = buildAnchoredTextMap(body);
+  const topLevel = [];
+  const repliesByParent = /* @__PURE__ */ new Map();
+  for (const c of comments) {
+    if (c.parentId !== void 0) {
+      const existing = repliesByParent.get(c.parentId) ?? [];
+      existing.push(c);
+      repliesByParent.set(c.parentId, existing);
+    } else {
+      topLevel.push(c);
+    }
+  }
+  const result = topLevel.map((c) => {
+    const anchor = anchoredTextMap.get(c.id);
+    const replies = (repliesByParent.get(c.id) ?? []).map((r) => ({
+      id: r.id,
+      author: r.author,
+      date: r.date ?? null,
+      text: getCommentText(r)
+    }));
+    return {
+      id: c.id,
+      author: c.author,
+      date: c.date ?? null,
+      text: getCommentText(c),
+      anchoredText: anchor?.text ?? "",
+      paragraphIndex: anchor?.paragraphIndex ?? -1,
+      replies,
+      done: c.done ?? false
+    };
+  });
+  return result.filter((c) => {
+    if (filter?.author && c.author !== filter.author) return false;
+    if (filter?.done !== void 0 && c.done !== filter.done) return false;
+    return true;
+  });
+}
+function getCommentText(comment) {
+  return comment.content.map((para) => getParagraphPlainText(para)).join("\n");
+}
+function buildAnchoredTextMap(body) {
+  const result = /* @__PURE__ */ new Map();
+  const openRanges = /* @__PURE__ */ new Map();
+  forEachParagraph(body, (para, paragraphIndex) => {
+    for (const item of para.content) {
+      if (item.type === "commentRangeStart") {
+        openRanges.set(item.id, { paragraphIndex, parts: [] });
+      } else if (item.type === "commentRangeEnd") {
+        const open = openRanges.get(item.id);
+        if (open) {
+          result.set(item.id, { text: open.parts.join(""), paragraphIndex: open.paragraphIndex });
+          openRanges.delete(item.id);
+        }
+      } else if (item.type === "run") {
+        const text = getRunText(item);
+        for (const open of openRanges.values()) {
+          open.parts.push(text);
+        }
+      } else if (item.type === "hyperlink") {
+        const text = item.children.filter((c) => c.type === "run").map(getRunText).join("");
+        for (const open of openRanges.values()) {
+          open.parts.push(text);
+        }
+      } else if (isTrackedChange(item)) {
+        const text = getTrackedChangeText(item.content);
+        for (const open of openRanges.values()) {
+          open.parts.push(text);
+        }
+      }
+    }
+  });
+  return result;
+}
+
+// src/comments.ts
+function addComment(body, options) {
+  const { paragraphIndex, author = "AI", text, search } = options;
+  const para = getParagraphAtIndex(body, paragraphIndex);
+  const existingIds = (body.comments ?? []).map((c) => c.id);
+  const newId = existingIds.length > 0 ? Math.max(...existingIds) + 1 : 1;
+  const comment = {
+    id: newId,
+    author,
+    date: (/* @__PURE__ */ new Date()).toISOString(),
+    content: [
+      {
+        type: "paragraph",
+        content: [{ type: "run", content: [{ type: "text", text }] }],
+        formatting: {}
+      }
+    ]
+  };
+  if (!body.comments) {
+    body.comments = [];
+  }
+  body.comments.push(comment);
+  if (search) {
+    const result = findTextInParagraph(para, search, paragraphIndex);
+    para.content.splice(result.endRunIndex + 1, 0, { type: "commentRangeEnd", id: newId });
+    para.content.splice(result.startRunIndex, 0, { type: "commentRangeStart", id: newId });
+  } else {
+    para.content.unshift({ type: "commentRangeStart", id: newId });
+    para.content.push({ type: "commentRangeEnd", id: newId });
+  }
+  return newId;
+}
+function replyTo(body, commentId, options) {
+  const comments = body.comments ?? [];
+  const parent = comments.find((c) => c.id === commentId);
+  if (!parent) {
+    throw new CommentNotFoundError(commentId);
+  }
+  const existingIds = comments.map((c) => c.id);
+  const newId = Math.max(...existingIds) + 1;
+  const reply = {
+    id: newId,
+    author: options.author ?? "AI",
+    date: (/* @__PURE__ */ new Date()).toISOString(),
+    parentId: commentId,
+    content: [
+      {
+        type: "paragraph",
+        content: [{ type: "run", content: [{ type: "text", text: options.text }] }],
+        formatting: {}
+      }
+    ]
+  };
+  comments.push(reply);
+  return newId;
+}
+
+// src/changes.ts
+function acceptChange(body, id) {
+  if (!processChangeById(body, id, "accept")) {
+    throw new ChangeNotFoundError(id);
+  }
+}
+function rejectChange(body, id) {
+  if (!processChangeById(body, id, "reject")) {
+    throw new ChangeNotFoundError(id);
+  }
+}
+function acceptAll(body) {
+  return processAllChanges(body, "accept");
+}
+function rejectAll(body) {
+  return processAllChanges(body, "reject");
+}
+function processAllChanges(body, mode) {
+  let count = 0;
+  forEachParagraph(body, (para) => {
+    for (let i = para.content.length - 1; i >= 0; i--) {
+      const item = para.content[i];
+      if (isTrackedChange(item)) {
+        applyChangeAtIndex(para, i, item, mode);
+        count++;
+      }
+    }
+  });
+  return count;
+}
+function processChangeById(body, id, mode) {
+  let found = false;
+  forEachParagraph(body, (para) => {
+    for (let i = para.content.length - 1; i >= 0; i--) {
+      const item = para.content[i];
+      if (isTrackedChange(item) && item.info.id === id) {
+        applyChangeAtIndex(para, i, item, mode);
+        found = true;
+      }
+    }
+    if (found) return false;
+  });
+  return found;
+}
+function applyChangeAtIndex(para, index, item, mode) {
+  const keepContent = item.type === "insertion" && mode === "accept" || item.type === "deletion" && mode === "reject" || item.type === "moveTo" && mode === "accept" || item.type === "moveFrom" && mode === "reject";
+  if (keepContent) {
+    const runs = item.content;
+    para.content.splice(index, 1, ...runs);
+  } else {
+    para.content.splice(index, 1);
+  }
+}
+function proposeReplacement(body, options) {
+  const { paragraphIndex, search, author = "AI", replaceWith } = options;
+  const para = getParagraphAtIndex(body, paragraphIndex);
+  const { startIndex, endIndex } = isolateMatchedText(para, search, paragraphIndex);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const baseId = nextRevisionId(body);
+  const matchedContent = para.content.slice(startIndex, endIndex + 1);
+  const deletion = {
+    type: "deletion",
+    info: { id: baseId, author, date: now },
+    content: matchedContent
+  };
+  const insertion = {
+    type: "insertion",
+    info: { id: baseId + 1, author, date: now },
+    content: [{ type: "run", content: [{ type: "text", text: replaceWith }] }]
+  };
+  para.content.splice(startIndex, endIndex - startIndex + 1, deletion, insertion);
+}
+function proposeInsertion(body, options) {
+  const { paragraphIndex, author = "AI", insertText, position = "after", search } = options;
+  const para = getParagraphAtIndex(body, paragraphIndex);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const id = nextRevisionId(body);
+  const insertion = {
+    type: "insertion",
+    info: { id, author, date: now },
+    content: [{ type: "run", content: [{ type: "text", text: insertText }] }]
+  };
+  if (search) {
+    const { startIndex, endIndex } = isolateMatchedText(para, search, paragraphIndex);
+    const insertAt = position === "after" ? endIndex + 1 : startIndex;
+    para.content.splice(insertAt, 0, insertion);
+  } else {
+    if (position === "before") {
+      para.content.unshift(insertion);
+    } else {
+      para.content.push(insertion);
+    }
+  }
+}
+function proposeDeletion(body, options) {
+  const { paragraphIndex, search, author = "AI" } = options;
+  const para = getParagraphAtIndex(body, paragraphIndex);
+  const { startIndex, endIndex } = isolateMatchedText(para, search, paragraphIndex);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const id = nextRevisionId(body);
+  const matchedContent = para.content.slice(startIndex, endIndex + 1);
+  const deletion = {
+    type: "deletion",
+    info: { id, author, date: now },
+    content: matchedContent
+  };
+  para.content.splice(startIndex, endIndex - startIndex + 1, deletion);
+}
+var revisionIdCache = /* @__PURE__ */ new WeakMap();
+function nextRevisionId(body) {
+  let maxId = revisionIdCache.get(body);
+  if (maxId === void 0) {
+    maxId = 0;
+    forEachParagraph(body, (para) => {
+      for (const item of para.content) {
+        if (isTrackedChange(item)) {
+          maxId = Math.max(maxId, item.info.id);
+        }
+      }
+    });
+  }
+  const next = maxId + 1;
+  revisionIdCache.set(body, next + 1);
+  return next;
+}
+
+// src/batch.ts
+function applyReview(body, ops, defaultAuthor = "AI") {
+  const errors = [];
+  let accepted = 0;
+  let rejected = 0;
+  let commentsAdded = 0;
+  let repliesAdded = 0;
+  let proposalsAdded = 0;
+  for (const id of ops.accept ?? []) {
+    try {
+      acceptChange(body, id);
+      accepted++;
+    } catch (e) {
+      errors.push({ operation: "accept", id, error: e.message });
+    }
+  }
+  for (const id of ops.reject ?? []) {
+    try {
+      rejectChange(body, id);
+      rejected++;
+    } catch (e) {
+      errors.push({ operation: "reject", id, error: e.message });
+    }
+  }
+  for (const opts of ops.comments ?? []) {
+    try {
+      addComment(body, { ...opts, author: opts.author ?? defaultAuthor });
+      commentsAdded++;
+    } catch (e) {
+      errors.push({ operation: "comment", search: opts.search, error: e.message });
+    }
+  }
+  for (const opts of ops.replies ?? []) {
+    try {
+      replyTo(body, opts.commentId, { author: opts.author ?? defaultAuthor, text: opts.text });
+      repliesAdded++;
+    } catch (e) {
+      errors.push({ operation: "reply", id: opts.commentId, error: e.message });
+    }
+  }
+  for (const opts of ops.proposals ?? []) {
+    try {
+      proposeReplacement(body, { ...opts, author: opts.author ?? defaultAuthor });
+      proposalsAdded++;
+    } catch (e) {
+      errors.push({ operation: "proposal", search: opts.search, error: e.message });
+    }
+  }
+  return { accepted, rejected, commentsAdded, repliesAdded, proposalsAdded, errors };
+}
+
+// src/DocxReviewer.ts
+var DocxReviewer = class _DocxReviewer {
+  /**
+   * Create a reviewer from a parsed Document.
+   * @param document - Parsed Document from @eigenpal/docx-core
+   * @param author - Default author name for comments and changes. (default: 'AI')
+   * @param originalBuffer - Original DOCX buffer, needed for toBuffer()
+   */
+  constructor(document, author = "AI", originalBuffer) {
+    const savedBuffer = originalBuffer ?? document.originalBuffer;
+    const { originalBuffer: _discard, ...rest } = document;
+    this.doc = structuredClone(rest);
+    if (savedBuffer) this.doc.originalBuffer = savedBuffer;
+    this.author = author;
+  }
+  /**
+   * Create a reviewer from a DOCX file buffer.
+   * @param buffer - ArrayBuffer of the DOCX file
+   * @param author - Default author name for comments and changes. (default: 'AI')
+   */
+  static async fromBuffer(buffer, author = "AI") {
+    const doc = await parseDocx(buffer, { preloadFonts: false });
+    return new _DocxReviewer(doc, author, buffer);
+  }
+  get body() {
+    return this.doc.package.document;
+  }
+  resolveAuthor(author) {
+    return author ?? this.author;
+  }
+  // ==========================================================================
+  // READ
+  // ==========================================================================
+  /** Get document content as structured blocks (headings, paragraphs, tables, lists). */
+  getContent(options) {
+    return getContent(this.body, options);
+  }
+  /**
+   * Get document content as plain text for LLM prompts.
+   * Each paragraph is prefixed with its index: `[0] text`, `[1] text`, etc.
+   * Table cells include position: `[5] (table, row 1, col 2) cell text`.
+   * Avoids JSON quote-escaping issues — LLMs can copy text verbatim.
+   */
+  getContentAsText(options) {
+    return formatContentForLLM(getContent(this.body, options));
+  }
+  // ==========================================================================
+  // DISCOVER
+  // ==========================================================================
+  /** Get all tracked changes in the document. */
+  getChanges(filter) {
+    return getChanges(this.body, filter);
+  }
+  /** Get all comments with their replies. */
+  getComments(filter) {
+    return getComments(this.body, filter);
+  }
+  addComment(indexOrOptions, text) {
+    const opts = typeof indexOrOptions === "number" ? { paragraphIndex: indexOrOptions, text, author: this.author } : { ...indexOrOptions, author: this.resolveAuthor(indexOrOptions.author) };
+    return addComment(this.body, opts);
+  }
+  replyTo(commentId, textOrOptions) {
+    const opts = typeof textOrOptions === "string" ? { text: textOrOptions, author: this.author } : { ...textOrOptions, author: this.resolveAuthor(textOrOptions.author) };
+    return replyTo(this.body, commentId, opts);
+  }
+  replace(indexOrOptions, search, replaceWith) {
+    const opts = typeof indexOrOptions === "number" ? {
+      paragraphIndex: indexOrOptions,
+      search,
+      replaceWith,
+      author: this.author
+    } : { ...indexOrOptions, author: this.resolveAuthor(indexOrOptions.author) };
+    proposeReplacement(this.body, opts);
+  }
+  /** @deprecated Use replace() instead. */
+  proposeReplacement(options) {
+    this.replace(options);
+  }
+  /** Insert text as a tracked change. */
+  proposeInsertion(options) {
+    proposeInsertion(this.body, {
+      ...options,
+      author: this.resolveAuthor(options.author)
+    });
+  }
+  /** Delete text as a tracked change. */
+  proposeDeletion(options) {
+    proposeDeletion(this.body, {
+      ...options,
+      author: this.resolveAuthor(options.author)
+    });
+  }
+  // ==========================================================================
+  // RESOLVE
+  // ==========================================================================
+  /** Accept a tracked change by its revision ID. */
+  acceptChange(id) {
+    acceptChange(this.body, id);
+  }
+  /** Reject a tracked change by its revision ID. */
+  rejectChange(id) {
+    rejectChange(this.body, id);
+  }
+  /** Accept all tracked changes. Returns count accepted. */
+  acceptAll() {
+    return acceptAll(this.body);
+  }
+  /** Reject all tracked changes. Returns count rejected. */
+  rejectAll() {
+    return rejectAll(this.body);
+  }
+  // ==========================================================================
+  // BATCH
+  // ==========================================================================
+  /**
+   * Apply multiple review operations in one call.
+   * Uses the reviewer's default author. Individual failures are collected, not thrown.
+   */
+  applyReview(ops) {
+    return applyReview(this.body, ops, this.author);
+  }
+  // ==========================================================================
+  // EXPORT
+  // ==========================================================================
+  /** Get the modified Document model. */
+  toDocument() {
+    return this.doc;
+  }
+  /** Serialize back to a DOCX buffer. Requires the original buffer. */
+  async toBuffer() {
+    if (!this.doc.originalBuffer) {
+      throw new Error(
+        "Cannot create buffer: no original DOCX buffer was provided. Use DocxReviewer.fromBuffer() or pass originalBuffer to the constructor."
+      );
+    }
+    const { repackDocx } = await import('@eigenpal/docx-core/headless');
+    return repackDocx(this.doc);
+  }
+};
+
+export { ChangeNotFoundError, CommentNotFoundError, DocxReviewer, TextNotFoundError };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map