@ansonlai/docx-redline-js 0.9.0 → 0.11.0

package/dist/docx-redline.bundle.cjs

@@ -1,4 +1,4 @@
-// @ansonlai/docx-redline-js standalone CommonJS bundle v0.9.0 — https://github.com/AnsonLai/docx-redline-js
+// @ansonlai/docx-redline-js standalone CommonJS bundle v0.11.0 — https://github.com/AnsonLai/docx-redline-js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -8009,6 +8009,7 @@ __export(index_exports, {
   canonicalNumberingDefinition: () => canonicalNumberingDefinition,
   clearSingleLineListFallbackExplicitSequence: () => clearSingleLineListFallbackExplicitSequence,
   collectContiguousListParagraphBlock: () => collectContiguousListParagraphBlock,
+  compareDocumentInspections: () => compareDocumentInspections,
   computeDocumentPartsRevisionToken: () => computeDocumentPartsRevisionToken,
   computePackageRevisionToken: () => computePackageRevisionToken,
   computeRevisionToken: () => computeRevisionToken,
@@ -8060,9 +8061,11 @@ __export(index_exports, {
   injectCommentsIntoPackage: () => injectCommentsIntoPackage2,
   insertBodyElementBeforeSectPr: () => insertBodyElementBeforeSectPr,
   inspectDocumentParts: () => inspectDocumentParts,
+  inspectionReviewShape: () => inspectionReviewShape,
   isLikelyStructuredTableSourceParagraph: () => isLikelyStructuredTableSourceParagraph,
   isMarkdownTableText: () => isMarkdownTableText,
   isNodeVisibleInRevisionView: () => isNodeVisibleInRevisionView,
+  mergeCommentParts: () => mergeCommentParts,
   mergeNumberingParts: () => mergeNumberingParts,
   mergeNumberingXmlBySchemaOrder: () => mergeNumberingXmlBySchemaOrder,
   normalizeBodySectionOrderStandalone: () => normalizeBodySectionOrderStandalone,
@@ -8089,6 +8092,7 @@ __export(index_exports, {
   repairKnownContentTypes: () => repairKnownContentTypes,
   reserveNextNumberingId: () => reserveNextNumberingId,
   reserveNextNumberingIdPair: () => reserveNextNumberingIdPair,
+  resolveExistingRevisionsPolicy: () => resolveExistingRevisionsPolicy,
   resolveParagraphRangeByRefs: () => resolveParagraphRangeByRefs,
   resolveSingleLineListFallbackNumberingAction: () => resolveSingleLineListFallbackNumberingAction,
   resolveTargetParagraph: () => resolveTargetParagraph,
@@ -8287,7 +8291,10 @@ var MARKDOWN_PATTERNS = [
   { regex: /\*\*\+\+(.+?)\+\+\*\*/, format: { bold: true, underline: true } },
   // Bold: **text** or __text__
   { regex: /\*\*(.+?)\*\*/, format: { bold: true } },
-  { regex: /__(.+?)__/, format: { bold: true } },
+  // Underscore delimiters follow CommonMark flanking rules: not intraword, not part of a
+  // longer underscore run, and never around whitespace. So signature lines ("_____")
+  // and snake_case identifiers stay literal text.
+  { regex: /(?<![A-Za-z0-9_])__(?=[^_\s])(.+?)(?<=[^_\s])__(?![A-Za-z0-9_])/, format: { bold: true } },
   // Underline: ++text++
   { regex: /\+\+(.+?)\+\+/, format: { underline: true } },
   // Strikethrough: ~~text~~ or ~text~
@@ -8295,7 +8302,7 @@ var MARKDOWN_PATTERNS = [
   { regex: /~(.+?)~/, format: { strikethrough: true } },
   // Italic: *text* or _text_ (using lookahead only for compatibility)
   { regex: /\*(?!\*)(.+?)\*(?!\*)/, format: { italic: true } },
-  { regex: /_(?!_)(.+?)_(?!_)/, format: { italic: true } }
+  { regex: /(?<![A-Za-z0-9_])_(?=[^_\s])(.+?)(?<=[^_\s])_(?![A-Za-z0-9_])/, format: { italic: true } }
 ];
 function preprocessMarkdown(text2) {
   if (!text2) {
@@ -10466,6 +10473,23 @@ function withOoxmlSourceType(result) {
   }
   return { ...result, sourceType: classifyOoxmlSourceType(result.oxml) };
 }
+function hasUnattributedTrackedChange(node) {
+  if (!node) return false;
+  for (const localName4 of TRACKED_CHANGE_NAMES) {
+    for (const change of wordElementsByLocalName(node, localName4)) {
+      const author = change.getAttribute?.("w:author") || change.getAttribute?.("author") || (typeof change.getAttributeNS === "function" ? change.getAttributeNS(NS_W, "author") : null);
+      if (!author || !String(author).trim()) return true;
+    }
+  }
+  return false;
+}
+function resolveExistingRevisionsPolicy(policy, node, author) {
+  if (policy !== "auto") return policy;
+  const nodes = (Array.isArray(node) ? node : [node]).filter(Boolean);
+  const own = String(author || "").trim().toLowerCase();
+  const foreign = nodes.some((item) => containsTrackedChanges(item) && (hasUnattributedTrackedChange(item) || getTrackedChangeAuthors(item).some((name) => name.trim().toLowerCase() !== own)));
+  return foreign ? "slice-cross-author" : "merge-same-author";
+}
 
 // engine/paragraph-mark-revisions.js
 function localNameOf(node) {
@@ -10572,6 +10596,7 @@ function paragraphMarkPPrXml(kind, ctx = {}) {
 }
 
 // services/table-reconciliation.js
+var cellMarkdown = (text2, options) => options?.plainTextContent === true ? { cleanText: String(text2 ?? ""), formatHints: [] } : preprocessMarkdown(text2);
 function generateTableOoxml(tableData, options = {}) {
   const {
     generateRedlines = false,
@@ -10605,7 +10630,7 @@ function generateTableOoxml(tableData, options = {}) {
     let cellsXml = "";
     for (let c = 0; c < numCols; c++) {
       const cellText = row[c] || "";
-      const { cleanText, formatHints } = preprocessMarkdown(cellText);
+      const { cleanText, formatHints } = cellMarkdown(cellText, options);
       const runModel = [{
         kind: generateRedlines ? RunKind.INSERTION : RunKind.TEXT,
         text: cleanText,
@@ -10720,7 +10745,7 @@ function serializeVirtualGridToOoxml(grid, operations, options) {
     let cellsXml = "";
     const rowInsertMeta = generateRedlines ? createRevisionMetadata(author, revisionIdAllocator) : null;
     for (const cellText of op.cells) {
-      const { cleanText, formatHints } = preprocessMarkdown(cellText);
+      const { cleanText, formatHints } = cellMarkdown(cellText, options);
       const runModel = [{
         kind: generateRedlines ? RunKind.INSERTION : RunKind.TEXT,
         text: cleanText,
@@ -10794,7 +10819,7 @@ function reconcileMultiBlockCellContent(cell, newText, options) {
       }
       return;
     }
-    const { cleanText, formatHints } = preprocessMarkdown(line);
+    const { cleanText, formatHints } = cellMarkdown(line, options);
     const diffOps = computeWordLevelDiffOps(block.acceptedText, cleanText);
     const model = applyPatches(splitRunsAtDiffBoundaries(block.runModel, diffOps), diffOps, {
       generateRedlines,
@@ -10804,7 +10829,7 @@ function reconcileMultiBlockCellContent(cell, newText, options) {
     out += serializeToOoxml(model, block.pPr, formatHints, { author, generateRedlines, revisionIdAllocator });
   });
   for (let i2 = cell.blocks.length; i2 < lines.length; i2++) {
-    const { cleanText, formatHints } = preprocessMarkdown(lines[i2]);
+    const { cleanText, formatHints } = cellMarkdown(lines[i2], options);
     const runModel = [{
       kind: generateRedlines ? RunKind.INSERTION : RunKind.TEXT,
       text: cleanText,
@@ -10823,7 +10848,7 @@ function reconcileCellContent(cell, newText, options) {
     return reconcileMultiBlockCellContent(cell, newText, options);
   }
   const { generateRedlines, author, revisionIdAllocator = null } = options;
-  const { cleanText, formatHints } = preprocessMarkdown(newText);
+  const { cleanText, formatHints } = cellMarkdown(newText, options);
   const oldText = cell.getText();
   const diffOps = computeWordLevelDiffOps(oldText, cleanText);
   const baseBlock = cell.blocks[0] || { runModel: [], pPr: null };
@@ -10869,7 +10894,7 @@ function parseTable(text2) {
   }
   const isSeparatorLine = (line) => {
     const normalized = line.replace(/\s+/g, "");
-    return /^\|:?-{3,}:?(\|:?-{3,}:?)+\|?$/.test(normalized);
+    return /^\|:?-{3,}:?(?:(\|:?-{3,}:?)+\|?|\|)$/.test(normalized);
   };
   const hasHeader = lines.some(isSeparatorLine);
   const dataLines = lines.filter((line) => !isSeparatorLine(line));
@@ -11453,7 +11478,7 @@ var ReconciliationPipeline = class {
 };
 
 // pipeline/structured-content.js
-var TABLE_SEPARATOR = /^\s*\|?\s*:?-{3,}:?\s*(?:\|\s*:?-{3,}:?\s*)+\|?\s*$/;
+var TABLE_SEPARATOR = /^\s*(?:\|\s*:?-{3,}:?\s*\||\|?\s*:?-{3,}:?\s*(?:\|\s*:?-{3,}:?\s*)+\|?)\s*$/;
 function isBlank(line) {
   return !line || line.trim().length === 0;
 }
@@ -15110,7 +15135,7 @@ function keepUnchangedTextOutsideWrappers(diffs, mapping) {
 function noChanges(serializer, xmlDoc) {
   return withOoxmlSourceType({ oxml: serializer.serializeToString(xmlDoc), hasChanges: false });
 }
-function applyTableReconciliation(xmlDoc, modifiedText, serializer, parser, author, generateRedlines = true) {
+function applyTableReconciliation(xmlDoc, modifiedText, serializer, parser, author, generateRedlines = true, extra = {}) {
   const tableNodes = getElementsByTagNSOrTag(xmlDoc, NS_W, "tbl");
   const newTableData = parseTable(modifiedText);
   const hasNewContent = newTableData.rows.length > 0 || newTableData.headers.length > 0;
@@ -15126,7 +15151,8 @@ function applyTableReconciliation(xmlDoc, modifiedText, serializer, parser, auth
   const options = {
     generateRedlines,
     author,
-    revisionIdAllocator: getRevisionIdAllocatorForDocument(xmlDoc)
+    revisionIdAllocator: getRevisionIdAllocatorForDocument(xmlDoc),
+    plainTextContent: extra.plainTextContent === true
   };
   const reconciledOxml = serializeVirtualGridToOoxml(oldGrid, operations, options);
   const wrappedOxml = `<root xmlns:w="${NS_W}">${reconciledOxml}</root>`;
@@ -15146,14 +15172,14 @@ function applyTableReconciliation(xmlDoc, modifiedText, serializer, parser, auth
   targetTable.parentNode.replaceChild(importedTable, targetTable);
   return withOoxmlSourceType({ oxml: serializer.serializeToString(xmlDoc), hasChanges: true });
 }
-function applyTextToTableTransformation(xmlDoc, modifiedText, serializer, parser, author, generateRedlines) {
+function applyTextToTableTransformation(xmlDoc, modifiedText, serializer, parser, author, generateRedlines, extra = {}) {
   const revisionIdAllocator = getRevisionIdAllocatorForDocument(xmlDoc);
   const tableData = parseTable(modifiedText);
   if (!tableData || tableData.rows.length === 0 && tableData.headers.length === 0) {
     log("[OxmlEngine] Failed to parse table data from Markdown");
     return noChanges(serializer, xmlDoc);
   }
-  const tableOoxml = generateTableOoxml(tableData, { generateRedlines, author, revisionIdAllocator, trackAsBlock: true });
+  const tableOoxml = generateTableOoxml(tableData, { generateRedlines, author, revisionIdAllocator, trackAsBlock: true, plainTextContent: extra.plainTextContent === true });
   const tableDoc = parseOoxmlSafe(`<root xmlns:w="${NS_W}">${tableOoxml}</root>`, "application/xml").doc;
   if (!tableDoc) return noChanges(serializer, xmlDoc);
   const tableParseError = getXmlParseError(tableDoc);
@@ -15976,7 +16002,7 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
   const operationWarnings = [];
   let normalizedExistingRevisions = false;
   let preservedInsertedParagraphMark = null;
-  const existingRevisionsPolicy = options.existingRevisions || "merge-same-author";
+  let existingRevisionsPolicy = options.existingRevisions || "merge-same-author";
   const keepNormalizedNoOp = existingRevisionsPolicy === "accept-all-first-keep-normalized";
   const finalize = (result) => {
     const withStatus = { ...result };
@@ -16024,6 +16050,10 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
   const parsed = parseOoxmlSafe(inputOoxml, "text/xml");
   parseWarnings = parsed.warnings;
   let xmlDoc = parsed.doc;
+  if (existingRevisionsPolicy === "auto") {
+    existingRevisionsPolicy = resolveExistingRevisionsPolicy("auto", xmlDoc, author);
+    options = { ...options, existingRevisions: existingRevisionsPolicy };
+  }
   const parseError = xmlDoc ? getXmlParseError(xmlDoc) : null;
   if (parsed.error || parseError) {
     const message = parsed.error?.message || parseError?.textContent || "Could not parse OOXML input.";
@@ -16058,7 +16088,7 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
     if (existingRevisionsPolicy === "merge-same-author" || existingRevisionsPolicy === "slice-cross-author") {
       const authors = getTrackedChangeAuthors(xmlDoc);
       const currentAuthor = String(author || "").trim().toLowerCase();
-      const isSameAuthor = authors.length > 0 && authors.every((a) => a.trim().toLowerCase() === currentAuthor);
+      const isSameAuthor = authors.length > 0 && !hasUnattributedTrackedChange(xmlDoc) && authors.every((a) => a.trim().toLowerCase() === currentAuthor);
       if (isSameAuthor) {
         const commentIds = getCommentIdsInOoxml(xmlDoc);
         if (commentIds.length > 0) {
@@ -16215,7 +16245,7 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
       sanitizedText = structuredAnalysis.normalizedMarkdown;
     }
   }
-  const { cleanText: cleanModifiedText, formatHints } = preprocessMarkdown(sanitizedText);
+  const { cleanText: cleanModifiedText, formatHints } = options.plainTextContent === true ? { cleanText: sanitizedText, formatHints: [] } : preprocessMarkdown(sanitizedText);
   const { existingFormatHints, textSpans, paragraphs } = extractFormattingFromOoxml(xmlDoc);
   const hasLiteralTextChanges = existingRevisionsPolicy === "slice-cross-author" ? cleanModifiedText !== originalText : cleanModifiedText.trim() !== originalText.trim();
   const hasListStructureChange = !hasLiteralTextChanges && options.explicitStructuredContent === true && isListTargetLoose(cleanModifiedText) && !sourceMatchesListShape(paragraphs, cleanModifiedText);
@@ -16348,11 +16378,11 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
     if (isMarkdownTable && !hasTables) {
       recordRouteSelection(options, "table", { transformation: "text-to-table" });
       log("[OxmlEngine] Text-to-table transformation: generating new table from Markdown");
-      return finalize(applyTextToTableTransformation(xmlDoc, cleanModifiedText, serializer, null, author, generateRedlines));
+      return finalize(applyTextToTableTransformation(xmlDoc, cleanModifiedText, serializer, null, author, generateRedlines, { plainTextContent: options.plainTextContent === true }));
     }
     if (hasTables && isMarkdownTable) {
       recordRouteSelection(options, "table", { transformation: "table-reconciliation" });
-      return finalize(applyTableReconciliation(xmlDoc, cleanModifiedText, serializer, null, author, generateRedlines));
+      return finalize(applyTableReconciliation(xmlDoc, cleanModifiedText, serializer, null, author, generateRedlines, { plainTextContent: options.plainTextContent === true }));
     }
     if (usesSurgicalTextMode) {
       recordRouteSelection(options, "surgical", { tableScoped: hasTables });
@@ -20047,6 +20077,70 @@ function inspectDocumentParts(parts, options = {}) {
   };
 }
 
+// services/inspection-comparison.js
+var commentIdentity = (comment) => [comment.author ?? null, comment.text ?? "", comment.anchoredText || ""];
+function reviewSegments(segments = []) {
+  return segments.filter((segment) => segment.kind !== "baseline").reduce((result, segment) => {
+    const next = {
+      kind: segment.kind,
+      author: segment.author || null,
+      text: segment.text,
+      acceptedStart: segment.acceptedStart ?? null,
+      rejectedStart: segment.rejectedStart ?? null
+    };
+    const previous = result.at(-1);
+    const adjacent = (key) => previous[key] == null && next[key] == null || previous[key] != null && previous[key] + previous.text.length === next[key];
+    if (previous && previous.kind === next.kind && previous.author === next.author && adjacent("acceptedStart") && adjacent("rejectedStart")) previous.text += next.text;
+    else result.push(next);
+    return result;
+  }, []);
+}
+function inspectionReviewShape(inspection) {
+  const comments = inspection?.comments || [];
+  return {
+    paragraphs: (inspection?.paragraphs || []).map((paragraph) => ({
+      text: paragraph.exactText,
+      inTable: paragraph.inTable === true,
+      table: paragraph.table ? [paragraph.table.rowIndex, paragraph.table.cellIndex] : null,
+      list: paragraph.list ? [paragraph.list.format, paragraph.list.level, paragraph.list.label] : null,
+      review: {
+        present: paragraph.hasRevisions === true,
+        authors: [...paragraph.revisionAuthors || []].sort(),
+        segments: reviewSegments(paragraph.segments)
+      }
+    })),
+    comments: comments.map((comment) => {
+      const parent = comment.parentCommentId != null ? comments.find((item) => String(item.id) === String(comment.parentCommentId)) : null;
+      return [
+        ...commentIdentity(comment),
+        comment.done === true,
+        parent ? commentIdentity(parent) : comment.parentCommentId != null || comment.parentParaId ? "unresolved parent" : null
+      ];
+    }).map((item) => JSON.stringify(item)).sort()
+  };
+}
+function compareDocumentInspections(expected, actual) {
+  const left = inspectionReviewShape(expected);
+  const right = inspectionReviewShape(actual);
+  const differences = [];
+  const note = (path, a, b) => {
+    if (differences.length < 10 && JSON.stringify(a) !== JSON.stringify(b)) differences.push({ path, expected: a, actual: b });
+  };
+  note("paragraphs.length", left.paragraphs.length, right.paragraphs.length);
+  const count = Math.max(left.paragraphs.length, right.paragraphs.length);
+  for (let index = 0; index < count; index++) {
+    const a = left.paragraphs[index] ?? null;
+    const b = right.paragraphs[index] ?? null;
+    if (!a || !b) {
+      note(`paragraphs[${index}]`, a, b);
+      continue;
+    }
+    for (const key of ["text", "inTable", "table", "list", "review"]) note(`paragraphs[${index}].${key}`, a[key], b[key]);
+  }
+  note("comments", left.comments, right.comments);
+  return { matches: differences.length === 0, differences };
+}
+
 // services/comment-locator.js
 function createParagraphTextIndex(paragraph, options = {}) {
   const revisionView = options.revisionView === "current" ? "accepted" : options.revisionView || "accepted";
@@ -20521,7 +20615,7 @@ function applyCommentReplyToParts({ commentsXml, commentsExtendedXml = null, doc
     extendedDoc = parsed.doc;
   }
   const occupied = usedParaIds(commentsDoc, extendedDoc);
-  if (documentXml) for (const match of String(documentXml).matchAll(/w14:paraId="([0-9A-Fa-f]{8})"/g)) occupied.add(match[1].toUpperCase());
+  if (documentXml) for (const match of String(documentXml).matchAll(/\bw14:paraId="([0-9A-Fa-f]{8})"/g)) occupied.add(match[1].toUpperCase());
   const parentParagraph = commentThreadParagraph(parent);
   if (!parentParagraph) return { status: "error", error: { code: "PARENT_COMMENT_INVALID", message: `Parent comment '${parentCommentId}' has no paragraph.` } };
   let parentParaId = commentParaId(parent);
@@ -20584,232 +20678,6 @@ function applyCommentReplyToParts({ commentsXml, commentsExtendedXml = null, doc
   };
 }
 
-// engine/formatting-removal.js
-function removeNode2(node) {
-  if (node?.parentNode) {
-    node.parentNode.removeChild(node);
-  }
-}
-function removeFormattingFromRPr(rPr, formatTypes = ["all"]) {
-  if (!rPr) return null;
-  const rPrClone = rPr.cloneNode(true);
-  if (formatTypes.includes("all")) {
-    const toRemove = [
-      "w:b",
-      "w:i",
-      "w:u",
-      "w:strike",
-      "w:dstrike",
-      "w:color",
-      "w:sz",
-      "w:szCs",
-      "w:rFonts",
-      "w:highlight",
-      "w:vertAlign",
-      "w:spacing",
-      "w:w",
-      "w:kern",
-      "w:position"
-    ];
-    toRemove.forEach((tag) => {
-      const elements = rPrClone.querySelectorAll(`${tag}, ${tag.replace("w:", "")}`);
-      elements.forEach(removeNode2);
-    });
-  } else {
-    const tagMap = {
-      "bold": "w:b",
-      "italic": "w:i",
-      "underline": "w:u",
-      "strikethrough": "w:strike",
-      "doubleStrike": "w:dstrike",
-      "color": "w:color",
-      "highlight": "w:highlight",
-      "fontSize": "w:sz",
-      "fontSizeCs": "w:szCs",
-      // Complex script font size
-      "fontFamily": "w:rFonts",
-      "superscript": "w:vertAlign",
-      "subscript": "w:vertAlign"
-    };
-    formatTypes.forEach((type) => {
-      const tag = tagMap[type];
-      if (tag) {
-        const elements = rPrClone.querySelectorAll(`${tag}, ${tag.replace("w:", "")}`);
-        elements.forEach(removeNode2);
-      }
-    });
-  }
-  return rPrClone.children.length > 0 ? rPrClone : null;
-}
-function applyFormattingRemovalToOoxml(ooxmlString, targetText, formatTypes) {
-  if (!targetText || !ooxmlString) return ooxmlString;
-  const doc = parseOoxml(ooxmlString);
-  if (!doc) return ooxmlString;
-  const NS_W11 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
-  const runs = doc.getElementsByTagNameNS(NS_W11, "r");
-  const insertions = doc.getElementsByTagNameNS(NS_W11, "ins");
-  const allRuns = [...Array.from(runs)];
-  for (const ins of insertions) {
-    const insideRuns = ins.getElementsByTagNameNS(NS_W11, "r");
-    allRuns.push(...Array.from(insideRuns));
-  }
-  for (const run of allRuns) {
-    const textNodes = run.getElementsByTagNameNS(NS_W11, "t");
-    const runText = Array.from(textNodes).map((t) => t.textContent).join("");
-    if (runText.includes(targetText) || runText === targetText) {
-      const rPrElements = run.getElementsByTagNameNS(NS_W11, "rPr");
-      if (rPrElements.length > 0) {
-        const rPr = rPrElements[0];
-        const newRPr = removeFormattingFromRPr(rPr, formatTypes);
-        if (newRPr) {
-          if (rPr.parentNode) {
-            rPr.parentNode.replaceChild(newRPr, rPr);
-          }
-        } else {
-          removeNode2(rPr);
-        }
-      }
-    }
-  }
-  return serializeOoxml(doc);
-}
-var HIGHLIGHT_COLOR_MAP = {
-  "yellow": "yellow",
-  "green": "green",
-  "cyan": "cyan",
-  "magenta": "magenta",
-  "blue": "blue",
-  "red": "red",
-  "darkblue": "darkBlue",
-  "darkcyan": "darkCyan",
-  "darkgreen": "darkGreen",
-  "darkmagenta": "darkMagenta",
-  "darkred": "darkRed",
-  "darkyellow": "darkYellow",
-  "gray25": "lightGray",
-  "gray50": "darkGray",
-  "black": "black",
-  "white": "white"
-};
-function injectHighlightIntoRPr(doc, rPr, color = "yellow", options = {}) {
-  const NS_W11 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
-  const ooxmlColor = HIGHLIGHT_COLOR_MAP[color.toLowerCase()] || "yellow";
-  const generateRedlines = options?.generateRedlines ?? false;
-  const author = options?.author || getDefaultAuthor();
-  let rPrElement = rPr;
-  if (!rPrElement) {
-    rPrElement = createWordElement(doc, "w:rPr");
-  } else {
-    rPrElement = rPr.cloneNode(true);
-  }
-  let previousRPrState = null;
-  if (generateRedlines) {
-    previousRPrState = createWordElement(doc, "w:rPr");
-    Array.from(rPrElement.childNodes).forEach((child) => {
-      if (child.nodeName !== "w:rPrChange") {
-        previousRPrState.appendChild(child.cloneNode(true));
-      }
-    });
-  }
-  const existingHighlight = rPrElement.getElementsByTagNameNS(NS_W11, "highlight");
-  Array.from(existingHighlight).forEach(removeNode2);
-  const highlightEl = createWordElement(doc, "w:highlight");
-  highlightEl.setAttributeNS(NS_W11, "w:val", ooxmlColor);
-  rPrElement.appendChild(highlightEl);
-  if (generateRedlines && previousRPrState) {
-    const rPrChange = createWordElement(doc, "w:rPrChange");
-    const metadata = createRevisionMetadata(author, doc);
-    rPrChange.setAttribute("w:id", String(metadata.id));
-    rPrChange.setAttribute("w:author", metadata.author);
-    rPrChange.setAttribute("w:date", metadata.date);
-    rPrChange.appendChild(previousRPrState);
-    const existingChange = rPrElement.getElementsByTagNameNS(NS_W11, "rPrChange");
-    Array.from(existingChange).forEach(removeNode2);
-    rPrElement.appendChild(rPrChange);
-  }
-  return rPrElement;
-}
-function applyHighlightToOoxml(ooxmlString, targetText, color = "yellow", options = {}) {
-  if (!targetText || !ooxmlString) return ooxmlString;
-  const doc = parseOoxml(ooxmlString);
-  if (!doc) return ooxmlString;
-  let revisionIdAllocator;
-  if (options?._revisionIdAllocator instanceof RevisionIdAllocator) {
-    revisionIdAllocator = options._revisionIdAllocator;
-    seedRevisionIdsFromDocument(doc, revisionIdAllocator);
-  } else {
-    revisionIdAllocator = createRevisionIdAllocator(doc);
-  }
-  const NS_W11 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
-  const getRunText = (run) => {
-    const textNodes = run.getElementsByTagNameNS(NS_W11, "t");
-    return Array.from(textNodes).map((t) => t.textContent).join("");
-  };
-  const allRuns = Array.from(doc.getElementsByTagNameNS(NS_W11, "r"));
-  const sourceRunsWithClaimedRevisionIds = /* @__PURE__ */ new WeakSet();
-  const cloneRunWithText2 = (sourceRun, text2, shouldHighlight) => {
-    const clonedRun = sourceRun.cloneNode(true);
-    if (sourceRunsWithClaimedRevisionIds.has(sourceRun)) {
-      refreshRunPropertyChangeIds(clonedRun, revisionIdAllocator);
-    } else {
-      sourceRunsWithClaimedRevisionIds.add(sourceRun);
-    }
-    const textNodes = clonedRun.getElementsByTagNameNS(NS_W11, "t");
-    Array.from(textNodes).forEach(removeNode2);
-    const newText = createWordElement(doc, "w:t");
-    newText.setAttribute("xml:space", "preserve");
-    newText.textContent = text2;
-    clonedRun.appendChild(newText);
-    if (shouldHighlight) {
-      const rPrElements = clonedRun.getElementsByTagNameNS(NS_W11, "rPr");
-      const existingRPr = rPrElements.length > 0 ? rPrElements[0] : null;
-      const newRPr = injectHighlightIntoRPr(doc, existingRPr, color, options);
-      if (existingRPr) {
-        clonedRun.replaceChild(newRPr, existingRPr);
-      } else {
-        clonedRun.insertBefore(newRPr, clonedRun.firstChild);
-      }
-    }
-    return clonedRun;
-  };
-  for (const run of allRuns) {
-    const runText = getRunText(run);
-    if (!runText) continue;
-    const matchIndexes = [];
-    let searchOffset = 0;
-    while (searchOffset <= runText.length - targetText.length) {
-      const matchIndex = runText.indexOf(targetText, searchOffset);
-      if (matchIndex === -1) break;
-      matchIndexes.push(matchIndex);
-      searchOffset = matchIndex + targetText.length;
-    }
-    if (matchIndexes.length === 0) continue;
-    const parent = run.parentNode;
-    if (!parent) {
-      console.warn("[Highlight] Run parent is null; skipping. Likely already processed.");
-      continue;
-    }
-    const fragment = doc.createDocumentFragment();
-    let cursor = 0;
-    for (const matchIndex of matchIndexes) {
-      if (matchIndex > cursor) {
-        fragment.appendChild(cloneRunWithText2(run, runText.slice(cursor, matchIndex), false));
-      }
-      fragment.appendChild(cloneRunWithText2(
-        run,
-        runText.slice(matchIndex, matchIndex + targetText.length),
-        true
-      ));
-      cursor = matchIndex + targetText.length;
-    }
-    if (cursor < runText.length) {
-      fragment.appendChild(cloneRunWithText2(run, runText.slice(cursor), false));
-    }
-    parent.replaceChild(fragment, run);
-  }
-  return serializeOoxml(doc);
-}
-
 // services/package-parts.js
 var WORD_ML = "application/vnd.openxmlformats-officedocument.wordprocessingml";
 var REL_OFFICE_DOC = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
@@ -21097,31 +20965,34 @@ async function ensureNumberingArtifactsInZip(zip, numberingXmlList, options = {}
     }
   }
 }
+function mergeCommentsPartXml(existingXml, commentsXml, options = {}) {
+  if (!existingXml || options.replaceExisting === true) return commentsXml;
+  const existingDoc = parseXmlStrictStandalone(existingXml, "word/comments.xml (existing)");
+  const incomingDoc = parseXmlStrictStandalone(commentsXml, "word/comments.xml (incoming)");
+  const incomingComments = Array.from(incomingDoc.documentElement.getElementsByTagNameNS(NS_W7, "comment"));
+  if (incomingComments.length === 0) return existingXml;
+  const existingRoot = existingDoc.documentElement;
+  const usedIds = new Set(
+    Array.from(existingRoot.getElementsByTagNameNS(NS_W7, "comment")).map((comment) => comment.getAttribute("w:id") || comment.getAttribute("id")).filter(Boolean)
+  );
+  for (const incomingComment of incomingComments) {
+    const id = incomingComment.getAttribute("w:id") || incomingComment.getAttribute("id");
+    if (id && usedIds.has(id)) {
+      throw Object.assign(new Error(`Duplicate comment id: ${id}`), { code: "DUPLICATE_COMMENT_ID", commentId: id });
+    }
+    if (id) usedIds.add(id);
+    existingRoot.appendChild(existingDoc.importNode(incomingComment, true));
+  }
+  return createSerializer().serializeToString(existingDoc);
+}
 async function ensureCommentsArtifactsInZip(zip, commentsXml, options = {}) {
   const onInfo = typeof options?.onInfo === "function" ? options.onInfo : () => {
   };
   if (!commentsXml) return;
   const serializer = createSerializer();
   const existingText = await readZipText(zip, COMMENTS_PATH);
-  if (!existingText || options.replaceExisting === true) {
-    onInfo("[Demo] Adding comments.xml");
-    zip.file(COMMENTS_PATH, commentsXml);
-  } else {
-    const existingDoc = parseXmlStrictStandalone(existingText, "word/comments.xml (existing)");
-    const incomingDoc = parseXmlStrictStandalone(commentsXml, "word/comments.xml (incoming)");
-    const existingRoot = existingDoc.documentElement;
-    const existingIds = new Set(
-      Array.from(existingRoot.getElementsByTagNameNS(NS_W7, "comment")).map((comment) => comment.getAttribute("w:id") || comment.getAttribute("id")).filter(Boolean)
-    );
-    for (const incomingComment of Array.from(incomingDoc.documentElement.getElementsByTagNameNS(NS_W7, "comment"))) {
-      const id = incomingComment.getAttribute("w:id") || incomingComment.getAttribute("id");
-      if (id && existingIds.has(id)) {
-        throw new Error(`Duplicate comment id: ${id}`);
-      }
-      existingRoot.appendChild(existingDoc.importNode(incomingComment, true));
-    }
-    zip.file(COMMENTS_PATH, serializer.serializeToString(existingDoc));
-  }
+  if (!existingText || options.replaceExisting === true) onInfo("[Demo] Adding comments.xml");
+  zip.file(COMMENTS_PATH, mergeCommentsPartXml(existingText, commentsXml, options));
   const ctText = await readZipText(zip, CONTENT_TYPES_PATH);
   if (ctText) {
     const ctDoc = parseXmlStrictStandalone(ctText, CONTENT_TYPES_PATH);
@@ -21357,6 +21228,318 @@ async function validateDocxPackage(zip) {
   }
 }
 
+// services/comment-parts-merge.js
+var PART_KEYS = Object.freeze({
+  comments: "commentsXml",
+  commentsExtended: "commentsExtendedXml",
+  commentsIds: "commentsIdsXml",
+  commentsExtensible: "commentsExtensibleXml"
+});
+var partsOf = (parts) => Object.fromEntries(Object.values(PART_KEYS).map((key) => [key, parts?.[key] || null]));
+function mergeCommentParts(parts = {}, output = {}) {
+  const before = partsOf(parts);
+  const after = { ...before };
+  const fail = (error2) => ({ status: "error", hasChanges: false, parts: before, changedParts: [], addedParts: [], error: error2 });
+  const commentsMode = output?.commentsXmlMode === "replace" ? "replace" : "merge";
+  const extendedMode = output?.commentsExtendedXmlMode === "replace" ? "replace" : "merge";
+  for (const [label, value] of [
+    ...Object.values(PART_KEYS).map((key) => [`parts.${key}`, before[key]]),
+    ["output.commentsXml", output?.commentsXml],
+    ["output.commentsExtendedXml", output?.commentsExtendedXml]
+  ]) {
+    if (value != null && typeof value !== "string") {
+      return fail({ code: "INVALID_COMMENT_PARTS", message: `${label} must be an XML string, null or omitted (got ${typeof value}).` });
+    }
+  }
+  const requirePart = (xml, part, rootName, label) => {
+    let doc;
+    try {
+      doc = parseXmlStrictStandalone(xml, label);
+    } catch (error2) {
+      throw Object.assign(error2, { part });
+    }
+    if (doc.documentElement?.localName !== rootName) {
+      throw Object.assign(new Error(`${label}: expected a <${rootName}> root element, found <${doc.documentElement?.localName || "none"}>.`), { code: "INVALID_COMMENT_PARTS", part });
+    }
+    return doc;
+  };
+  try {
+    if (output?.commentsXml) {
+      const incomingDoc = requirePart(output.commentsXml, "comments", "comments", "word/comments.xml (incoming)");
+      const seen = /* @__PURE__ */ new Set();
+      for (const node of Array.from(incomingDoc.getElementsByTagNameNS("*", "comment"))) {
+        const id = node.getAttribute("w:id") || node.getAttribute("id");
+        if (!id) continue;
+        if (seen.has(id)) {
+          throw Object.assign(new Error(`Duplicate comment id: ${id}`), { code: "DUPLICATE_COMMENT_ID", commentId: id, part: "comments" });
+        }
+        seen.add(id);
+      }
+      if (before.commentsXml) requirePart(before.commentsXml, "comments", "comments", "word/comments.xml (existing)");
+      if (before.commentsIdsXml) requirePart(before.commentsIdsXml, "commentsIds", "commentsIds", "word/commentsIds.xml (existing)");
+      if (before.commentsExtensibleXml) requirePart(before.commentsExtensibleXml, "commentsExtensible", "commentsExtensible", "word/commentsExtensible.xml (existing)");
+      after.commentsXml = mergeCommentsPartXml(before.commentsXml, output.commentsXml, { replaceExisting: commentsMode === "replace" });
+      Object.assign(after, reconcileCommentSiblingParts({
+        commentsXml: after.commentsXml,
+        commentsIdsXml: after.commentsIdsXml,
+        commentsExtensibleXml: after.commentsExtensibleXml
+      }));
+    }
+    if (output?.commentsExtendedXml) {
+      if (extendedMode !== "replace" && before.commentsExtendedXml) {
+        return fail({
+          code: "UNSUPPORTED_EXISTING_COMMENT_THREAD_METADATA",
+          part: "commentsExtended",
+          message: 'The output carries a commentsExtended delta (mode "merge") for parts that already have thread metadata; a delta cannot be merged into an existing commentsExtended.xml. Nothing was merged.'
+        });
+      }
+      requirePart(output.commentsExtendedXml, "commentsExtended", "commentsEx", "word/commentsExtended.xml (incoming)");
+      after.commentsExtendedXml = output.commentsExtendedXml;
+    }
+  } catch (error2) {
+    return fail({
+      code: error2?.code || "COMMENT_PARTS_MERGE_FAILED",
+      message: error2?.message || String(error2),
+      ...error2?.part || error2?.code === "DUPLICATE_COMMENT_ID" ? { part: error2.part || "comments" } : {},
+      ...error2?.commentId ? { commentId: error2.commentId } : {}
+    });
+  }
+  const changedParts = [];
+  const addedParts = [];
+  for (const [name, key] of Object.entries(PART_KEYS)) {
+    if (after[key] === before[key]) continue;
+    changedParts.push(name);
+    if (!before[key]) addedParts.push(name);
+  }
+  return { status: "ok", hasChanges: changedParts.length > 0, parts: after, changedParts, addedParts };
+}
+
+// engine/formatting-removal.js
+function removeNode2(node) {
+  if (node?.parentNode) {
+    node.parentNode.removeChild(node);
+  }
+}
+function removeFormattingFromRPr(rPr, formatTypes = ["all"]) {
+  if (!rPr) return null;
+  const rPrClone = rPr.cloneNode(true);
+  if (formatTypes.includes("all")) {
+    const toRemove = [
+      "w:b",
+      "w:i",
+      "w:u",
+      "w:strike",
+      "w:dstrike",
+      "w:color",
+      "w:sz",
+      "w:szCs",
+      "w:rFonts",
+      "w:highlight",
+      "w:vertAlign",
+      "w:spacing",
+      "w:w",
+      "w:kern",
+      "w:position"
+    ];
+    toRemove.forEach((tag) => {
+      const elements = rPrClone.querySelectorAll(`${tag}, ${tag.replace("w:", "")}`);
+      elements.forEach(removeNode2);
+    });
+  } else {
+    const tagMap = {
+      "bold": "w:b",
+      "italic": "w:i",
+      "underline": "w:u",
+      "strikethrough": "w:strike",
+      "doubleStrike": "w:dstrike",
+      "color": "w:color",
+      "highlight": "w:highlight",
+      "fontSize": "w:sz",
+      "fontSizeCs": "w:szCs",
+      // Complex script font size
+      "fontFamily": "w:rFonts",
+      "superscript": "w:vertAlign",
+      "subscript": "w:vertAlign"
+    };
+    formatTypes.forEach((type) => {
+      const tag = tagMap[type];
+      if (tag) {
+        const elements = rPrClone.querySelectorAll(`${tag}, ${tag.replace("w:", "")}`);
+        elements.forEach(removeNode2);
+      }
+    });
+  }
+  return rPrClone.children.length > 0 ? rPrClone : null;
+}
+function applyFormattingRemovalToOoxml(ooxmlString, targetText, formatTypes) {
+  if (!targetText || !ooxmlString) return ooxmlString;
+  const doc = parseOoxml(ooxmlString);
+  if (!doc) return ooxmlString;
+  const NS_W11 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+  const runs = doc.getElementsByTagNameNS(NS_W11, "r");
+  const insertions = doc.getElementsByTagNameNS(NS_W11, "ins");
+  const allRuns = [...Array.from(runs)];
+  for (const ins of insertions) {
+    const insideRuns = ins.getElementsByTagNameNS(NS_W11, "r");
+    allRuns.push(...Array.from(insideRuns));
+  }
+  for (const run of allRuns) {
+    const textNodes = run.getElementsByTagNameNS(NS_W11, "t");
+    const runText = Array.from(textNodes).map((t) => t.textContent).join("");
+    if (runText.includes(targetText) || runText === targetText) {
+      const rPrElements = run.getElementsByTagNameNS(NS_W11, "rPr");
+      if (rPrElements.length > 0) {
+        const rPr = rPrElements[0];
+        const newRPr = removeFormattingFromRPr(rPr, formatTypes);
+        if (newRPr) {
+          if (rPr.parentNode) {
+            rPr.parentNode.replaceChild(newRPr, rPr);
+          }
+        } else {
+          removeNode2(rPr);
+        }
+      }
+    }
+  }
+  return serializeOoxml(doc);
+}
+var HIGHLIGHT_COLOR_MAP = {
+  "yellow": "yellow",
+  "green": "green",
+  "cyan": "cyan",
+  "magenta": "magenta",
+  "blue": "blue",
+  "red": "red",
+  "darkblue": "darkBlue",
+  "darkcyan": "darkCyan",
+  "darkgreen": "darkGreen",
+  "darkmagenta": "darkMagenta",
+  "darkred": "darkRed",
+  "darkyellow": "darkYellow",
+  "gray25": "lightGray",
+  "gray50": "darkGray",
+  "black": "black",
+  "white": "white"
+};
+function injectHighlightIntoRPr(doc, rPr, color = "yellow", options = {}) {
+  const NS_W11 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+  const ooxmlColor = HIGHLIGHT_COLOR_MAP[color.toLowerCase()] || "yellow";
+  const generateRedlines = options?.generateRedlines ?? false;
+  const author = options?.author || getDefaultAuthor();
+  let rPrElement = rPr;
+  if (!rPrElement) {
+    rPrElement = createWordElement(doc, "w:rPr");
+  } else {
+    rPrElement = rPr.cloneNode(true);
+  }
+  let previousRPrState = null;
+  if (generateRedlines) {
+    previousRPrState = createWordElement(doc, "w:rPr");
+    Array.from(rPrElement.childNodes).forEach((child) => {
+      if (child.nodeName !== "w:rPrChange") {
+        previousRPrState.appendChild(child.cloneNode(true));
+      }
+    });
+  }
+  const existingHighlight = rPrElement.getElementsByTagNameNS(NS_W11, "highlight");
+  Array.from(existingHighlight).forEach(removeNode2);
+  const highlightEl = createWordElement(doc, "w:highlight");
+  highlightEl.setAttributeNS(NS_W11, "w:val", ooxmlColor);
+  rPrElement.appendChild(highlightEl);
+  if (generateRedlines && previousRPrState) {
+    const rPrChange = createWordElement(doc, "w:rPrChange");
+    const metadata = createRevisionMetadata(author, doc);
+    rPrChange.setAttribute("w:id", String(metadata.id));
+    rPrChange.setAttribute("w:author", metadata.author);
+    rPrChange.setAttribute("w:date", metadata.date);
+    rPrChange.appendChild(previousRPrState);
+    const existingChange = rPrElement.getElementsByTagNameNS(NS_W11, "rPrChange");
+    Array.from(existingChange).forEach(removeNode2);
+    rPrElement.appendChild(rPrChange);
+  }
+  return rPrElement;
+}
+function applyHighlightToOoxml(ooxmlString, targetText, color = "yellow", options = {}) {
+  if (!targetText || !ooxmlString) return ooxmlString;
+  const doc = parseOoxml(ooxmlString);
+  if (!doc) return ooxmlString;
+  let revisionIdAllocator;
+  if (options?._revisionIdAllocator instanceof RevisionIdAllocator) {
+    revisionIdAllocator = options._revisionIdAllocator;
+    seedRevisionIdsFromDocument(doc, revisionIdAllocator);
+  } else {
+    revisionIdAllocator = createRevisionIdAllocator(doc);
+  }
+  const NS_W11 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+  const getRunText = (run) => {
+    const textNodes = run.getElementsByTagNameNS(NS_W11, "t");
+    return Array.from(textNodes).map((t) => t.textContent).join("");
+  };
+  const allRuns = Array.from(doc.getElementsByTagNameNS(NS_W11, "r"));
+  const sourceRunsWithClaimedRevisionIds = /* @__PURE__ */ new WeakSet();
+  const cloneRunWithText2 = (sourceRun, text2, shouldHighlight) => {
+    const clonedRun = sourceRun.cloneNode(true);
+    if (sourceRunsWithClaimedRevisionIds.has(sourceRun)) {
+      refreshRunPropertyChangeIds(clonedRun, revisionIdAllocator);
+    } else {
+      sourceRunsWithClaimedRevisionIds.add(sourceRun);
+    }
+    const textNodes = clonedRun.getElementsByTagNameNS(NS_W11, "t");
+    Array.from(textNodes).forEach(removeNode2);
+    const newText = createWordElement(doc, "w:t");
+    newText.setAttribute("xml:space", "preserve");
+    newText.textContent = text2;
+    clonedRun.appendChild(newText);
+    if (shouldHighlight) {
+      const rPrElements = clonedRun.getElementsByTagNameNS(NS_W11, "rPr");
+      const existingRPr = rPrElements.length > 0 ? rPrElements[0] : null;
+      const newRPr = injectHighlightIntoRPr(doc, existingRPr, color, options);
+      if (existingRPr) {
+        clonedRun.replaceChild(newRPr, existingRPr);
+      } else {
+        clonedRun.insertBefore(newRPr, clonedRun.firstChild);
+      }
+    }
+    return clonedRun;
+  };
+  for (const run of allRuns) {
+    const runText = getRunText(run);
+    if (!runText) continue;
+    const matchIndexes = [];
+    let searchOffset = 0;
+    while (searchOffset <= runText.length - targetText.length) {
+      const matchIndex = runText.indexOf(targetText, searchOffset);
+      if (matchIndex === -1) break;
+      matchIndexes.push(matchIndex);
+      searchOffset = matchIndex + targetText.length;
+    }
+    if (matchIndexes.length === 0) continue;
+    const parent = run.parentNode;
+    if (!parent) {
+      console.warn("[Highlight] Run parent is null; skipping. Likely already processed.");
+      continue;
+    }
+    const fragment = doc.createDocumentFragment();
+    let cursor = 0;
+    for (const matchIndex of matchIndexes) {
+      if (matchIndex > cursor) {
+        fragment.appendChild(cloneRunWithText2(run, runText.slice(cursor, matchIndex), false));
+      }
+      fragment.appendChild(cloneRunWithText2(
+        run,
+        runText.slice(matchIndex, matchIndex + targetText.length),
+        true
+      ));
+      cursor = matchIndex + targetText.length;
+    }
+    if (cursor < runText.length) {
+      fragment.appendChild(cloneRunWithText2(run, runText.slice(cursor), false));
+    }
+    parent.replaceChild(fragment, run);
+  }
+  return serializeOoxml(doc);
+}
+
 // orchestration/route-plan.js
 var RoutePlanKind = Object.freeze({
   STRUCTURED_LIST_DIRECT: "structured_list_direct",
@@ -22823,6 +23006,7 @@ var SUPPORTED_OPERATION_TYPES = /* @__PURE__ */ new Set([
   "highlight"
 ]);
 var EXISTING_REVISIONS_POLICIES = Object.freeze([
+  "auto",
   "merge-same-author",
   "slice-cross-author",
   "reject-input",
@@ -25060,7 +25244,7 @@ function deriveParagraphThenTableAppend(modifiedText) {
   const tableLines = lines.slice(1);
   if (!tableLines.every((line) => line.trim().startsWith("|"))) return null;
   const separator = tableLines[1].replace(/\s+/g, "");
-  if (!/^\|:?-{3,}:?(\|:?-{3,}:?)+\|?$/.test(separator)) return null;
+  if (!/^\|:?-{3,}:?(?:(\|:?-{3,}:?)+\|?|\|)$/.test(separator)) return null;
   return { paragraphMarkdown: lines[0].trim(), tableText: tableLines.join("\n") };
 }
 
@@ -25690,7 +25874,10 @@ async function buildInsertedPlainParagraph(xmlDoc, anchorParagraph, text2, revis
     String(text2 || ""),
     {
       author,
-      generateRedlines: false
+      generateRedlines: false,
+      // A caller's structuredContent: false keeps inserted paragraphs plain too: no headings,
+      // and inline Markdown markers stay literal.
+      ...options.plainTextContent === true ? { structuredContent: false, plainTextContent: true } : {}
     }
   );
   let sourceParagraph = null;
@@ -26877,13 +27064,17 @@ async function applyToParagraphByExactText(documentXml, targetText, modifiedText
       }
     };
   }
+  const autoExistingRevisions = options.existingRevisions === "auto";
+  if (autoExistingRevisions) {
+    options = { ...options, existingRevisions: resolveExistingRevisionsPolicy("auto", targetParagraph, author) };
+  }
   const hasRevisions = containsTrackedChanges(targetParagraph);
   const existingPolicy = options.existingRevisions || "merge-same-author";
   if (hasRevisions && existingPolicy !== "accept-all-first" && existingPolicy !== "accept-all-first-keep-normalized") {
     if (existingPolicy === "merge-same-author" || existingPolicy === "slice-cross-author") {
       const authors = getTrackedChangeAuthors(targetParagraph);
       const opAuthor = String(author || "").trim().toLowerCase();
-      const allSame = authors.length > 0 && authors.every((a) => a.trim().toLowerCase() === opAuthor);
+      const allSame = authors.length > 0 && !hasUnattributedTrackedChange(targetParagraph) && authors.every((a) => a.trim().toLowerCase() === opAuthor);
       if (!allSame && existingPolicy === "merge-same-author") {
         return {
           documentXml,
@@ -26892,7 +27083,7 @@ async function applyToParagraphByExactText(documentXml, targetText, modifiedText
           status: "error",
           error: {
             code: "EXISTING_REVISIONS",
-            message: `Target paragraph contains tracked changes from another author (${authors.length ? authors.join(", ") : "unattributed"}). Use existingRevisions: "slice-cross-author" for a surgical edit that preserves reviewer history; accepting or rejecting revisions requires separate authorization.`,
+            message: `Target paragraph contains tracked changes from another author (${[...authors, ...hasUnattributedTrackedChange(targetParagraph) ? ["unattributed"] : []].join(", ")}). Use existingRevisions: "slice-cross-author" for a surgical edit that preserves reviewer history; accepting or rejecting revisions requires separate authorization.`,
             revisionAuthors: authors,
             currentPolicy: existingPolicy
           }
@@ -27034,6 +27225,9 @@ async function applyToParagraphByExactText(documentXml, targetText, modifiedText
     onWarn
   }) : typeof targetText === "string" && /\r?\n/.test(targetText) ? findReconstructionParagraphRange(xmlDoc, targetText) : null;
   const hasExplicitRangeScope = Array.isArray(explicitRangeParagraphs) && explicitRangeParagraphs.length > 0;
+  if (autoExistingRevisions && hasExplicitRangeScope) {
+    options = { ...options, existingRevisions: resolveExistingRevisionsPolicy("auto", explicitRangeParagraphs, author) };
+  }
   if (!useTableScope && hasExplicitRangeScope) {
     const insertionEntries = buildExplicitRangeInsertionEntries(explicitRangeParagraphs, effectiveModifiedText);
     if (insertionEntries && insertionEntries.length > 0) {
@@ -27209,7 +27403,7 @@ async function applyToParagraphByExactText(documentXml, targetText, modifiedText
         author,
         // A wholly inserted paragraph must track its own paragraph mark; otherwise Word's
         // Reject All removes the text but leaves an empty paragraph behind.
-        { generateRedlines, trackParagraphMark: true }
+        { generateRedlines, trackParagraphMark: true, plainTextContent: options.plainTextContent === true }
       );
       const imported = xmlDoc.importNode(plainParagraph, true);
       ensureParagraphIdsOnImportedNode(imported, operationSession);
@@ -27348,6 +27542,7 @@ async function applyToParagraphByExactText(documentXml, targetText, modifiedText
     existingRevisions: options.existingRevisions || "merge-same-author",
     structuredContent: options.structuredContent !== false,
     explicitStructuredContent: options.explicitStructuredContent === true,
+    plainTextContent: options.plainTextContent === true,
     _revisionIdAllocator: revisionIdAllocator,
     _isolatedTableCell: useTableScope
   }) : await applyRedlineToOxml2(scopedXml, originalTextForApply, effectiveModifiedText, {
@@ -27359,6 +27554,7 @@ async function applyToParagraphByExactText(documentXml, targetText, modifiedText
     pairReplacements: options.pairReplacements === true,
     insertionAffinity: options.insertionAffinity || null,
     literalTextEdit: options.literalTextEdit === true,
+    plainTextContent: options.plainTextContent === true,
     _revisionIdAllocator: revisionIdAllocator,
     _isolatedTableCell: useTableScope
   });
@@ -28369,7 +28565,31 @@ function verifyUntrackedLocality({ before, after, targetSourceIndex, beforeViews
   }
   return violations.length ? { ok: false, violations } : { ok: true };
 }
-function verifyNumberingReferences({ before, after, numberingXmls, beforeViews = null, afterViews = null }) {
+var numberingDefinitionCache = /* @__PURE__ */ new Map();
+var NUMBERING_DEFINITION_CACHE_SIZE = 8;
+function parseNumberingDefinitions(text2) {
+  const cached = numberingDefinitionCache.get(text2);
+  if (cached) return cached;
+  const abstractLevels = /* @__PURE__ */ new Map();
+  for (const match of text2.matchAll(/<(?:\w+:)?abstractNum\b([^>]*)>([\s\S]*?)<\/(?:\w+:)?abstractNum>/g)) {
+    const id = /abstractNumId="([^"]*)"/.exec(match[1])?.[1];
+    if (id == null) continue;
+    const levels = abstractLevels.get(id) || /* @__PURE__ */ new Set();
+    for (const lvl of match[2].matchAll(/<(?:\w+:)?lvl\b[^>]*?ilvl="([^"]*)"/g)) levels.add(lvl[1]);
+    abstractLevels.set(id, levels);
+  }
+  const numToAbstract = /* @__PURE__ */ new Map();
+  for (const match of text2.matchAll(/<(?:\w+:)?num\b([^>]*)>([\s\S]*?)<\/(?:\w+:)?num>/g)) {
+    const id = /numId="([^"]*)"/.exec(match[1])?.[1];
+    const abstractId = /abstractNumId[^>]*?val="([^"]*)"/.exec(match[2])?.[1];
+    if (id != null && abstractId != null) numToAbstract.set(id, abstractId);
+  }
+  const definitions = { abstractLevels, numToAbstract };
+  if (numberingDefinitionCache.size >= NUMBERING_DEFINITION_CACHE_SIZE) numberingDefinitionCache.delete(numberingDefinitionCache.keys().next().value);
+  numberingDefinitionCache.set(text2, definitions);
+  return definitions;
+}
+function verifyNumberingReferences({ before, after, numberingXmls }) {
   const references = (documentNode) => {
     const found = /* @__PURE__ */ new Map();
     for (const numIdNode of getAllReferencedNumIdElements(documentNode)) {
@@ -28385,21 +28605,7 @@ function verifyNumberingReferences({ before, after, numberingXmls, beforeViews =
   const used = references(after);
   if (used.size === 0) return { ok: true };
   const known = references(before);
-  const text2 = (numberingXmls || []).filter(Boolean).join("\n");
-  const abstractLevels = /* @__PURE__ */ new Map();
-  for (const match of text2.matchAll(/<(?:\w+:)?abstractNum\b([^>]*)>([\s\S]*?)<\/(?:\w+:)?abstractNum>/g)) {
-    const id = /abstractNumId="([^"]*)"/.exec(match[1])?.[1];
-    if (id == null) continue;
-    const levels = abstractLevels.get(id) || /* @__PURE__ */ new Set();
-    for (const lvl of match[2].matchAll(/<(?:\w+:)?lvl\b[^>]*?ilvl="([^"]*)"/g)) levels.add(lvl[1]);
-    abstractLevels.set(id, levels);
-  }
-  const numToAbstract = /* @__PURE__ */ new Map();
-  for (const match of text2.matchAll(/<(?:\w+:)?num\b([^>]*)>([\s\S]*?)<\/(?:\w+:)?num>/g)) {
-    const id = /numId="([^"]*)"/.exec(match[1])?.[1];
-    const abstractId = /abstractNumId[^>]*?val="([^"]*)"/.exec(match[2])?.[1];
-    if (id != null && abstractId != null) numToAbstract.set(id, abstractId);
-  }
+  const { abstractLevels, numToAbstract } = parseNumberingDefinitions((numberingXmls || []).filter(Boolean).join("\n"));
   const violations = [];
   for (const [numId, levels] of used) {
     if (known.has(numId)) continue;
@@ -28748,6 +28954,7 @@ async function applyOperationToDocumentXml(documentXml, op, author, runtimeConte
     ...operation.existingRevisions ? { existingRevisions: operation.existingRevisions } : {},
     structuredContent: typeof operation.structuredContent === "boolean" ? operation.structuredContent : options.structuredContent !== false,
     explicitStructuredContent: operation.structuredContent === true,
+    plainTextContent: operation.structuredContent === false || operation.structuredContent == null && options.structuredContent === false,
     ...operation._localizedReplacementCompilation && operation.structuredContent !== true ? { literalTextEdit: true } : {},
     pairReplacements: typeof operation.pairReplacements === "boolean" ? operation.pairReplacements : options.pairReplacements !== false,
     ...operation.insertionAffinity ? { insertionAffinity: operation.insertionAffinity } : {},
@@ -30002,35 +30209,44 @@ function preflightOperations(documentXml, operations, author, options = {}) {
       const anchor = operation.operationKind === "comment" ? operation.textToComment || paragraphText : operation.operationKind === "highlight" ? operation.textToHighlight : operation.operationKind === "format" ? operation.textToFormat : null;
       const anchorResolution = operation.operationKind === "comment" && anchor != null ? resolveTextInParagraphIndex(createParagraphTextIndex(paragraph, { revisionView: targetView }), anchor) : null;
       const anchorFound = anchor == null || (anchorResolution ? anchorResolution.found : paragraphText.includes(anchor));
+      const rangeParagraphs = (opType) => {
+        if (operation.targetEndRef) {
+          return resolveParagraphRangeByRefs(xmlDoc, operation.targetRef, operation.targetEndRef, {
+            opType,
+            targetRefSnapshot: options.targetRefSnapshot || null,
+            onInfo: options.onInfo,
+            onWarn: options.onWarn
+          });
+        }
+        if (!operation.targetEndDescriptor) return [paragraph];
+        const endResolved = resolveTargetParagraph(xmlDoc, {
+          targetText: operation.targetEndDescriptor.text,
+          targetRef: operation.targetEndDescriptor.index,
+          targetDescriptor: operation.targetEndDescriptor,
+          opType,
+          strictAmbiguity: strictTargets,
+          paragraphMetadataIndex: currentMetadataIndex,
+          metadataIndices,
+          onInfo: options.onInfo,
+          onWarn: options.onWarn
+        });
+        const allParagraphs = getDocumentParagraphNodes(xmlDoc);
+        const startIndex = allParagraphs.indexOf(paragraph);
+        const endIndex = allParagraphs.indexOf(endResolved?.paragraph);
+        return startIndex >= 0 && endIndex >= startIndex ? allParagraphs.slice(startIndex, endIndex + 1) : null;
+      };
       const hasRevisions = containsTrackedChanges(paragraph);
-      const existingPolicy = operation.existingRevisions || options.existingRevisions || "merge-same-author";
+      const requestedPolicy = operation.existingRevisions || options.existingRevisions || "merge-same-author";
+      const existingPolicy = resolveExistingRevisionsPolicy(
+        requestedPolicy,
+        requestedPolicy === "auto" && operation.operationKind === "redline" && (operation.targetEndRef || operation.targetEndDescriptor) ? rangeParagraphs("redline") || paragraph : paragraph,
+        authorUsed
+      );
       const deletingWholeParagraph = operation.operationKind === "redline" && operation.modified === "";
       const commentIds = deletingWholeParagraph ? getCommentIdsInParagraph(paragraph) : [];
       let error2 = null;
       if (operation.operationKind === "restore") {
-        let restorationParagraphs = operation.targetEndRef ? resolveParagraphRangeByRefs(xmlDoc, operation.targetRef, operation.targetEndRef, {
-          opType: "restore",
-          targetRefSnapshot: options.targetRefSnapshot || null,
-          onInfo: options.onInfo,
-          onWarn: options.onWarn
-        }) : [paragraph];
-        if (!operation.targetEndRef && operation.targetEndDescriptor) {
-          const endResolved = resolveTargetParagraph(xmlDoc, {
-            targetText: operation.targetEndDescriptor.text,
-            targetRef: operation.targetEndDescriptor.index,
-            targetDescriptor: operation.targetEndDescriptor,
-            opType: "restore",
-            strictAmbiguity: strictTargets,
-            paragraphMetadataIndex: currentMetadataIndex,
-            metadataIndices,
-            onInfo: options.onInfo,
-            onWarn: options.onWarn
-          });
-          const allParagraphs = getDocumentParagraphNodes(xmlDoc);
-          const startIndex = allParagraphs.indexOf(paragraph);
-          const endIndex = allParagraphs.indexOf(endResolved?.paragraph);
-          restorationParagraphs = startIndex >= 0 && endIndex >= startIndex ? allParagraphs.slice(startIndex, endIndex + 1) : null;
-        }
+        const restorationParagraphs = rangeParagraphs("restore");
         const replacements = Array.isArray(operation.modified) ? operation.modified : [operation.modified];
         if (!restorationParagraphs || restorationParagraphs[0] !== paragraph || replacements.length !== restorationParagraphs.length) {
           error2 = {
@@ -30077,11 +30293,11 @@ function preflightOperations(documentXml, operations, author, options = {}) {
         if (existingPolicy === "merge-same-author" || existingPolicy === "slice-cross-author") {
           const authors = getTrackedChangeAuthors(paragraph);
           const opAuthor = String(authorUsed || "").trim().toLowerCase();
-          const allSame = authors.length > 0 && authors.every((a) => a.trim().toLowerCase() === opAuthor);
+          const allSame = authors.length > 0 && !hasUnattributedTrackedChange(paragraph) && authors.every((a) => a.trim().toLowerCase() === opAuthor);
           if (!allSame && existingPolicy === "merge-same-author") {
             error2 = {
               code: "EXISTING_REVISIONS",
-              message: `Target paragraph contains tracked changes from another author (${authors.length ? authors.join(", ") : "unattributed"}). Use existingRevisions: "slice-cross-author" for a surgical edit that preserves reviewer history; accepting or rejecting revisions requires separate authorization.`,
+              message: `Target paragraph contains tracked changes from another author (${[...authors, ...hasUnattributedTrackedChange(paragraph) ? ["unattributed"] : []].join(", ")}). Use existingRevisions: "slice-cross-author" for a surgical edit that preserves reviewer history; accepting or rejecting revisions requires separate authorization.`,
               revisionAuthors: authors,
               currentPolicy: existingPolicy
             };