@ansonlai/docx-redline-js 0.4.0 → 0.5.0

package/dist/docx-redline-js.esm.js

@@ -1,4 +1,4 @@
-// @ansonlai/docx-redline-js v0.4.0 — https://github.com/AnsonLai/docx-redline-js
+// @ansonlai/docx-redline-js v0.5.0 — https://github.com/AnsonLai/docx-redline-js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -1612,10 +1612,11 @@ function serializeXml(node) {
 }
 
 // adapters/config.js
-var _defaultAuthor = "Author";
+var fallbackAuthor = () => typeof process !== "undefined" && process.env?.DOCX_REDLINE_AUTHOR || "AI Redliner";
+var _defaultAuthor = fallbackAuthor();
 var _platform = "Unknown";
 function setDefaultAuthor(author) {
-  _defaultAuthor = typeof author === "string" && author.trim() ? author.trim() : "Author";
+  _defaultAuthor = typeof author === "string" && author.trim() ? author.trim() : fallbackAuthor();
 }
 function getDefaultAuthor() {
   return _defaultAuthor;
@@ -1743,7 +1744,7 @@ function decodeHtmlEntities(text) {
 }
 
 // pipeline/list-markers.js
-var LIST_MARKER_CORE = String.raw`(?:\d+(?:\.\d+)*\.?|\((?:\d+|[a-zA-Z]|[ivxlcIVXLC]+)\)|[a-zA-Z]\.|\d+\.|[ivxlcIVXLC]+\.|[-*\u2022])`;
+var LIST_MARKER_CORE = String.raw`(?:\d+(?:\.\d+)*\.?|\((?:\d+|[a-zA-Z]|[ivxlcIVXLC]+)\)|[a-zA-Z]\.|\d+\.|[ivxlcIVXLC]+\.|[-*+\u2022])`;
 var LINE_REGEX_STRICT = new RegExp(`^(\\s*)((?:${LIST_MARKER_CORE})\\s+)`);
 var LINE_REGEX_LOOSE = new RegExp(`^(\\s*)((?:${LIST_MARKER_CORE})\\s*)`);
 var MULTILINE_REGEX_STRICT = new RegExp(`^(\\s*)((?:${LIST_MARKER_CORE})\\s+)`, "m");
@@ -1766,6 +1767,43 @@ function stripListMarker(line, options = {}) {
   const regex = allowZeroSpaceAfterMarker ? LINE_REGEX_LOOSE : LINE_REGEX_STRICT;
   return line.replace(regex, "");
 }
+function classifyListMarker(marker) {
+  return /^[-*+\u2022]$/.test(String(marker || "").trim()) ? "bullet" : "numbered";
+}
+function inferNumberingStyleFromMarker(marker) {
+  const value = String(marker || "").trim();
+  if (classifyListMarker(value) === "bullet") return "bullet";
+  if (/^\d+(?:\.\d+)*\.?$/.test(value) || /^\(\d+\)$/.test(value)) return "decimal";
+  if (/^[ivxlcdm]+\.$/.test(value)) return "lowerRoman";
+  if (/^[IVXLCDM]{2,}\.$/.test(value)) return "upperRoman";
+  if (/^[a-z]\.$/.test(value)) return "lowerAlpha";
+  if (/^[A-Z]\.$/.test(value)) return "upperAlpha";
+  return "decimal";
+}
+function parseOutlineLevelFromMarker(marker) {
+  const value = String(marker || "").trim();
+  if (!/^\d+(?:\.\d+)+\.?$/.test(value)) return null;
+  return Math.max(0, value.replace(/\.$/, "").split(".").length - 1);
+}
+function parseListItem(line, options = {}) {
+  const match = matchListMarker(String(line || ""), options);
+  if (!match) return null;
+  const marker = match[2].trim();
+  const indent = (match[1] || "").length;
+  const indentSpaces = Math.max(1, Number(options.indentSpaces) || 2);
+  const markerType = classifyListMarker(marker);
+  return {
+    line: String(line || ""),
+    text: stripListMarker(String(line || ""), options),
+    marker,
+    indent,
+    level: Math.min(8, Math.floor(indent / indentSpaces)),
+    markerType,
+    listType: markerType,
+    numberingStyle: inferNumberingStyleFromMarker(marker),
+    outlineLevel: markerType === "numbered" ? parseOutlineLevelFromMarker(marker) : null
+  };
+}
 
 // core/types.js
 var NS_W = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
@@ -1849,8 +1887,8 @@ var REVISION_ELEMENT_NAMES = /* @__PURE__ */ new Set([
 var revisionAllocatorByDocument = /* @__PURE__ */ new WeakMap();
 function isRevisionIdElement(element) {
   if (!element || element.nodeType !== 1) return false;
-  const localName = String(element.localName || element.nodeName || "").replace(/^.*:/, "");
-  if (!REVISION_ELEMENT_NAMES.has(localName)) return false;
+  const localName2 = String(element.localName || element.nodeName || "").replace(/^.*:/, "");
+  if (!REVISION_ELEMENT_NAMES.has(localName2)) return false;
   return !element.namespaceURI || element.namespaceURI === NS_W || String(element.nodeName || "").startsWith("w:");
 }
 function readWordId(element) {
@@ -1866,14 +1904,22 @@ var RevisionIdAllocator = class {
   }
   seed(xmlDoc) {
     let maxFound = -1;
-    const elements = Array.from(xmlDoc?.getElementsByTagName?.("*") || []);
-    if (xmlDoc?.nodeType === 1) elements.unshift(xmlDoc);
-    for (const element of elements) {
-      if (!isRevisionIdElement(element)) continue;
-      const id = readWordId(element);
-      if (id == null) continue;
-      this.occupiedIds.add(id);
-      maxFound = Math.max(maxFound, id);
+    const traversalRoot = xmlDoc?.nodeType === 9 ? xmlDoc.documentElement : xmlDoc;
+    let node = traversalRoot || null;
+    while (node) {
+      if (isRevisionIdElement(node)) {
+        const id = readWordId(node);
+        if (id != null) {
+          this.occupiedIds.add(id);
+          maxFound = Math.max(maxFound, id);
+        }
+      }
+      if (node.firstChild) {
+        node = node.firstChild;
+        continue;
+      }
+      while (node && node !== traversalRoot && !node.nextSibling) node = node.parentNode;
+      node = node && node !== traversalRoot ? node.nextSibling : null;
     }
     const highRiskBoundary = MAX_PRACTICAL_REVISION_ID - REVISION_ID_SAFETY_MARGIN;
     this.nextId = maxFound >= highRiskBoundary ? this.startValue : Math.max(this.nextId, maxFound + 1);
@@ -1920,15 +1966,36 @@ function getNextRevisionId() {
 function getRevisionTimestamp(date = /* @__PURE__ */ new Date()) {
   return date.toISOString();
 }
-function createRevisionMetadata(author, allocatorOrNode = null) {
+function createRevisionMetadata(author, allocatorOrNode = null, kind = null) {
   const resolvedAuthor = typeof author === "string" && author.trim() ? author.trim() : getDefaultAuthor();
   const allocator = allocatorOrNode instanceof RevisionIdAllocator ? allocatorOrNode : getRevisionIdAllocatorForDocument(allocatorOrNode) || defaultRevisionIdAllocator;
+  const id = allocator.next();
+  if (allocator._receiptCollector) {
+    allocator._receiptCollector.recordRevision(id, kind || "structural");
+  }
   return {
-    id: allocator.next(),
+    id,
     author: resolvedAuthor,
     date: getRevisionTimestamp()
   };
 }
+function createReplacementRevisionEvent(author, allocatorOrNode = null) {
+  const resolvedAuthor = typeof author === "string" && author.trim() ? author.trim() : getDefaultAuthor();
+  const allocator = allocatorOrNode instanceof RevisionIdAllocator ? allocatorOrNode : getRevisionIdAllocatorForDocument(allocatorOrNode) || defaultRevisionIdAllocator;
+  const date = getRevisionTimestamp();
+  const deletionId = allocator.next();
+  const insertionId = allocator.next();
+  if (allocator._receiptCollector) {
+    allocator._receiptCollector.recordRevision(deletionId, "del");
+    allocator._receiptCollector.recordRevision(insertionId, "ins");
+  }
+  return {
+    deletionId,
+    insertionId,
+    author: resolvedAuthor,
+    date
+  };
+}
 function seedRevisionIdsFromDocument(xmlDoc, allocator = defaultRevisionIdAllocator) {
   const resolvedAllocator = allocator instanceof RevisionIdAllocator ? allocator : defaultRevisionIdAllocator;
   const nextId = resolvedAllocator.seed(xmlDoc);
@@ -1965,22 +2032,22 @@ function getFirstElementByTag(node, tagName) {
   const elements = node.getElementsByTagName(tagName);
   return elements.length > 0 ? elements[0] : null;
 }
-function getElementsByTagNS(node, namespaceUri, localName) {
+function getElementsByTagNS(node, namespaceUri, localName2) {
   if (!node || typeof node.getElementsByTagNameNS !== "function") return [];
-  return Array.from(node.getElementsByTagNameNS(namespaceUri, localName));
+  return Array.from(node.getElementsByTagNameNS(namespaceUri, localName2));
 }
-function getFirstElementByTagNS(node, namespaceUri, localName) {
+function getFirstElementByTagNS(node, namespaceUri, localName2) {
   if (!node || typeof node.getElementsByTagNameNS !== "function") return null;
-  const elements = node.getElementsByTagNameNS(namespaceUri, localName);
+  const elements = node.getElementsByTagNameNS(namespaceUri, localName2);
   return elements.length > 0 ? elements[0] : null;
 }
-function getElementsByTagNSOrTag(node, namespaceUri, localName, fallbackTagName = `w:${localName}`) {
-  const namespacedElements = getElementsByTagNS(node, namespaceUri, localName);
+function getElementsByTagNSOrTag(node, namespaceUri, localName2, fallbackTagName = `w:${localName2}`) {
+  const namespacedElements = getElementsByTagNS(node, namespaceUri, localName2);
   if (namespacedElements.length > 0) return namespacedElements;
   return getElementsByTag(node, fallbackTagName);
 }
-function getFirstElementByTagNSOrTag(node, namespaceUri, localName, fallbackTagName = `w:${localName}`) {
-  const namespacedElement = getFirstElementByTagNS(node, namespaceUri, localName);
+function getFirstElementByTagNSOrTag(node, namespaceUri, localName2, fallbackTagName = `w:${localName2}`) {
+  const namespacedElement = getFirstElementByTagNS(node, namespaceUri, localName2);
   if (namespacedElement) return namespacedElement;
   return getFirstElementByTag(node, fallbackTagName);
 }
@@ -1993,12 +2060,12 @@ function childNodesToArray(node) {
   return Array.from(node?.childNodes || []);
 }
 function serializeAttributes(element) {
-  return Array.from(element.attributes).map((attr) => `${attr.name}="${attr.value}"`).join(" ");
+  return Array.from(element.attributes).map((attr4) => `${attr4.name}="${attr4.value}"`).join(" ");
 }
-function isNamespacedNode(node, namespaceUri, localName = "") {
+function isNamespacedNode(node, namespaceUri, localName2 = "") {
   if (!node || node.namespaceURI !== namespaceUri) return false;
-  if (!localName) return true;
-  return node.localName === localName;
+  if (!localName2) return true;
+  return node.localName === localName2;
 }
 
 // pipeline/ingestion-paragraph.js
@@ -2048,6 +2115,7 @@ function detectNumberingContext(pElement) {
   const ilvlEl = getFirstElementByTagNS(numPr, NS_W, "ilvl");
   if (!numIdEl) return null;
   const numId = numIdEl.getAttribute("w:val");
+  if (!/^\d+$/.test(numId) || Number.parseInt(numId, 10) === 0) return null;
   const type = numId === "1" ? "bullet" : numId === "2" ? "numbered" : "unknown";
   return {
     numId,
@@ -2246,6 +2314,8 @@ function processRun(runElement, startOffset) {
       text += "	";
     } else if (nodeName.endsWith(":noBreakHyphen") || nodeName === "noBreakHyphen") {
       text += "\u2011";
+    } else if (nodeName.endsWith(":softHyphen") || nodeName === "softHyphen") {
+      text += "\xAD";
     }
   }
   if (!text) return null;
@@ -3155,7 +3225,8 @@ function buildSimpleRun(text, rPrXml) {
 function buildDeletionXml(item, options = {}) {
   const metadata = createRevisionMetadata(
     options.author ?? getDefaultAuthor(),
-    options.revisionIdAllocator
+    options.revisionIdAllocator,
+    "del"
   );
   const font = options.font ?? null;
   let rPr = item.rPrXml ? stripNamespaceDeclarations(item.rPrXml) : "";
@@ -3167,7 +3238,8 @@ function buildDeletionXml(item, options = {}) {
 function buildInsertionXml(item, formatHints, options = {}) {
   const metadata = createRevisionMetadata(
     options.author ?? getDefaultAuthor(),
-    options.revisionIdAllocator
+    options.revisionIdAllocator,
+    "ins"
   );
   const font = options.font ?? null;
   const applicableHints = getApplicableFormatHints(formatHints, item.startOffset, item.endOffset);
@@ -3255,6 +3327,10 @@ function stripNamespaceDeclarations(xml) {
 }
 
 // services/numbering-service.js
+function isUsableNumId(numId) {
+  const normalized = String(numId ?? "");
+  return /^\d+$/.test(normalized) && Number.parseInt(normalized, 10) > 0;
+}
 var NumberingService = class {
   constructor() {
     this.contextMap = /* @__PURE__ */ new Map();
@@ -3268,7 +3344,9 @@ var NumberingService = class {
    * @param {string} numId - Existing numId from Word
    */
   registerExistingNumId(signature, numId) {
-    this.contextMap.set(signature, numId);
+    if (isUsableNumId(numId)) {
+      this.contextMap.set(signature, String(numId));
+    }
   }
   /**
    * Resolves the best numId to use for a requested list format.
@@ -3279,13 +3357,15 @@ var NumberingService = class {
    */
   getOrCreateNumId(formatConfig, existingContext = null) {
     const requestedType = formatConfig.type || NumberFormat.BULLET;
-    if (existingContext && existingContext.numId) {
+    if (existingContext && isUsableNumId(existingContext.numId)) {
       if (existingContext.type === requestedType || existingContext.type === "unknown") {
         return existingContext.numId;
       }
     }
     if (this.contextMap.has(requestedType)) {
-      return this.contextMap.get(requestedType);
+      const cachedNumId = this.contextMap.get(requestedType);
+      if (isUsableNumId(cachedNumId)) return cachedNumId;
+      this.contextMap.delete(requestedType);
     }
     if (requestedType === NumberFormat.OUTLINE) {
       return "3";
@@ -3488,8 +3568,13 @@ var NumberingService = class {
 
 // services/table-reconciliation.js
 function generateTableOoxml(tableData, options = {}) {
-  const { generateRedlines = false, author = "AI", revisionIdAllocator = null } = options;
-  const tableInsertMeta = generateRedlines ? createRevisionMetadata(author, revisionIdAllocator) : null;
+  const {
+    generateRedlines = false,
+    author = "AI",
+    revisionIdAllocator = null,
+    trackAsBlock = false
+  } = options;
+  const tableInsertMeta = generateRedlines && trackAsBlock ? createRevisionMetadata(author, revisionIdAllocator) : null;
   const numCols = tableData.headers?.length || (tableData.rows?.[0]?.length || 1);
   const tblPr = `
         <w:tblPr>
@@ -3517,7 +3602,7 @@ function generateTableOoxml(tableData, options = {}) {
       const cellText = row[c] || "";
       const { cleanText, formatHints } = preprocessMarkdown(cellText);
       const runModel = [{
-        kind: generateRedlines ? RunKind.INSERTION : RunKind.TEXT,
+        kind: generateRedlines && !trackAsBlock ? RunKind.INSERTION : RunKind.TEXT,
         text: cleanText,
         rPrXml: isHeaderRow ? "<w:rPr><w:b/></w:rPr>" : "",
         author,
@@ -3532,7 +3617,7 @@ function generateTableOoxml(tableData, options = {}) {
       const tcPr = '<w:tcPr><w:tcW w:w="0" w:type="auto"/></w:tcPr>';
       cellsXml += `<w:tc>${tcPr}${runsOoxml}</w:tc>`;
     }
-    const trPr = "<w:trPr/>";
+    const trPr = isHeaderRow ? "<w:trPr><w:tblHeader/><w:cantSplit/></w:trPr>" : "<w:trPr><w:cantSplit/></w:trPr>";
     rowsXml += `<w:tr>${trPr}${cellsXml}</w:tr>`;
   }
   let tableXml = `<w:tbl>${tblPr}${tblGrid}${rowsXml}</w:tbl>`;
@@ -3750,6 +3835,71 @@ function parseTable(text) {
   };
 }
 
+// core/word-xml.js
+function isWordElement(node, localName2) {
+  if (!node || node.nodeType !== 1) return false;
+  if (node.namespaceURI === NS_W && node.localName === localName2) return true;
+  const nodeName = String(node.nodeName || "");
+  return nodeName === `w:${localName2}` || nodeName === localName2;
+}
+function createWordElement(xmlDoc, qualifiedName) {
+  return typeof xmlDoc.createElementNS === "function" ? xmlDoc.createElementNS(NS_W, qualifiedName) : xmlDoc.createElement(qualifiedName);
+}
+function wordElementsByLocalName(xmlDoc, localName2) {
+  const namespaced = Array.from(xmlDoc?.getElementsByTagNameNS?.(NS_W, localName2) || []);
+  if (namespaced.length > 0) return namespaced;
+  return Array.from(xmlDoc?.getElementsByTagName?.("*") || []).filter((node) => isWordElement(node, localName2));
+}
+var TRACKED_CHANGE_NAMES = [
+  "ins",
+  "del",
+  "moveFrom",
+  "moveTo",
+  "moveFromRangeStart",
+  "moveFromRangeEnd",
+  "moveToRangeStart",
+  "moveToRangeEnd",
+  "rPrChange",
+  "pPrChange",
+  "tblPrChange",
+  "trPrChange",
+  "tcPrChange",
+  "cellIns",
+  "cellDel"
+];
+function containsTrackedChanges(xmlDoc) {
+  return TRACKED_CHANGE_NAMES.some((localName2) => wordElementsByLocalName(xmlDoc, localName2).length > 0);
+}
+function getTrackedChangeAuthors(xmlDocOrElement) {
+  if (!xmlDocOrElement) return [];
+  const authors = /* @__PURE__ */ new Set();
+  for (const localName2 of TRACKED_CHANGE_NAMES) {
+    for (const node of wordElementsByLocalName(xmlDocOrElement, localName2)) {
+      const author = node.getAttribute?.("w:author") || node.getAttribute?.("author") || (typeof node.getAttributeNS === "function" ? node.getAttributeNS(NS_W, "author") : null);
+      if (author && typeof author === "string" && author.trim()) {
+        authors.add(author.trim());
+      }
+    }
+  }
+  return [...authors].sort();
+}
+function classifyOoxmlSourceType(oxml) {
+  const trimmed = String(oxml || "").trim();
+  if (/^<\?xml\b[^>]*>\s*<pkg:package\b/i.test(trimmed) || /^<pkg:package\b/i.test(trimmed)) {
+    return "package";
+  }
+  if (/^<\?xml\b[^>]*>\s*<(?:w:)?document\b/i.test(trimmed) || /^<(?:w:)?document\b/i.test(trimmed)) {
+    return "document";
+  }
+  return "fragment";
+}
+function withOoxmlSourceType(result) {
+  if (!result || typeof result !== "object" || result.sourceType || typeof result.oxml !== "string") {
+    return result;
+  }
+  return { ...result, sourceType: classifyOoxmlSourceType(result.oxml) };
+}
+
 // pipeline/list-generation.js
 async function executeListGeneration(options) {
   const {
@@ -3767,6 +3917,13 @@ async function executeListGeneration(options) {
   const lineMetadata = buildLineMetadata(normalizedListText);
   const rawLines = lineMetadata.map((line) => line.raw);
   const results = [];
+  const sourcePPr = getSourceParagraphProperties(originalRunModel);
+  const inheritedTypographyRPrXml = extractInheritedTypographyRPrXml(originalRunModel, sourcePPr);
+  const inheritedHeadingRPrXml = extractInheritedTypographyRPrXml(
+    originalRunModel,
+    sourcePPr,
+    ["rFonts", "kern", "position", "rtl", "cs", "lang"]
+  );
   let deletionRuns = [];
   if (generateRedlines) {
     if (originalRunModel && originalRunModel.length > 0) {
@@ -3782,6 +3939,15 @@ async function executeListGeneration(options) {
       }];
     }
   }
+  if (generateRedlines && deletionRuns.length > 0) {
+    const deletedPPr = addParagraphMarkRevision(sourcePPr, "del", author, revisionIdAllocator);
+    const deletedParagraph = serializeToOoxml(deletionRuns, deletedPPr, [], {
+      author,
+      generateRedlines,
+      revisionIdAllocator
+    });
+    results.push(deletedParagraph);
+  }
   const indentStep = detectIndentationStep(rawLines);
   log(`[ListGen] Detected indentation step: ${indentStep} spaces/chars`);
   const firstMarker = lineMetadata.find((line) => line.marker)?.marker || "";
@@ -3792,18 +3958,11 @@ async function executeListGeneration(options) {
     if (tableBlock) {
       const tableData = parseTable(tableBlock.tableText);
       if (tableData.headers.length > 0 || tableData.rows.length > 0) {
-        if (generateRedlines && results.length === 0 && deletionRuns.length > 0) {
-          results.push(serializeToOoxml(deletionRuns, null, [], {
-            author,
-            generateRedlines,
-            font,
-            revisionIdAllocator
-          }));
-        }
         results.push(generateTableOoxml(tableData, {
           generateRedlines,
           author,
-          revisionIdAllocator
+          revisionIdAllocator,
+          trackAsBlock: true
         }));
         i = tableBlock.endIndex;
         continue;
@@ -3812,7 +3971,6 @@ async function executeListGeneration(options) {
     const line = lineMetadata[i];
     const entry = buildListEntry(
       line,
-      i,
       indentStep,
       numberingContext,
       numberingService,
@@ -3820,18 +3978,17 @@ async function executeListGeneration(options) {
       author,
       font,
       revisionIdAllocator,
-      deletionRuns
+      inheritedTypographyRPrXml,
+      inheritedHeadingRPrXml
     );
     results.push(entry.ooxml);
   }
   const numberingXml = numberingService.generateNumberingXml();
   const finalOoxml = results.join("");
-  const blankParagraph = "<w:p><w:pPr></w:pPr></w:p>";
-  const oxmlWithSpacing = finalOoxml + blankParagraph;
-  log(`[ListGen] \u2705 Generated OOXML for ${results.length} list items, total length: ${oxmlWithSpacing.length}`);
-  log(`[ListGen] First 200 chars: ${oxmlWithSpacing.substring(0, 200)}...`);
+  log(`[ListGen] \u2705 Generated OOXML for ${results.length} paragraphs, total length: ${finalOoxml.length}`);
+  log(`[ListGen] First 200 chars: ${finalOoxml.substring(0, 200)}...`);
   return {
-    ooxml: oxmlWithSpacing,
+    ooxml: finalOoxml,
     isValid: true,
     warnings: ["Paragraph expanded to list fragment"],
     type: "fragment",
@@ -3910,9 +4067,10 @@ function collectMarkdownTableBlock(lineMetadata, index) {
     endIndex: cursor - 1
   };
 }
-function buildListEntry(line, lineIndex, indentStep, numberingContext, numberingService, generateRedlines, author, font, revisionIdAllocator, deletionRuns) {
+function buildListEntry(line, indentStep, numberingContext, numberingService, generateRedlines, author, font, revisionIdAllocator, inheritedTypographyRPrXml, inheritedHeadingRPrXml) {
   let pPrXml = "";
   let segmentText = "";
+  let insertedRPrXml = inheritedTypographyRPrXml;
   if (line.headerMatch) {
     const level = Math.min(line.headerMatch[1].length, 9);
     const outlineLevel = Math.min(level - 1, 8);
@@ -3920,6 +4078,10 @@ function buildListEntry(line, lineIndex, indentStep, numberingContext, numbering
     const headingSize = headingSizes[level - 1] || headingSizes[headingSizes.length - 1];
     segmentText = line.headerMatch[2].trim();
     pPrXml = `<w:pPr><w:pStyle w:val="Heading${level}"/><w:outlineLvl w:val="${outlineLevel}"/><w:rPr><w:b/><w:sz w:val="${headingSize}"/><w:szCs w:val="${headingSize}"/></w:rPr></w:pPr>`;
+    insertedRPrXml = mergeRunProperties(
+      inheritedHeadingRPrXml,
+      `<w:rPr><w:b/><w:sz w:val="${headingSize}"/><w:szCs w:val="${headingSize}"/></w:rPr>`
+    );
   } else if (line.marker) {
     const lineFormat = numberingService.detectNumberingFormat(line.marker);
     const indentLevel = indentStep > 0 ? Math.floor(line.indentSize / indentStep) : 0;
@@ -3931,14 +4093,20 @@ function buildListEntry(line, lineIndex, indentStep, numberingContext, numbering
   } else {
     segmentText = line.raw;
   }
+  if (generateRedlines) {
+    pPrXml = addParagraphMarkRevision(
+      pPrXml || "<w:pPr/>",
+      "ins",
+      author,
+      revisionIdAllocator
+    );
+  }
   const { cleanText, formatHints } = preprocessMarkdown(segmentText);
   const runModel = [];
-  if (lineIndex === 0 && deletionRuns.length > 0) {
-    runModel.push(...deletionRuns);
-  }
   runModel.push({
     kind: generateRedlines ? "insertion" : "run",
     text: cleanText,
+    rPrXml: insertedRPrXml,
     author,
     startOffset: 0,
     endOffset: cleanText.length
@@ -3952,6 +4120,59 @@ function buildListEntry(line, lineIndex, indentStep, numberingContext, numbering
     })
   };
 }
+function getSourceParagraphProperties(originalRunModel) {
+  const paragraphStart = (originalRunModel || []).find((run) => run.kind === RunKind.PARAGRAPH_START);
+  return paragraphStart?.pPrElement || paragraphStart?.pPrXml || null;
+}
+function extractInheritedTypographyRPrXml(originalRunModel, sourcePPr, tagOrder = ["rFonts", "kern", "position", "sz", "szCs", "rtl", "cs", "lang"]) {
+  const sources = (originalRunModel || []).filter((run) => (run.kind === RunKind.TEXT || run.kind === "text") && run.rPrXml).map((run) => run.rPrXml);
+  if (sourcePPr) {
+    sources.push(typeof sourcePPr === "string" ? sourcePPr : serializeXml(sourcePPr));
+  }
+  const inherited = [];
+  for (const tagName of tagOrder) {
+    let match = null;
+    for (const source of sources) {
+      match = String(source || "").match(new RegExp(`<w:${tagName}\\b[^>]*(?:\\/>|>[\\s\\S]*?<\\/w:${tagName}>)`));
+      if (match) break;
+    }
+    if (match) inherited.push(match[0]);
+  }
+  return inherited.length > 0 ? `<w:rPr>${inherited.join("")}</w:rPr>` : "";
+}
+function mergeRunProperties(...sources) {
+  const properties = sources.map((source) => String(source || "").replace(/^\s*<w:rPr[^>]*>|<\/w:rPr>\s*$/g, "")).filter(Boolean).join("");
+  return properties ? `<w:rPr>${properties}</w:rPr>` : "";
+}
+function addParagraphMarkRevision(xml, type, author, revisionIdAllocator) {
+  const metadata = createRevisionMetadata(author, revisionIdAllocator);
+  let pPr;
+  let ownerDoc;
+  if (xml?.nodeType === 1) {
+    pPr = xml.cloneNode(true);
+    ownerDoc = pPr.ownerDocument;
+  } else {
+    const pPrXml = typeof xml === "string" && xml.trim() ? xml : "<w:pPr/>";
+    const parsed = parseOoxmlSafe(`<w:root xmlns:w="${NS_W}">${pPrXml}</w:root>`);
+    if (!parsed.doc) {
+      throw new Error(parsed.error?.message || "Could not parse paragraph properties for list revision");
+    }
+    ownerDoc = parsed.doc;
+    pPr = Array.from(ownerDoc.documentElement.childNodes || []).find((node) => node.nodeType === 1 && node.localName === "pPr");
+  }
+  if (!pPr || !ownerDoc) throw new Error("List paragraph properties are unavailable");
+  let rPr = Array.from(pPr.childNodes || []).find((node) => node.nodeType === 1 && node.localName === "rPr");
+  if (!rPr) {
+    rPr = createWordElement(ownerDoc, "w:rPr");
+    pPr.appendChild(rPr);
+  }
+  const marker = createWordElement(ownerDoc, type === "del" ? "w:del" : "w:ins");
+  marker.setAttribute("w:id", String(metadata.id));
+  marker.setAttribute("w:author", metadata.author);
+  marker.setAttribute("w:date", metadata.date);
+  rPr.appendChild(marker);
+  return serializeXml(pPr);
+}
 
 // pipeline/pipeline.js
 var WEB_PLATFORM_NAMES = /* @__PURE__ */ new Set(["officeonline", "officeweb", "web"]);
@@ -4217,53 +4438,127 @@ var ReconciliationPipeline = class {
   }
 };
 
-// core/word-xml.js
-function isWordElement(node, localName) {
-  if (!node || node.nodeType !== 1) return false;
-  if (node.namespaceURI === NS_W && node.localName === localName) return true;
-  const nodeName = String(node.nodeName || "");
-  return nodeName === `w:${localName}` || nodeName === localName;
-}
-function createWordElement(xmlDoc, qualifiedName) {
-  return typeof xmlDoc.createElementNS === "function" ? xmlDoc.createElementNS(NS_W, qualifiedName) : xmlDoc.createElement(qualifiedName);
-}
-function wordElementsByLocalName(xmlDoc, localName) {
-  const namespaced = Array.from(xmlDoc?.getElementsByTagNameNS?.(NS_W, localName) || []);
-  if (namespaced.length > 0) return namespaced;
-  return Array.from(xmlDoc?.getElementsByTagName?.("*") || []).filter((node) => isWordElement(node, localName));
-}
-function containsTrackedChanges(xmlDoc) {
-  const trackedChangeNames = [
-    "ins",
-    "del",
-    "moveFrom",
-    "moveTo",
-    "moveFromRangeStart",
-    "moveFromRangeEnd",
-    "moveToRangeStart",
-    "moveToRangeEnd",
-    "rPrChange",
-    "pPrChange",
-    "cellIns",
-    "cellDel"
-  ];
-  return trackedChangeNames.some((localName) => wordElementsByLocalName(xmlDoc, localName).length > 0);
-}
-function classifyOoxmlSourceType(oxml) {
-  const trimmed = String(oxml || "").trim();
-  if (/^<\?xml\b[^>]*>\s*<pkg:package\b/i.test(trimmed) || /^<pkg:package\b/i.test(trimmed)) {
-    return "package";
-  }
-  if (/^<\?xml\b[^>]*>\s*<(?:w:)?document\b/i.test(trimmed) || /^<(?:w:)?document\b/i.test(trimmed)) {
-    return "document";
+// pipeline/structured-content.js
+var TABLE_SEPARATOR = /^\s*\|?\s*:?-{3,}:?\s*(?:\|\s*:?-{3,}:?\s*)+\|?\s*$/;
+function isBlank(line) {
+  return !line || line.trim().length === 0;
+}
+function isTableLine(line) {
+  const trimmed = String(line || "").trim();
+  return trimmed.startsWith("|") && trimmed.endsWith("|");
+}
+function tableCells(line) {
+  return String(line || "").trim().split("|").slice(1, -1).map((cell) => cell.trim());
+}
+function classifyLine(line) {
+  if (isBlank(line)) return "blank";
+  if (/^\s*#{1,9}\s+\S/.test(line)) return "heading";
+  if (isTableLine(line)) return "table";
+  if (matchListMarker(line)) return "list";
+  return "paragraph";
+}
+function analyzeStructuredContent(markdown) {
+  const source = typeof markdown === "string" ? markdown.replace(/\r\n?/g, "\n") : String(markdown ?? "");
+  const lines = source.split("\n");
+  const blocks = [];
+  const issues = [];
+  let index = 0;
+  while (index < lines.length) {
+    if (isBlank(lines[index])) {
+      index++;
+      continue;
+    }
+    const kind = classifyLine(lines[index]);
+    const startLine = index + 1;
+    if (kind === "heading") {
+      const match = lines[index].match(/^\s*(#{1,9})\s+(.+?)\s*$/);
+      blocks.push({ type: "heading", level: match[1].length, text: match[2], markdown: lines[index].trim() });
+      index++;
+      continue;
+    }
+    if (kind === "table") {
+      const tableLines = [];
+      while (index < lines.length && isTableLine(lines[index])) {
+        tableLines.push(lines[index].trim());
+        index++;
+      }
+      const separatorPresent = tableLines.length > 1 && TABLE_SEPARATOR.test(tableLines[1]);
+      const widths = tableLines.filter((line) => !TABLE_SEPARATOR.test(line)).map((line) => tableCells(line).length);
+      if (!separatorPresent) {
+        issues.push({
+          severity: "error",
+          code: "TABLE_SEPARATOR_REQUIRED",
+          line: startLine,
+          message: "Markdown tables require a separator row immediately after the header (for example | --- | --- |)."
+        });
+      }
+      if (widths.length < 2) {
+        issues.push({
+          severity: "error",
+          code: "TABLE_DATA_ROW_REQUIRED",
+          line: startLine,
+          message: "Markdown tables require a header and at least one data row."
+        });
+      } else if (new Set(widths).size > 1) {
+        issues.push({
+          severity: "error",
+          code: "TABLE_COLUMN_COUNT_MISMATCH",
+          line: startLine,
+          message: `Markdown table rows have inconsistent column counts: ${widths.join(", ")}.`
+        });
+      }
+      blocks.push({
+        type: "table",
+        columns: widths[0] || 0,
+        rows: Math.max(0, widths.length - 1),
+        hasHeader: separatorPresent,
+        markdown: tableLines.join("\n")
+      });
+      continue;
+    }
+    if (kind === "list") {
+      const listLines = [];
+      while (index < lines.length && classifyLine(lines[index]) === "list") {
+        listLines.push(lines[index].trimEnd());
+        index++;
+      }
+      blocks.push({ type: "list", items: listLines.length, markdown: listLines.join("\n") });
+      continue;
+    }
+    const paragraphLines = [];
+    while (index < lines.length && classifyLine(lines[index]) === "paragraph") {
+      paragraphLines.push(lines[index].trim());
+      index++;
+    }
+    const text = paragraphLines.join(" ").trim();
+    blocks.push({ type: "paragraph", text, markdown: text });
   }
-  return "fragment";
+  const counts = { heading: 0, paragraph: 0, list: 0, table: 0 };
+  for (const block of blocks) counts[block.type] = (counts[block.type] || 0) + 1;
+  const normalizedMarkdown = blocks.map((block) => block.markdown).join("\n\n");
+  return {
+    valid: issues.every((issue) => issue.severity !== "error"),
+    normalizedMarkdown,
+    blocks,
+    issues,
+    counts,
+    requiresStructuredContent: blocks.length > 1 || blocks.some((block) => block.type === "heading" || block.type === "table" || block.type === "list" && block.items > 1)
+  };
 }
-function withOoxmlSourceType(result) {
-  if (!result || typeof result !== "object" || result.sourceType || typeof result.oxml !== "string") {
-    return result;
-  }
-  return { ...result, sourceType: classifyOoxmlSourceType(result.oxml) };
+function planStructuredReplacement(target, markdown, options = {}) {
+  const analysis = analyzeStructuredContent(markdown);
+  return {
+    ...analysis,
+    operation: analysis.valid ? {
+      type: "replace",
+      target,
+      modified: analysis.normalizedMarkdown,
+      structuredContent: true,
+      ...options.author ? { author: options.author } : {},
+      ...typeof options.generateRedlines === "boolean" ? { generateRedlines: options.generateRedlines } : {},
+      ...options.existingRevisions ? { existingRevisions: options.existingRevisions } : {}
+    } : null
+  };
 }
 
 // engine/rpr-helpers.js
@@ -4306,7 +4601,8 @@ var RPR_SCHEMA_ORDER = [
   "w:lang",
   "w:eastAsianLayout",
   "w:specVanish",
-  "w:oMath"
+  "w:oMath",
+  "w:rPrChange"
 ];
 function insertRPrChildInOrder(rPr, el) {
   const myIndex = RPR_SCHEMA_ORDER.indexOf(el.nodeName);
@@ -4415,11 +4711,11 @@ function isFormattingElementEnabled(element, isUnderline) {
 
 // engine/format-extraction.js
 var NS_W3 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
-function isWordElement2(node, localName) {
+function isWordElement2(node, localName2) {
   if (!node || node.nodeType !== 1) return false;
-  if (node.namespaceURI === NS_W3 && node.localName === localName) return true;
+  if (node.namespaceURI === NS_W3 && node.localName === localName2) return true;
   const nodeName = String(node.nodeName || "");
-  return nodeName === `w:${localName}` || nodeName === localName;
+  return nodeName === `w:${localName2}` || nodeName === localName2;
 }
 function isExcludedRevisionContainer(node) {
   if (!node || node.nodeType !== 1 || node.namespaceURI !== NS_W3) return false;
@@ -4449,8 +4745,8 @@ function getDocumentParagraphs(xmlDoc) {
   return allParagraphs.filter((p) => {
     let node = p.parentNode;
     while (node && node.nodeName) {
-      const localName = String(node.localName || "").toLowerCase();
-      if (excludedContainers.has(localName)) {
+      const localName2 = String(node.localName || "").toLowerCase();
+      if (excludedContainers.has(localName2)) {
         return false;
       }
       node = node.parentNode;
@@ -4580,9 +4876,9 @@ function extractFormattingFromOoxml(xmlDoc) {
 }
 
 // engine/run-builders.js
-function createTrackChange(xmlDoc, type, run, author) {
+function createTrackChange(xmlDoc, type, run, author, revisionMetadata = null) {
   const wrapper = createWordElement(xmlDoc, type === "ins" ? "w:ins" : "w:del");
-  const metadata = createRevisionMetadata(author, xmlDoc);
+  const metadata = revisionMetadata || createRevisionMetadata(author, xmlDoc, type === "ins" ? "ins" : "del");
   wrapper.setAttribute("w:id", String(metadata.id));
   wrapper.setAttribute("w:author", metadata.author);
   wrapper.setAttribute("w:date", metadata.date);
@@ -4591,8 +4887,8 @@ function createTrackChange(xmlDoc, type, run, author) {
   }
   return wrapper;
 }
-function getDirectWordChild(node, localName) {
-  return Array.from(node?.childNodes || []).find((child) => child.nodeType === 1 && (child.localName === localName || child.nodeName === `w:${localName}`)) || null;
+function getDirectWordChild(node, localName2) {
+  return Array.from(node?.childNodes || []).find((child) => child.nodeType === 1 && (child.localName === localName2 || child.nodeName === `w:${localName2}`)) || null;
 }
 function ensureParagraphProperties(xmlDoc, paragraph) {
   let pPr = getDirectWordChild(paragraph, "pPr");
@@ -4614,7 +4910,7 @@ function ensureParagraphMarkRunProperties(xmlDoc, pPr) {
   }
   return rPr;
 }
-function markParagraphMark(xmlDoc, paragraph, author, type) {
+function markParagraphMark(xmlDoc, paragraph, author, type, revisionMetadata = null) {
   const pPr = ensureParagraphProperties(xmlDoc, paragraph);
   const rPr = ensureParagraphMarkRunProperties(xmlDoc, pPr);
   for (const child of Array.from(rPr.childNodes || [])) {
@@ -4624,18 +4920,18 @@ function markParagraphMark(xmlDoc, paragraph, author, type) {
     }
   }
   const marker = createWordElement(xmlDoc, type === "ins" ? "w:ins" : "w:del");
-  const metadata = createRevisionMetadata(author, xmlDoc);
+  const metadata = revisionMetadata || createRevisionMetadata(author, xmlDoc, type === "ins" ? "ins" : "del");
   marker.setAttribute("w:id", String(metadata.id));
   marker.setAttribute("w:author", metadata.author);
   marker.setAttribute("w:date", metadata.date);
   rPr.appendChild(marker);
   return marker;
 }
-function markParagraphMarkInserted(xmlDoc, paragraph, author) {
-  return markParagraphMark(xmlDoc, paragraph, author, "ins");
+function markParagraphMarkInserted(xmlDoc, paragraph, author, revisionMetadata = null) {
+  return markParagraphMark(xmlDoc, paragraph, author, "ins", revisionMetadata);
 }
-function markParagraphMarkDeleted(xmlDoc, paragraph, author) {
-  return markParagraphMark(xmlDoc, paragraph, author, "del");
+function markParagraphMarkDeleted(xmlDoc, paragraph, author, revisionMetadata = null) {
+  return markParagraphMark(xmlDoc, paragraph, author, "del", revisionMetadata);
 }
 function createTextRun(xmlDoc, text, rPr, isDelete) {
   const run = createWordElement(xmlDoc, "w:r");
@@ -4763,7 +5059,7 @@ function injectFormattingToRPr(xmlDoc, baseRPr, format, author, generateRedlines
 }
 function snapshotAndAttachRPrChange(xmlDoc, rPr, author, dateStr, sourceNode) {
   const rPrChange = createWordElement(xmlDoc, "w:rPrChange");
-  const metadata = createRevisionMetadata(author, xmlDoc);
+  const metadata = createRevisionMetadata(author, xmlDoc, "rPrChange");
   rPrChange.setAttribute("w:id", String(metadata.id));
   rPrChange.setAttribute("w:author", metadata.author);
   rPrChange.setAttribute("w:date", dateStr || metadata.date);
@@ -4788,11 +5084,11 @@ function createRPrChange(xmlDoc, rPr, author, previousRPrArg) {
 
 // engine/format-paragraph-targeting.js
 var NS_W4 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
-function isWordElement3(node, localName) {
+function isWordElement3(node, localName2) {
   if (!node || node.nodeType !== 1) return false;
-  if (node.namespaceURI === NS_W4 && node.localName === localName) return true;
+  if (node.namespaceURI === NS_W4 && node.localName === localName2) return true;
   const nodeName = String(node.nodeName || "");
-  return nodeName === `w:${localName}` || nodeName === localName;
+  return nodeName === `w:${localName2}` || nodeName === localName2;
 }
 function buildParagraphInfos(xmlDoc, paragraphs, textSpans) {
   void xmlDoc;
@@ -4972,11 +5268,11 @@ function splitSpanAtOffset(xmlDoc, span, absoluteOffset) {
 
 // engine/format-application.js
 var NS_W5 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
-function isWordElement4(node, localName) {
+function isWordElement4(node, localName2) {
   if (!node || node.nodeType !== 1) return false;
-  if (node.namespaceURI === NS_W5 && node.localName === localName) return true;
+  if (node.namespaceURI === NS_W5 && node.localName === localName2) return true;
   const nodeName = String(node.nodeName || "");
-  return nodeName === `w:${localName}` || nodeName === localName;
+  return nodeName === `w:${localName2}` || nodeName === localName2;
 }
 function normalizePrecomputedFormatContext(precomputedContext) {
   if (Array.isArray(precomputedContext)) {
@@ -5158,6 +5454,174 @@ function createFormatHintOverlapLookup(formatHints) {
   };
 }
 
+// core/paragraph-text.js
+function localName(node) {
+  return String(node?.localName || node?.nodeName || "").replace(/^.*:/, "");
+}
+function isNodeVisibleInRevisionView(node, boundary = null, revisionView = "accepted") {
+  const view = revisionView === "current" ? "accepted" : revisionView;
+  let cursor = node;
+  while (cursor && cursor !== boundary) {
+    const name = localName(cursor);
+    if (view === "accepted" && (name === "del" || name === "moveFrom")) return false;
+    if (view === "rejected" && (name === "ins" || name === "moveTo")) return false;
+    cursor = cursor.parentNode;
+  }
+  return true;
+}
+function readCanonicalRunText(run, options = {}) {
+  const revisionView = options.revisionView === "current" ? "accepted" : options.revisionView || "accepted";
+  const boundary = options.boundary || null;
+  if (!isNodeVisibleInRevisionView(run, boundary, revisionView)) return "";
+  let text = "";
+  const visit = (node) => {
+    for (const child of Array.from(node?.childNodes || [])) {
+      if (child?.nodeType !== 1 || child.namespaceURI && child.namespaceURI !== NS_W) continue;
+      if (!isNodeVisibleInRevisionView(child, boundary, revisionView)) continue;
+      const name = localName(child);
+      if (name === "t" || name === "delText" && revisionView === "rejected") text += child.textContent || "";
+      else if (name === "tab") text += "	";
+      else if (name === "br" || name === "cr") text += "\n";
+      else if (name === "noBreakHyphen") text += "\u2011";
+      else if (name === "softHyphen") text += "\xAD";
+      else visit(child);
+    }
+  };
+  visit(run);
+  return text;
+}
+var attr = (node, name) => node?.getAttribute?.(`w:${name}`) || node?.getAttribute?.(name) || "";
+function extractParagraphRevisionSegments(paragraph, options = {}) {
+  if (!paragraph) return [];
+  const rawPieces = [];
+  function walk(node, currentRevision, currentCarrier) {
+    for (const child of Array.from(node?.childNodes || [])) {
+      if (child?.nodeType !== 1) continue;
+      if (child.namespaceURI && child.namespaceURI !== NS_W) continue;
+      const name = localName(child);
+      if (name === "pPr" || name === "rPr") continue;
+      let nextRevision = currentRevision;
+      if (name === "ins") {
+        nextRevision = {
+          kind: "insertion",
+          author: attr(child, "author") || void 0,
+          revisionId: attr(child, "id") || void 0
+        };
+      } else if (name === "del") {
+        nextRevision = {
+          kind: "deletion",
+          author: attr(child, "author") || void 0,
+          revisionId: attr(child, "id") || void 0
+        };
+      } else if (name === "moveFrom") {
+        nextRevision = {
+          kind: "move_from",
+          author: attr(child, "author") || void 0,
+          revisionId: attr(child, "id") || void 0
+        };
+      } else if (name === "moveTo") {
+        nextRevision = {
+          kind: "move_to",
+          author: attr(child, "author") || void 0,
+          revisionId: attr(child, "id") || void 0
+        };
+      }
+      let nextCarrier = currentCarrier;
+      if (name === "r") {
+        nextCarrier = child;
+      }
+      let text = null;
+      let kind = nextRevision ? nextRevision.kind : "baseline";
+      let author = nextRevision?.author;
+      let revisionId = nextRevision?.revisionId;
+      if (name === "t") {
+        text = child.textContent || "";
+      } else if (name === "delText") {
+        text = child.textContent || "";
+        if (!nextRevision) {
+          kind = "deletion";
+        }
+      } else if (name === "tab") {
+        text = "	";
+      } else if (name === "br" || name === "cr") {
+        text = "\n";
+      } else if (name === "noBreakHyphen") {
+        text = "\u2011";
+      } else if (name === "softHyphen") {
+        text = "\xAD";
+      }
+      if (text !== null) {
+        if (text.length > 0) {
+          rawPieces.push({
+            text,
+            kind,
+            author,
+            revisionId,
+            carrier: nextCarrier || child,
+            carrierContainer: (nextCarrier || child)?.parentNode || null
+          });
+        }
+      } else {
+        walk(child, nextRevision, nextCarrier);
+      }
+    }
+  }
+  const initialCarrier = localName(paragraph) === "r" ? paragraph : null;
+  walk(paragraph, null, initialCarrier);
+  if (rawPieces.length === 0) return [];
+  const mergeRuns = options.mergeRuns !== false;
+  const merged = [];
+  let current = null;
+  for (const piece of rawPieces) {
+    if (!current) {
+      current = { ...piece };
+      continue;
+    }
+    const sameKind = current.kind === piece.kind;
+    const sameAuthor = current.author === piece.author;
+    const sameRevisionId = current.revisionId === piece.revisionId;
+    const sameCarrier = current.carrier === piece.carrier;
+    const compatibleContainer = mergeRuns && current.carrierContainer === piece.carrierContainer;
+    if (sameKind && sameAuthor && sameRevisionId && (sameCarrier || compatibleContainer)) {
+      current.text += piece.text;
+    } else {
+      merged.push(current);
+      current = { ...piece };
+    }
+  }
+  if (current) merged.push(current);
+  let acceptedCursor = 0;
+  let rejectedCursor = 0;
+  const segments = [];
+  for (const item of merged) {
+    const isAccepted = item.kind !== "deletion" && item.kind !== "move_from";
+    const isRejected = item.kind !== "insertion" && item.kind !== "move_to";
+    const acceptedStart = isAccepted ? acceptedCursor : null;
+    const rejectedStart = isRejected ? rejectedCursor : null;
+    if (isAccepted) acceptedCursor += item.text.length;
+    if (isRejected) rejectedCursor += item.text.length;
+    const segment = {
+      text: item.text,
+      kind: item.kind,
+      acceptedStart,
+      rejectedStart
+    };
+    if (item.author !== void 0) segment.author = item.author;
+    if (item.revisionId !== void 0) segment.revisionId = item.revisionId;
+    segments.push(segment);
+  }
+  return segments;
+}
+function extractCanonicalParagraphText(paragraph, options = {}) {
+  if (!paragraph) return "";
+  const view = options.revisionView === "current" ? "accepted" : options.revisionView || "accepted";
+  const segments = extractParagraphRevisionSegments(paragraph, options);
+  if (view === "rejected") {
+    return segments.filter((s) => s.rejectedStart !== null).map((s) => s.text).join("");
+  }
+  return segments.filter((s) => s.acceptedStart !== null).map((s) => s.text).join("");
+}
+
 // engine/table-cell-context.js
 var W14_NS = "http://schemas.microsoft.com/office/word/2010/wordml";
 function detectTableCellContext(xmlDoc, originalText, options = {}) {
@@ -5193,11 +5657,7 @@ function detectTableCellContext(xmlDoc, originalText, options = {}) {
     const normalizedTarget = originalText.trim();
     if (!targetParagraph) {
       for (const p of paragraphsInCells) {
-        const textNodes = getElementsByTagNSOrTag(p, NS_W, "t");
-        let paragraphText = "";
-        for (const t of textNodes) {
-          paragraphText += t.textContent || "";
-        }
+        const paragraphText = extractCanonicalParagraphText(p);
         if (paragraphText.trim() === normalizedTarget) {
           targetParagraph = p;
           log(`[OxmlEngine] Found target paragraph by text match: "${normalizedTarget.substring(0, 30)}..."`);
@@ -5246,10 +5706,11 @@ function getRunChildText(child) {
   if (isWordElement(child, "br") || isWordElement(child, "cr")) return "\n";
   if (isWordElement(child, "tab")) return "	";
   if (isWordElement(child, "noBreakHyphen")) return "\u2011";
+  if (isWordElement(child, "softHyphen")) return "\xAD";
   return "";
 }
 function isTextLikeRunChild(child) {
-  return isWordElement(child, "t") || isWordElement(child, "br") || isWordElement(child, "cr") || isWordElement(child, "tab") || isWordElement(child, "noBreakHyphen");
+  return isWordElement(child, "t") || isWordElement(child, "br") || isWordElement(child, "cr") || isWordElement(child, "tab") || isWordElement(child, "noBreakHyphen") || isWordElement(child, "softHyphen");
 }
 function buildSurgicalTextSpans(paragraphs) {
   let fullText = "";
@@ -5265,6 +5726,27 @@ function buildSurgicalTextSpans(paragraphs) {
             fullText += processRunElement(hc, paragraph, container, fullText.length, textSpans).text;
           }
         }
+      } else if (isWordElement(child, "ins")) {
+        for (let ic = child.firstChild; ic; ic = ic.nextSibling) {
+          if (isWordElement(ic, "r")) {
+            fullText += processRunElement(ic, paragraph, container, fullText.length, textSpans).text;
+          }
+        }
+      } else if (isWordElement(child, "sdt")) {
+        const sdtContent = Array.from(child.childNodes || []).find((n) => isWordElement(n, "sdtContent"));
+        if (sdtContent) {
+          for (let sc = sdtContent.firstChild; sc; sc = sc.nextSibling) {
+            if (isWordElement(sc, "r")) {
+              fullText += processRunElement(sc, paragraph, container, fullText.length, textSpans).text;
+            }
+          }
+        }
+      } else if (isWordElement(child, "smartTag")) {
+        for (let st = child.firstChild; st; st = st.nextSibling) {
+          if (isWordElement(st, "r")) {
+            fullText += processRunElement(st, paragraph, container, fullText.length, textSpans).text;
+          }
+        }
       }
     }
     fullText = appendParagraphBoundary(fullText, paragraphIndex, paragraphs.length);
@@ -5374,6 +5856,28 @@ function lowerBound(values, target) {
   }
   return left;
 }
+function describeInsertionBoundary(spanIndex, pos, fallbackParagraph = null) {
+  if (!spanIndex || !spanIndex.spans || spanIndex.spans.length === 0) {
+    return {
+      leftSpan: null,
+      rightSpan: null,
+      containingSpan: null,
+      isInterior: false,
+      fallbackParagraph
+    };
+  }
+  const containingSpan = findContainingSpan(spanIndex, pos);
+  const isInterior = containingSpan !== null && pos > containingSpan.charStart && pos < containingSpan.charEnd;
+  const leftSpan = findFirstSpanEndingAt(spanIndex, pos) || (pos > 0 ? findLastSpanEndingBeforeOrAt(spanIndex, pos) : null);
+  const rightSpan = spanIndex.spans.find((s) => s.charStart === pos) || (pos === 0 ? spanIndex.spans[0] : null);
+  return {
+    leftSpan,
+    rightSpan,
+    containingSpan,
+    isInterior,
+    fallbackParagraph
+  };
+}
 
 // engine/surgical-run-splitting.js
 function getRunContentPieces(runElement) {
@@ -5487,7 +5991,7 @@ function reconcileFormattingForTextSpan(xmlDoc, span, start, end, applicableHint
   parent.removeChild(span.runElement);
   return true;
 }
-function processDelete(xmlDoc, spanIndex, startPos, endPos, author, generateRedlines) {
+function processDelete(xmlDoc, spanIndex, startPos, endPos, author, generateRedlines, revisionMetadata = null) {
   const spans = [];
   forEachOverlappingSpan(spanIndex, startPos, endPos, (span) => {
     spans.push(span);
@@ -5500,6 +6004,7 @@ function processDelete(xmlDoc, spanIndex, startPos, endPos, author, generateRedl
     spansByRun.get(span.runElement).push(span);
   });
   let changed = false;
+  let usedDelMetadata = false;
   spansByRun.forEach((runSpans, runElement) => {
     const parent = runElement.parentNode;
     if (!parent) return;
@@ -5523,7 +6028,9 @@ function processDelete(xmlDoc, spanIndex, startPos, endPos, author, generateRedl
     insertRunPiecesBefore(xmlDoc, parent, runElement, beforePieces, runSpans[0].rPr);
     if (generateRedlines && deletedPieces.length > 0) {
       const delRun = createRunFromPieces(xmlDoc, deletedPieces, runSpans[0].rPr);
-      const delWrapper = createTrackChange(xmlDoc, "del", delRun, author);
+      const metadata = revisionMetadata ? usedDelMetadata ? { ...revisionMetadata, id: createRevisionMetadata(author, xmlDoc).id } : revisionMetadata : null;
+      usedDelMetadata = true;
+      const delWrapper = createTrackChange(xmlDoc, "del", delRun, author, metadata);
       parent.insertBefore(delWrapper, runElement);
     }
     insertRunPiecesBefore(xmlDoc, parent, runElement, afterPieces, runSpans[0].rPr);
@@ -5532,50 +6039,200 @@ function processDelete(xmlDoc, spanIndex, startPos, endPos, author, generateRedl
   });
   return changed;
 }
-function processInsert(xmlDoc, spanIndex, pos, text, author, formatHints = [], insertOffset = 0, generateRedlines = true, fallbackParagraph = null) {
-  let targetSpan = findContainingSpan(spanIndex, pos);
-  if (!targetSpan && pos > 0) {
-    targetSpan = findFirstSpanEndingAt(spanIndex, pos);
+function processInsert(xmlDoc, spanIndex, pos, text, author, formatHints = [], insertOffset = 0, generateRedlines = true, fallbackParagraph = null, revisionMetadata = null, affinity = null) {
+  if (!affinity) {
+    let targetSpan = findContainingSpan(spanIndex, pos);
+    if (!targetSpan && pos > 0) {
+      targetSpan = findFirstSpanEndingAt(spanIndex, pos);
+    }
+    if (!targetSpan && pos > 0) {
+      targetSpan = findLastSpanEndingBeforeOrAt(spanIndex, pos);
+    }
+    if (!targetSpan && spanIndex.spans.length > 0) {
+      targetSpan = spanIndex.spans[spanIndex.spans.length - 1];
+    }
+    if (!targetSpan) {
+      if (!fallbackParagraph) return false;
+      insertTextRuns(xmlDoc, fallbackParagraph, null, text, null, author, formatHints, insertOffset, generateRedlines, revisionMetadata);
+      return true;
+    }
+    const parent2 = targetSpan.runElement.parentNode;
+    if (!parent2) {
+      if (!fallbackParagraph) return false;
+      insertTextRuns(xmlDoc, fallbackParagraph, null, text, targetSpan.rPr, author, formatHints, insertOffset, generateRedlines, revisionMetadata);
+      return true;
+    }
+    const pieces = getRunContentPieces(targetSpan.runElement);
+    const targetPiece = pieces.find((piece) => piece.node === targetSpan.textElement);
+    const localInsertPos = targetPiece ? targetPiece.start + Math.max(0, Math.min(pos - targetSpan.charStart, targetSpan.charEnd - targetSpan.charStart)) : pos <= targetSpan.charStart ? 0 : getRunTextLength(pieces);
+    if (localInsertPos > 0 && localInsertPos < getRunTextLength(pieces)) {
+      const beforePieces = sliceRunPieces(xmlDoc, pieces, 0, localInsertPos, false);
+      const afterPieces = sliceRunPieces(xmlDoc, pieces, localInsertPos, getRunTextLength(pieces), false);
+      insertRunPiecesBefore(xmlDoc, parent2, targetSpan.runElement, beforePieces, targetSpan.rPr);
+      insertTextRuns(xmlDoc, parent2, targetSpan.runElement, text, targetSpan.rPr, author, formatHints, insertOffset, generateRedlines, revisionMetadata);
+      insertRunPiecesBefore(xmlDoc, parent2, targetSpan.runElement, afterPieces, targetSpan.rPr);
+      parent2.removeChild(targetSpan.runElement);
+      return true;
+    }
+    const referenceNode2 = pos <= targetSpan.charStart ? targetSpan.runElement : targetSpan.runElement.nextSibling;
+    insertTextRuns(xmlDoc, parent2, referenceNode2, text, targetSpan.rPr, author, formatHints, insertOffset, generateRedlines, revisionMetadata);
+    return true;
   }
-  if (!targetSpan && pos > 0) {
-    targetSpan = findLastSpanEndingBeforeOrAt(spanIndex, pos);
+  const boundary = describeInsertionBoundary(spanIndex, pos, fallbackParagraph);
+  const isLeftInHyperlink = boundary.leftSpan && isWordElement(boundary.leftSpan.runElement?.parentNode, "hyperlink");
+  const isRightInHyperlink = boundary.rightSpan && isWordElement(boundary.rightSpan.runElement?.parentNode, "hyperlink");
+  const isContainingInHyperlink = boundary.containingSpan && isWordElement(boundary.containingSpan.runElement?.parentNode, "hyperlink");
+  if (affinity.hyperlink === "outside") {
+    if (boundary.isInterior && isContainingInHyperlink) {
+      return {
+        error: {
+          code: "UNSUPPORTED_INSERTION_AFFINITY",
+          message: "Cannot place insertion outside hyperlink from strictly interior position."
+        }
+      };
+    }
+  } else if (affinity.hyperlink === "inside") {
+    if (!isLeftInHyperlink && !isRightInHyperlink && !isContainingInHyperlink) {
+      return {
+        error: {
+          code: "UNSUPPORTED_INSERTION_AFFINITY",
+          message: "Cannot place insertion inside hyperlink when no hyperlink is present at boundary."
+        }
+      };
+    }
   }
-  if (!targetSpan && spanIndex.spans.length > 0) {
-    targetSpan = spanIndex.spans[spanIndex.spans.length - 1];
+  let baseRPr = null;
+  if (affinity.formatting === "none") {
+    baseRPr = null;
+  } else if (affinity.formatting === "right") {
+    baseRPr = boundary.rightSpan?.rPr || null;
+  } else if (affinity.formatting === "left") {
+    baseRPr = boundary.leftSpan?.rPr || null;
+  } else {
+    baseRPr = (boundary.containingSpan || boundary.leftSpan || boundary.rightSpan)?.rPr || null;
+  }
+  if (boundary.isInterior) {
+    const targetSpan = boundary.containingSpan;
+    const parent2 = targetSpan.runElement.parentNode || fallbackParagraph;
+    if (!parent2) return false;
+    const pieces = getRunContentPieces(targetSpan.runElement);
+    const targetPiece = pieces.find((piece) => piece.node === targetSpan.textElement);
+    const localInsertPos = targetPiece ? targetPiece.start + Math.max(0, Math.min(pos - targetSpan.charStart, targetSpan.charEnd - targetSpan.charStart)) : pos <= targetSpan.charStart ? 0 : getRunTextLength(pieces);
+    if (localInsertPos > 0 && localInsertPos < getRunTextLength(pieces)) {
+      const beforePieces = sliceRunPieces(xmlDoc, pieces, 0, localInsertPos, false);
+      const afterPieces = sliceRunPieces(xmlDoc, pieces, localInsertPos, getRunTextLength(pieces), false);
+      insertRunPiecesBefore(xmlDoc, parent2, targetSpan.runElement, beforePieces, targetSpan.rPr);
+      insertTextRuns(xmlDoc, parent2, targetSpan.runElement, text, baseRPr, author, formatHints, insertOffset, generateRedlines, revisionMetadata);
+      insertRunPiecesBefore(xmlDoc, parent2, targetSpan.runElement, afterPieces, targetSpan.rPr);
+      parent2.removeChild(targetSpan.runElement);
+      return true;
+    }
   }
-  if (!targetSpan) {
-    if (!fallbackParagraph) return false;
-    insertTextRuns(xmlDoc, fallbackParagraph, null, text, null, author, formatHints, insertOffset, generateRedlines);
-    return true;
+  let parent = null;
+  let referenceNode = null;
+  if (affinity.hyperlink === "outside") {
+    if (isRightInHyperlink) {
+      const hyperlinkNode = boundary.rightSpan.runElement.parentNode;
+      parent = hyperlinkNode.parentNode || fallbackParagraph;
+      referenceNode = hyperlinkNode;
+    } else if (isLeftInHyperlink) {
+      const hyperlinkNode = boundary.leftSpan.runElement.parentNode;
+      parent = hyperlinkNode.parentNode || fallbackParagraph;
+      referenceNode = hyperlinkNode.nextSibling;
+    }
+  } else if (affinity.hyperlink === "inside") {
+    if (isRightInHyperlink) {
+      parent = boundary.rightSpan.runElement.parentNode;
+      referenceNode = boundary.rightSpan.runElement;
+    } else if (isLeftInHyperlink) {
+      parent = boundary.leftSpan.runElement.parentNode;
+      referenceNode = boundary.leftSpan.runElement.nextSibling;
+    }
   }
-  const parent = targetSpan.runElement.parentNode;
   if (!parent) {
-    if (!fallbackParagraph) return false;
-    insertTextRuns(xmlDoc, fallbackParagraph, null, text, targetSpan.rPr, author, formatHints, insertOffset, generateRedlines);
-    return true;
+    if (boundary.rightSpan) {
+      parent = boundary.rightSpan.runElement.parentNode || fallbackParagraph;
+      referenceNode = boundary.rightSpan.runElement;
+    } else if (boundary.leftSpan) {
+      parent = boundary.leftSpan.runElement.parentNode || fallbackParagraph;
+      referenceNode = boundary.leftSpan.runElement.nextSibling;
+    } else {
+      parent = fallbackParagraph;
+      referenceNode = null;
+    }
   }
-  const pieces = getRunContentPieces(targetSpan.runElement);
-  const targetPiece = pieces.find((piece) => piece.node === targetSpan.textElement);
-  const localInsertPos = targetPiece ? targetPiece.start + Math.max(0, Math.min(pos - targetSpan.charStart, targetSpan.charEnd - targetSpan.charStart)) : pos <= targetSpan.charStart ? 0 : getRunTextLength(pieces);
-  if (localInsertPos > 0 && localInsertPos < getRunTextLength(pieces)) {
-    const beforePieces = sliceRunPieces(xmlDoc, pieces, 0, localInsertPos, false);
-    const afterPieces = sliceRunPieces(xmlDoc, pieces, localInsertPos, getRunTextLength(pieces), false);
-    insertRunPiecesBefore(xmlDoc, parent, targetSpan.runElement, beforePieces, targetSpan.rPr);
-    insertTextRuns(xmlDoc, parent, targetSpan.runElement, text, targetSpan.rPr, author, formatHints, insertOffset, generateRedlines);
-    insertRunPiecesBefore(xmlDoc, parent, targetSpan.runElement, afterPieces, targetSpan.rPr);
-    parent.removeChild(targetSpan.runElement);
-    return true;
+  if (affinity.bookmark && parent) {
+    if (affinity.bookmark === "outside") {
+      if (referenceNode && isWordElement(referenceNode.previousSibling, "bookmarkStart")) {
+        referenceNode = referenceNode.previousSibling;
+      }
+      if (boundary.leftSpan && isWordElement(boundary.leftSpan.runElement.nextSibling, "bookmarkEnd")) {
+        referenceNode = boundary.leftSpan.runElement.nextSibling.nextSibling;
+      }
+    } else if (affinity.bookmark === "inside") {
+      if (referenceNode && isWordElement(referenceNode, "bookmarkStart")) {
+        referenceNode = referenceNode.nextSibling;
+      }
+      if (boundary.leftSpan && isWordElement(boundary.leftSpan.runElement.nextSibling, "bookmarkEnd")) {
+        referenceNode = boundary.leftSpan.runElement.nextSibling;
+      }
+    }
+  }
+  if (affinity.comment && parent) {
+    if (affinity.comment === "outside") {
+      if (referenceNode && isWordElement(referenceNode.previousSibling, "commentRangeStart")) {
+        referenceNode = referenceNode.previousSibling;
+      }
+      if (boundary.leftSpan && isWordElement(boundary.leftSpan.runElement.nextSibling, "commentRangeEnd")) {
+        let afterComment = boundary.leftSpan.runElement.nextSibling.nextSibling;
+        if (afterComment && (isWordElement(afterComment, "commentReference") || isWordElement(afterComment, "r"))) {
+          const hasCRef = Array.from(afterComment.childNodes || []).some((n) => isWordElement(n, "commentReference"));
+          if (hasCRef) afterComment = afterComment.nextSibling;
+        }
+        referenceNode = afterComment;
+      }
+    } else if (affinity.comment === "inside") {
+      if (referenceNode && isWordElement(referenceNode, "commentRangeStart")) {
+        referenceNode = referenceNode.nextSibling;
+      }
+      if (boundary.leftSpan && isWordElement(boundary.leftSpan.runElement.nextSibling, "commentRangeEnd")) {
+        referenceNode = boundary.leftSpan.runElement.nextSibling;
+      }
+    }
+  }
+  if (generateRedlines && affinity.revision === "coalesce_same_author") {
+    let insElem = null;
+    let insRef = null;
+    if (boundary.leftSpan && isWordElement(boundary.leftSpan.runElement.parentNode, "ins")) {
+      const candidate = boundary.leftSpan.runElement.parentNode;
+      const candAuthor = candidate.getAttribute("w:author") || candidate.getAttributeNS(NS_W, "author");
+      if (candAuthor === author) {
+        insElem = candidate;
+        insRef = boundary.leftSpan.runElement.nextSibling;
+      }
+    } else if (boundary.rightSpan && isWordElement(boundary.rightSpan.runElement.parentNode, "ins")) {
+      const candidate = boundary.rightSpan.runElement.parentNode;
+      const candAuthor = candidate.getAttribute("w:author") || candidate.getAttributeNS(NS_W, "author");
+      if (candAuthor === author) {
+        insElem = candidate;
+        insRef = boundary.rightSpan.runElement;
+      }
+    }
+    if (insElem) {
+      const insRun = createTextRun(xmlDoc, text, baseRPr, false);
+      insElem.insertBefore(insRun, insRef);
+      return true;
+    }
   }
-  const referenceNode = pos <= targetSpan.charStart ? targetSpan.runElement : targetSpan.runElement.nextSibling;
-  insertTextRuns(xmlDoc, parent, referenceNode, text, targetSpan.rPr, author, formatHints, insertOffset, generateRedlines);
+  insertTextRuns(xmlDoc, parent, referenceNode, text, baseRPr, author, formatHints, insertOffset, generateRedlines, revisionMetadata);
   return true;
 }
-function insertTextRuns(xmlDoc, parent, referenceNode, text, baseRPr, author, formatHints, insertOffset, generateRedlines) {
+function insertTextRuns(xmlDoc, parent, referenceNode, text, baseRPr, author, formatHints, insertOffset, generateRedlines, revisionMetadata = null) {
   const applicableHints = getApplicableFormatHints(formatHints, insertOffset, insertOffset + text.length);
   if (applicableHints.length === 0) {
     const insRun = createTextRun(xmlDoc, text, baseRPr, false);
     if (generateRedlines) {
-      const insWrapper = createTrackChange(xmlDoc, "ins", insRun, author);
+      const insWrapper = createTrackChange(xmlDoc, "ins", insRun, author, revisionMetadata);
       parent.insertBefore(insWrapper, referenceNode);
     } else {
       parent.insertBefore(insRun, referenceNode);
@@ -5584,7 +6241,7 @@ function insertTextRuns(xmlDoc, parent, referenceNode, text, baseRPr, author, fo
   }
   const runs = createFormattedRuns(xmlDoc, text, baseRPr, applicableHints, insertOffset, author, generateRedlines);
   if (generateRedlines) {
-    const insWrapper = createTrackChange(xmlDoc, "ins", null, author);
+    const insWrapper = createTrackChange(xmlDoc, "ins", null, author, revisionMetadata);
     runs.forEach((run) => insWrapper.appendChild(run));
     parent.insertBefore(insWrapper, referenceNode);
   } else {
@@ -5593,16 +6250,82 @@ function insertTextRuns(xmlDoc, parent, referenceNode, text, baseRPr, author, fo
 }
 
 // engine/surgical-mode.js
-function applySurgicalMode(xmlDoc, originalText, modifiedText, serializer, author, formatHints, generateRedlines = true, targetParagraph = null, diffOptions = {}) {
-  void originalText;
+function checkSafeAdjacencyForPairing(spanIndex, startPos, endPos) {
+  const spans = [];
+  forEachOverlappingSpan(spanIndex, startPos, endPos, (span) => spans.push(span));
+  if (spans.length === 0) return { safe: false };
+  const firstRun = spans[0].runElement;
+  const parent = firstRun?.parentNode;
+  if (!parent) return { safe: false };
+  const sameParent = spans.every((s) => s.runElement?.parentNode === parent);
+  if (!sameParent) return { safe: false, structuralBoundary: true };
+  const parentLocal = parent.localName || parent.nodeName.replace(/^.*:/, "");
+  if (["hyperlink", "sdt", "ins", "del", "moveFrom", "moveTo"].includes(parentLocal)) {
+    return { safe: false, structuralBoundary: true };
+  }
+  const structuralTags = /* @__PURE__ */ new Set([
+    "hyperlink",
+    "fldSimple",
+    "sdt",
+    "commentRangeStart",
+    "commentRangeEnd",
+    "commentReference",
+    "bookmarkStart",
+    "bookmarkEnd",
+    "moveFrom",
+    "moveTo",
+    "ins",
+    "del"
+  ]);
+  for (const span of spans) {
+    const run = span.runElement;
+    for (const child of Array.from(run.childNodes || [])) {
+      if (child.nodeType === 1) {
+        const tag = child.localName || child.nodeName.replace(/^.*:/, "");
+        if (structuralTags.has(tag) || tag === "fldChar") {
+          return { safe: false, structuralBoundary: true };
+        }
+      }
+    }
+  }
+  const lastRun = spans[spans.length - 1].runElement;
+  let curr = firstRun;
+  while (curr && curr !== lastRun) {
+    if (curr !== firstRun) {
+      const tag = curr.localName || curr.nodeName.replace(/^.*:/, "");
+      if (structuralTags.has(tag)) {
+        return { safe: false, structuralBoundary: true };
+      }
+    }
+    curr = curr.nextSibling;
+  }
+  function hasStructuralDescendant(node) {
+    if (!node || node.nodeType !== 1) return false;
+    const tag = node.localName || node.nodeName.replace(/^.*:/, "");
+    if (structuralTags.has(tag) || tag === "fldChar") return true;
+    for (const child of Array.from(node.childNodes || [])) {
+      if (child.nodeType === 1 && hasStructuralDescendant(child)) return true;
+    }
+    return false;
+  }
+  if (hasStructuralDescendant(firstRun.previousSibling) || hasStructuralDescendant(lastRun.nextSibling)) {
+    return { safe: false, structuralBoundary: true };
+  }
+  return { safe: true };
+}
+function applySurgicalMode(xmlDoc, originalText, modifiedText, serializer, author, formatHints, generateRedlines = true, targetParagraph = null, diffOptions = {}, options = {}) {
+  void originalText;
   const allParagraphs = targetParagraph ? [targetParagraph] : getDocumentParagraphs(xmlDoc);
   const { fullText, textSpans } = buildSurgicalTextSpans(allParagraphs);
   const diffs = computeWordDiffs(fullText, modifiedText, diffOptions);
   const spanIndex = buildSpanIndex(textSpans);
+  const pairReplacements = options.pairReplacements === true;
+  const warnings = [];
   let originalPos = 0;
   let newPos = 0;
   let hasChanges = false;
-  for (const [op, text] of diffs) {
+  for (let i = 0; i < diffs.length; i++) {
+    const [op, text] = diffs[i];
     if (op === 0) {
       const len = text.length;
       const startPos = originalPos;
@@ -5622,21 +6345,73 @@ function applySurgicalMode(xmlDoc, originalText, modifiedText, serializer, autho
       originalPos += len;
       newPos += len;
     } else if (op === -1) {
-      if (processDelete(xmlDoc, spanIndex, originalPos, originalPos + text.length, author, generateRedlines)) {
+      const hasNextInsert = i + 1 < diffs.length && diffs[i + 1][0] === 1;
+      let paired = false;
+      let delMetadata = null;
+      let insMetadata = null;
+      if (pairReplacements && generateRedlines && hasNextInsert) {
+        const nextText = diffs[i + 1][1];
+        const textWithoutNewlines = nextText.replace(/\n/g, " ");
+        if (textWithoutNewlines.trim().length > 0) {
+          const checkResult = checkSafeAdjacencyForPairing(spanIndex, originalPos, originalPos + text.length);
+          if (checkResult.safe) {
+            const event = createReplacementRevisionEvent(author, xmlDoc);
+            delMetadata = { id: event.deletionId, author: event.author, date: event.date };
+            insMetadata = { id: event.insertionId, author: event.author, date: event.date };
+            paired = true;
+          } else if (checkResult.structuralBoundary) {
+            warnings.push("PAIRING_SKIPPED_STRUCTURAL_BOUNDARY");
+          }
+        }
+      }
+      if (processDelete(xmlDoc, spanIndex, originalPos, originalPos + text.length, author, generateRedlines, delMetadata)) {
         hasChanges = true;
       }
       originalPos += text.length;
+      if (paired) {
+        i++;
+        const [, nextText] = diffs[i];
+        const textWithoutNewlines = nextText.replace(/\n/g, " ");
+        if (textWithoutNewlines.trim().length > 0) {
+          const insertResult = processInsert(xmlDoc, spanIndex, originalPos, textWithoutNewlines, author, formatHints, newPos, generateRedlines, allParagraphs[0] || null, insMetadata, options?.insertionAffinity || null);
+          if (insertResult && typeof insertResult === "object" && insertResult.error) {
+            return withOoxmlSourceType({
+              oxml: serializer.serializeToString(xmlDoc),
+              hasChanges: false,
+              status: "error",
+              error: insertResult.error
+            });
+          }
+          if (insertResult === true) {
+            hasChanges = true;
+          }
+        }
+        newPos += nextText.length;
+      }
     } else if (op === 1) {
       const textWithoutNewlines = text.replace(/\n/g, " ");
       if (textWithoutNewlines.trim().length > 0) {
-        if (processInsert(xmlDoc, spanIndex, originalPos, textWithoutNewlines, author, formatHints, newPos, generateRedlines, allParagraphs[0] || null)) {
+        const insertResult = processInsert(xmlDoc, spanIndex, originalPos, textWithoutNewlines, author, formatHints, newPos, generateRedlines, allParagraphs[0] || null, null, options?.insertionAffinity || null);
+        if (insertResult && typeof insertResult === "object" && insertResult.error) {
+          return withOoxmlSourceType({
+            oxml: serializer.serializeToString(xmlDoc),
+            hasChanges: false,
+            status: "error",
+            error: insertResult.error
+          });
+        }
+        if (insertResult === true) {
           hasChanges = true;
         }
       }
       newPos += text.length;
     }
   }
-  return withOoxmlSourceType({ oxml: serializer.serializeToString(xmlDoc), hasChanges });
+  return withOoxmlSourceType({
+    oxml: serializer.serializeToString(xmlDoc),
+    hasChanges,
+    ...warnings.length > 0 ? { warnings: [...new Set(warnings)] } : {}
+  });
 }
 
 // engine/reconstruction-mapper.js
@@ -5645,8 +6420,8 @@ var DMP = new import_diff_match_patch2.diff_match_patch();
 function localNameOf(node) {
   return String(node?.localName || node?.nodeName || "").replace(/^.*:/, "");
 }
-function wordAttribute(node, localName) {
-  return node?.getAttributeNS?.(NS_W, localName) || node?.getAttribute?.(`w:${localName}`) || node?.getAttribute?.(localName) || "";
+function wordAttribute(node, localName2) {
+  return node?.getAttributeNS?.(NS_W, localName2) || node?.getAttribute?.(`w:${localName2}`) || node?.getAttribute?.(localName2) || "";
 }
 function createRangeCursorLookup2(ranges) {
   let cursor = 0;
@@ -6021,7 +6796,7 @@ function processHyperlinkForReconstruction(hyperlinkElement, originalFullText, p
 }
 
 // engine/reconstruction-writer.js
-function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, author, formatHints, generateRedlines = true) {
+function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, author, formatHints, generateRedlines = true, options = {}) {
   const {
     paragraphs,
     containerFragments,
@@ -6035,7 +6810,14 @@ function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, author, fo
   } = context;
   const createNewParagraph = (pPr) => {
     const newParagraph = createWordElement(xmlDoc, "w:p");
-    if (pPr) newParagraph.appendChild(pPr.cloneNode(true));
+    if (pPr) {
+      const clonedPPr = pPr.cloneNode(true);
+      const sectPr = getFirstElementByTagNSOrTag(clonedPPr, NS_W, "sectPr");
+      if (sectPr) {
+        clonedPPr.removeChild(sectPr);
+      }
+      newParagraph.appendChild(clonedPPr);
+    }
     return newParagraph;
   };
   const startInfo = getParagraphInfo(0);
@@ -6046,15 +6828,30 @@ function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, author, fo
   }
   let currentOriginalIndex = 0;
   let currentInsertOffset = 0;
+  const pairReplacements = options?.pairReplacements === true;
   let pendingReplacementStart = null;
+  let pendingReplacementEvent = null;
   const emittedCommentMarkers = /* @__PURE__ */ new WeakSet();
-  for (const [op, text] of diffs) {
+  for (let diffIndex = 0; diffIndex < diffs.length; diffIndex++) {
+    const [op, text] = diffs[diffIndex];
     if (op === 0 || op === -1) {
       const type = op === 0 ? "equal" : "delete";
       if (op === 0) {
         pendingReplacementStart = null;
+        pendingReplacementEvent = null;
       } else if (pendingReplacementStart === null) {
         pendingReplacementStart = currentOriginalIndex;
+        let hasInsert = false;
+        for (let k = diffIndex + 1; k < diffs.length; k++) {
+          if (diffs[k][0] === 1) {
+            hasInsert = true;
+            break;
+          }
+          if (diffs[k][0] === 0) break;
+        }
+        if (pairReplacements && generateRedlines && hasInsert) {
+          pendingReplacementEvent = createReplacementRevisionEvent(author, xmlDoc);
+        }
       }
       let offset = 0;
       while (offset < text.length) {
@@ -6080,7 +6877,8 @@ function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, author, fo
           formatHints,
           currentInsertOffset,
           generateRedlines,
-          emittedCommentMarkers
+          emittedCommentMarkers,
+          pendingReplacementEvent
         );
         currentParagraph = appendResult.currentParagraph;
         if (op === 0) {
@@ -6112,13 +6910,47 @@ function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, author, fo
         formatHints,
         currentInsertOffset,
         generateRedlines,
-        emittedCommentMarkers
+        emittedCommentMarkers,
+        pendingReplacementEvent,
+        pendingReplacementStart !== null
       );
       currentParagraph = appendResult.currentParagraph;
       currentInsertOffset += text.length;
       pendingReplacementStart = null;
+      pendingReplacementEvent = null;
     }
   }
+  if (generateRedlines) {
+    containerFragments.forEach((fragment) => {
+      Array.from(fragment.childNodes).forEach((node) => {
+        if (isWordElement(node, "p")) {
+          const hasVisibleText = Array.from(node.getElementsByTagNameNS(NS_W, "t")).length > 0;
+          const hasDeletedText = Array.from(node.getElementsByTagNameNS(NS_W, "delText")).length > 0;
+          if (paragraphs.length === 1 && !hasVisibleText && (hasDeletedText || context.originalFullText.trim() !== "")) {
+            markParagraphMarkDeleted(xmlDoc, node, author);
+          }
+        }
+      });
+    });
+  }
+  containerFragments.forEach((fragment) => {
+    const createdParagraphs = Array.from(fragment.childNodes).filter((node) => isWordElement(node, "p"));
+    if (createdParagraphs.length > 1) {
+      const firstP = createdParagraphs[0];
+      const lastP = createdParagraphs[createdParagraphs.length - 1];
+      const firstPPr = getFirstElementByTagNSOrTag(firstP, NS_W, "pPr");
+      const sectPr = firstPPr ? getFirstElementByTagNSOrTag(firstPPr, NS_W, "sectPr") : null;
+      if (sectPr) {
+        firstPPr.removeChild(sectPr);
+        let lastPPr = getFirstElementByTagNSOrTag(lastP, NS_W, "pPr");
+        if (!lastPPr) {
+          lastPPr = createWordElement(xmlDoc, "w:pPr");
+          lastP.insertBefore(lastPPr, lastP.firstChild || null);
+        }
+        lastPPr.appendChild(sectPr);
+      }
+    }
+  });
   const paragraphSet = new Set(paragraphs);
   const insertionAnchors = /* @__PURE__ */ new Map();
   paragraphs.forEach((paragraph) => {
@@ -6157,16 +6989,23 @@ function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, author, fo
   const oxml = hasDocumentTarget && serializedDocumentOutput ? serializedDocumentOutput : serializer.serializeToString(xmlDoc);
   return { oxml, hasChanges: true };
 }
-function appendTextToCurrent(xmlDoc, text, type, rPr, wrapper, baseIndex, currentParagraphRef, containerFragments, sentinelMapByStart, referenceMap, replacementContainers, getParagraphInfo, createNewParagraph, author, formatHints = [], insertOffset = 0, generateRedlines = true, emittedCommentMarkers = /* @__PURE__ */ new WeakSet()) {
+function appendTextToCurrent(xmlDoc, text, type, rPr, wrapper, baseIndex, currentParagraphRef, containerFragments, sentinelMapByStart, referenceMap, replacementContainers, getParagraphInfo, createNewParagraph, author, formatHints = [], insertOffset = 0, generateRedlines = true, emittedCommentMarkers = /* @__PURE__ */ new WeakSet(), replacementEvent = null, deferClosingCommentMarkers = false) {
   let localBaseIndex = baseIndex;
   let localInsertOffset = insertOffset;
   let localParagraph = currentParagraphRef;
+  const deferredCommentMarkers = [];
   const parts = text.split(/([\n\uFFFC]|[\uE000-\uF8FF])/);
   parts.forEach((part) => {
     const sentinelsAtOffset = sentinelMapByStart.get(localBaseIndex) || [];
     const commentMarkers = sentinelsAtOffset.filter((sentinel) => sentinel.isCommentMarker && !emittedCommentMarkers.has(sentinel.node));
+    const closingCommentIds = deferClosingCommentMarkers ? new Set(commentMarkers.filter((marker) => isWordElement(marker.node, "commentRangeEnd")).map((marker) => marker.node.getAttributeNS?.(NS_W, "id") || marker.node.getAttribute?.("w:id") || marker.node.getAttribute?.("id"))) : /* @__PURE__ */ new Set();
     commentMarkers.forEach((marker) => {
       emittedCommentMarkers.add(marker.node);
+      const markerId = marker.node.getAttributeNS?.(NS_W, "id") || marker.node.getAttribute?.("w:id") || marker.node.getAttribute?.("id");
+      if (deferClosingCommentMarkers && closingCommentIds.has(markerId) && (isWordElement(marker.node, "commentRangeEnd") || isWordElement(marker.node, "commentReference"))) {
+        deferredCommentMarkers.push(marker.node);
+        return;
+      }
       if (isWordElement(marker.node, "commentReference")) {
         const run = createWordElement(xmlDoc, "w:r");
         run.appendChild(marker.node.cloneNode(true));
@@ -6246,14 +7085,34 @@ function appendTextToCurrent(xmlDoc, text, type, rPr, wrapper, baseIndex, curren
       delText.textContent = part;
       run.appendChild(delText);
       if (generateRedlines) {
-        const del = createTrackChange(xmlDoc, "del", run, author);
+        let metadata = null;
+        if (replacementEvent) {
+          const id = replacementEvent.usedDeletionId ? createRevisionMetadata(author, xmlDoc, "del").id : replacementEvent.deletionId;
+          replacementEvent.usedDeletionId = true;
+          metadata = {
+            id,
+            author: replacementEvent.author,
+            date: replacementEvent.date
+          };
+        }
+        const del = createTrackChange(xmlDoc, "del", run, author, metadata);
         parent.appendChild(del);
       }
     } else {
       const applicableHints = getApplicableFormatHints(formatHints, localInsertOffset, localInsertOffset + part.length);
       const runs = createFormattedRuns(xmlDoc, part, rPr, applicableHints, localInsertOffset, author, generateRedlines);
       if (type === "insert" && generateRedlines) {
-        const ins = createTrackChange(xmlDoc, "ins", null, author);
+        let metadata = null;
+        if (replacementEvent) {
+          const id = replacementEvent.usedInsertionId ? createRevisionMetadata(author, xmlDoc, "ins").id : replacementEvent.insertionId;
+          replacementEvent.usedInsertionId = true;
+          metadata = {
+            id,
+            author: replacementEvent.author,
+            date: replacementEvent.date
+          };
+        }
+        const ins = createTrackChange(xmlDoc, "ins", null, author, metadata);
         runs.forEach((run) => ins.appendChild(run));
         parent.appendChild(ins);
       } else {
@@ -6265,11 +7124,20 @@ function appendTextToCurrent(xmlDoc, text, type, rPr, wrapper, baseIndex, curren
     }
     localBaseIndex += part.length;
   });
+  deferredCommentMarkers.forEach((marker) => {
+    if (isWordElement(marker, "commentReference")) {
+      const run = createWordElement(xmlDoc, "w:r");
+      run.appendChild(marker.cloneNode(true));
+      localParagraph.appendChild(run);
+    } else {
+      localParagraph.appendChild(marker.cloneNode(true));
+    }
+  });
   return { currentParagraph: localParagraph };
 }
 
 // engine/reconstruction-mode.js
-function applyReconstructionMode(xmlDoc, originalText, modifiedText, serializer, author, formatHints, generateRedlines = true, diffOptions = {}) {
+function applyReconstructionMode(xmlDoc, originalText, modifiedText, serializer, author, formatHints, generateRedlines = true, diffOptions = {}, options = {}) {
   const selectedParagraphs = findReconstructionParagraphRange(xmlDoc, originalText);
   if (selectedParagraphs === null) {
     return withOoxmlSourceType({
@@ -6294,7 +7162,8 @@ function applyReconstructionMode(xmlDoc, originalText, modifiedText, serializer,
     serializer,
     author,
     formatHints,
-    generateRedlines
+    generateRedlines,
+    options
   ));
 }
 
@@ -6399,7 +7268,7 @@ function applyTextToTableTransformation(xmlDoc, modifiedText, serializer, parser
           }
         });
         const del = createWordElement(workingDoc, "w:del");
-        const metadata = createRevisionMetadata(author, workingDoc);
+        const metadata = createRevisionMetadata(author, workingDoc, "del");
         del.setAttribute("w:id", String(metadata.id));
         del.setAttribute("w:author", metadata.author);
         del.setAttribute("w:date", metadata.date);
@@ -6419,15 +7288,15 @@ function applyTextToTableTransformation(xmlDoc, modifiedText, serializer, parser
 }
 
 // services/revision-comment-management.js
-function getAttributeByLocalName(node, localName) {
+function getAttributeByLocalName(node, localName2) {
   if (!node || !node.attributes) return "";
-  for (const attr of Array.from(node.attributes)) {
-    if ((attr.localName || "").toLowerCase() === localName.toLowerCase()) {
-      return String(attr.value || "");
+  for (const attr4 of Array.from(node.attributes)) {
+    if ((attr4.localName || "").toLowerCase() === localName2.toLowerCase()) {
+      return String(attr4.value || "");
     }
   }
   return String(
-    node.getAttribute?.(`w:${localName}`) || node.getAttribute?.(localName) || ""
+    node.getAttribute?.(`w:${localName2}`) || node.getAttribute?.(localName2) || ""
   );
 }
 function normalizeAuthor(author) {
@@ -6436,11 +7305,11 @@ function normalizeAuthor(author) {
 function isElement(node) {
   return !!node && node.nodeType === 1;
 }
-function isWordElement5(node, localName) {
-  return isElement(node) && node.namespaceURI === NS_W && String(node.localName || "").toLowerCase() === localName.toLowerCase();
+function isWordElement5(node, localName2) {
+  return isElement(node) && node.namespaceURI === NS_W && String(node.localName || "").toLowerCase() === localName2.toLowerCase();
 }
-function getWordElementsByLocalName(xmlDoc, localName) {
-  return Array.from(xmlDoc.getElementsByTagNameNS(NS_W, localName));
+function getWordElementsByLocalName(xmlDoc, localName2) {
+  return Array.from(xmlDoc.getElementsByTagNameNS(NS_W, localName2));
 }
 function resolveAuthorFilter(options = {}) {
   if (options?.allAuthors === true) {
@@ -6463,19 +7332,37 @@ function authorMatchesNode(node, filter) {
   return !!nodeAuthor && nodeAuthor === filter.normalizedAuthor;
 }
 function parseXmlWithWarnings(oxml, parseFailurePrefix) {
-  const parsed = parseOoxmlSafe(oxml, "application/xml");
+  let rawOxml = typeof oxml === "string" ? oxml.replace(/^\uFEFF/, "").trim() : "";
+  let isFragmentWrapped = false;
+  let parsed = parseOoxmlSafe(rawOxml, "application/xml");
+  if (parsed.error && (parsed.error.message.includes("HierarchyRequestError") || parsed.error.message.includes("Only one element"))) {
+    const wrapped = `<w:body xmlns:w="${NS_W}">${rawOxml}</w:body>`;
+    const wrappedParsed = parseOoxmlSafe(wrapped, "application/xml");
+    if (!wrappedParsed.error) {
+      parsed = wrappedParsed;
+      isFragmentWrapped = true;
+    }
+  }
   const parseError = parsed.doc ? getXmlParseError(parsed.doc) : null;
   if (parsed.error || parseError) {
     const message = parsed.error?.message || parseError?.textContent || "parse error";
     return {
       xmlDoc: null,
       serializer: null,
+      isFragmentWrapped: false,
       warning: `${parseFailurePrefix}: ${message}`,
       warnings: parsed.warnings,
       error: { code: "PARSE_ERROR", message }
     };
   }
-  return { xmlDoc: parsed.doc, serializer: createSerializer(), warning: null, warnings: parsed.warnings, error: null };
+  return {
+    xmlDoc: parsed.doc,
+    serializer: createSerializer(),
+    isFragmentWrapped,
+    warning: null,
+    warnings: parsed.warnings,
+    error: null
+  };
 }
 function removeNode(node) {
   if (node?.parentNode) {
@@ -6518,10 +7405,16 @@ function mergeParagraphIntoNextAndRemove(paragraph) {
   if (!paragraph?.parentNode) return false;
   const nextParagraph = getNextWordParagraph(paragraph);
   if (!nextParagraph) {
+    if (isWordElement5(paragraph.parentNode, "tc") && getWordElementsByLocalName(paragraph.parentNode, "p").length <= 1) {
+      return false;
+    }
     return removeNode(paragraph);
   }
   const childrenToMove = Array.from(paragraph.childNodes || []).filter((child) => !isWordElement5(child, "pPr"));
-  const insertionPoint = nextParagraph.firstChild || null;
+  let insertionPoint = nextParagraph.firstChild || null;
+  if (isWordElement5(insertionPoint, "pPr")) {
+    insertionPoint = insertionPoint.nextSibling || null;
+  }
   for (const child of childrenToMove) {
     nextParagraph.insertBefore(child, insertionPoint);
   }
@@ -6583,14 +7476,15 @@ function acceptTrackedChangesInOoxml(oxml, options = {}) {
   }
   acceptedCount += removeMoveRangeMarkers(xmlDoc, filter);
   const changeTags = ["rPrChange", "pPrChange", "tblPrChange", "trPrChange", "tcPrChange"];
-  for (const localName of changeTags) {
-    for (const changeNode of getWordElementsByLocalName(xmlDoc, localName)) {
+  for (const localName2 of changeTags) {
+    for (const changeNode of getWordElementsByLocalName(xmlDoc, localName2)) {
       if (!changeNode.parentNode || !authorMatchesNode(changeNode, filter)) continue;
       if (removeNode(changeNode)) acceptedCount += 1;
     }
   }
+  const serializedOxml = parseResult.isFragmentWrapped ? Array.from(xmlDoc.documentElement.childNodes).map((n) => serializer.serializeToString(n)).join("") : serializer.serializeToString(xmlDoc);
   return {
-    oxml: serializer.serializeToString(xmlDoc),
+    oxml: serializedOxml,
     hasChanges: acceptedCount > 0,
     acceptedCount,
     warnings
@@ -6609,10 +7503,10 @@ function convertDeletionTextNodes(xmlDoc, delNode) {
     delTextNode.parentNode?.replaceChild(normalText, delTextNode);
   }
 }
-function rejectPropertyChangeNode(changeNode, localName) {
+function rejectPropertyChangeNode(changeNode, localName2) {
   const parent = changeNode?.parentNode;
   if (!parent) return false;
-  const baseLocalName = localName.endsWith("Change") ? localName.slice(0, -"Change".length) : "";
+  const baseLocalName = localName2.endsWith("Change") ? localName2.slice(0, -"Change".length) : "";
   if (!baseLocalName || String(parent.localName || "").toLowerCase() !== baseLocalName.toLowerCase() || parent.namespaceURI !== NS_W) {
     return removeNode(changeNode);
   }
@@ -6638,9 +7532,9 @@ function xmlDocImportNode(xmlDoc, node) {
   }
   return node.cloneNode(true);
 }
-function collectMoveRangeStartIds(xmlDoc, localName, filter) {
+function collectMoveRangeStartIds(xmlDoc, localName2, filter) {
   const ids = /* @__PURE__ */ new Set();
-  for (const node of getWordElementsByLocalName(xmlDoc, localName)) {
+  for (const node of getWordElementsByLocalName(xmlDoc, localName2)) {
     if (!authorMatchesNode(node, filter)) continue;
     const id = getAttributeByLocalName(node, "id");
     if (id) ids.add(id);
@@ -6657,8 +7551,8 @@ function removeMoveRangeMarkers(xmlDoc, filter) {
     ["moveToRangeStart", moveToIds, true],
     ["moveToRangeEnd", moveToIds, false]
   ];
-  for (const [localName, ids, isStart] of markerSpecs) {
-    for (const node of getWordElementsByLocalName(xmlDoc, localName)) {
+  for (const [localName2, ids, isStart] of markerSpecs) {
+    for (const node of getWordElementsByLocalName(xmlDoc, localName2)) {
       if (!node.parentNode) continue;
       const id = getAttributeByLocalName(node, "id");
       if (!id) continue;
@@ -6727,14 +7621,15 @@ function rejectTrackedChangesInOoxml(oxml, options = {}) {
   }
   rejectedCount += removeMoveRangeMarkers(xmlDoc, filter);
   const changeTags = ["rPrChange", "pPrChange", "tblPrChange", "trPrChange", "tcPrChange"];
-  for (const localName of changeTags) {
-    for (const changeNode of getWordElementsByLocalName(xmlDoc, localName)) {
+  for (const localName2 of changeTags) {
+    for (const changeNode of getWordElementsByLocalName(xmlDoc, localName2)) {
       if (!changeNode.parentNode || !authorMatchesNode(changeNode, filter)) continue;
-      if (rejectPropertyChangeNode(changeNode, localName)) rejectedCount += 1;
+      if (rejectPropertyChangeNode(changeNode, localName2)) rejectedCount += 1;
     }
   }
+  const serializedOxml = parseResult.isFragmentWrapped ? Array.from(xmlDoc.documentElement.childNodes).map((n) => serializer.serializeToString(n)).join("") : serializer.serializeToString(xmlDoc);
   return {
-    oxml: serializer.serializeToString(xmlDoc),
+    oxml: serializedOxml,
     hasChanges: rejectedCount > 0,
     rejectedCount,
     warnings
@@ -6773,12 +7668,12 @@ function runIsOnlyCommentReference(runNode) {
 function removeCommentAnchors(xmlDoc, targetIds) {
   let removed = 0;
   const anchorTags = ["commentRangeStart", "commentRangeEnd", "commentReference"];
-  for (const localName of anchorTags) {
-    for (const node of getWordElementsByLocalName(xmlDoc, localName)) {
+  for (const localName2 of anchorTags) {
+    for (const node of getWordElementsByLocalName(xmlDoc, localName2)) {
       if (!node.parentNode) continue;
       const id = getAttributeByLocalName(node, "id");
       if (!id || !targetIds.has(id)) continue;
-      if (localName === "commentReference" && runIsOnlyCommentReference(node.parentNode)) {
+      if (localName2 === "commentReference" && runIsOnlyCommentReference(node.parentNode)) {
         if (removeNode(node.parentNode)) {
           removed += 1;
         }
@@ -6819,8 +7714,8 @@ function deleteCommentsByAuthorInOoxml(oxml, options = {}) {
   warnings.push(...parseResult.warnings || []);
   const { targetIds, commentNodes } = collectCommentTargetIds(xmlDoc, filter);
   if (filter.allAuthors) {
-    for (const localName of ["commentRangeStart", "commentRangeEnd", "commentReference"]) {
-      for (const node of getWordElementsByLocalName(xmlDoc, localName)) {
+    for (const localName2 of ["commentRangeStart", "commentRangeEnd", "commentReference"]) {
+      for (const node of getWordElementsByLocalName(xmlDoc, localName2)) {
         const id = getAttributeByLocalName(node, "id");
         if (id) targetIds.add(id);
       }
@@ -6837,7 +7732,36 @@ function deleteCommentsByAuthorInOoxml(oxml, options = {}) {
   };
 }
 
+// engine/route-selection.js
+var RECONCILIATION_CAPABILITY_MATRIX = Object.freeze({
+  formatOnly: Object.freeze({ paragraphs: true, formatting: true, tables: "scoped", hyperlinks: "preserved", fields: "preserved", comments: "preserved" }),
+  surgical: Object.freeze({ paragraphs: true, tables: "cell-scoped", hyperlinks: "preserved", fields: "preserved", comments: "preserved", notes: "preserved" }),
+  reconstruction: Object.freeze({ paragraphs: true, hyperlinks: "sentinel-preserved", fields: "sentinel-preserved", comments: "marker-preserved", notes: "reference-preserved" }),
+  table: Object.freeze({ tables: true, paragraphs: true, formatting: "cell-dependent", numbering: false }),
+  listDirect: Object.freeze({ lists: true, numbering: true, paragraphs: "single-source expansion", tables: "embedded-markdown blocks", formatting: "markdown hints" }),
+  listCompatibilityPipeline: Object.freeze({ lists: true, numbering: true, paragraphs: "multi-source patching", compatibility: true })
+});
+function recordRouteSelection(options, route, context = {}) {
+  const callback = options?._routeInstrumentation?.onRoute;
+  if (typeof callback !== "function") return;
+  callback(Object.freeze({
+    route,
+    capabilities: RECONCILIATION_CAPABILITY_MATRIX[route] || null,
+    ...context
+  }));
+}
+
 // engine/oxml-engine.js
+function getCommentIdsInOoxml(node) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const localName2 of ["commentRangeStart", "commentRangeEnd", "commentReference"]) {
+    for (const marker of getElementsByTagNSOrTag(node, NS_W, localName2)) {
+      const id = marker.getAttribute?.("w:id") || marker.getAttribute?.("id");
+      if (id !== "") ids.add(id);
+    }
+  }
+  return [...ids].sort((a, b) => Number(a) - Number(b) || a.localeCompare(b));
+}
 async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}) {
   const inputOoxml = oxml;
   let workingOoxml = oxml;
@@ -6849,11 +7773,19 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
   let parseWarnings = [];
   const operationWarnings = [];
   let normalizedExistingRevisions = false;
-  const keepNormalizedNoOp = options.existingRevisions === "accept-all-first-keep-normalized";
+  const existingRevisionsPolicy = options.existingRevisions || "merge-same-author";
+  const keepNormalizedNoOp = existingRevisionsPolicy === "accept-all-first-keep-normalized";
   const finalize = (result) => {
     const withStatus = { ...result };
     if (normalizedExistingRevisions && withStatus.hasChanges === false && withStatus.status !== "error") {
-      if (keepNormalizedNoOp) {
+      if (existingRevisionsPolicy === "merge-same-author") {
+        withStatus.oxml = workingOoxml;
+        withStatus.hasChanges = true;
+        withStatus.warnings = [
+          ...Array.isArray(withStatus.warnings) ? withStatus.warnings : [],
+          "Previous revisions by the same author were reverted to baseline."
+        ];
+      } else if (keepNormalizedNoOp) {
         withStatus.oxml = workingOoxml;
         withStatus.hasChanges = true;
         withStatus.warnings = [
@@ -6900,8 +7832,74 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
   const revisionIdAllocator = options?._revisionIdAllocator instanceof RevisionIdAllocator ? options._revisionIdAllocator : new RevisionIdAllocator();
   seedRevisionIdsFromDocument(xmlDoc, revisionIdAllocator);
   if (containsTrackedChanges(xmlDoc)) {
-    const existingRevisionsPolicy = options.existingRevisions || "reject-input";
-    if (existingRevisionsPolicy === "accept-all-first" || existingRevisionsPolicy === "accept-all-first-keep-normalized") {
+    if (existingRevisionsPolicy === "merge-same-author") {
+      const authors = getTrackedChangeAuthors(xmlDoc);
+      const currentAuthor = String(author || "").trim().toLowerCase();
+      const isSameAuthor = authors.length > 0 && authors.every((a) => a.trim().toLowerCase() === currentAuthor);
+      if (isSameAuthor) {
+        const commentIds = getCommentIdsInOoxml(xmlDoc);
+        if (commentIds.length > 0) {
+          return finalize({
+            oxml: inputOoxml,
+            hasChanges: false,
+            status: "error",
+            error: {
+              code: "COMMENTED_CONTENT_MERGE",
+              message: "Refusing to merge existing revisions in commented content because reverting the prior revisions could remove or orphan comment anchors.",
+              commentIds
+            }
+          });
+        }
+        log("[OxmlEngine] Existing revisions from same author detected; rejecting previous changes to merge against baseline");
+        const rejected = rejectTrackedChangesInOoxml(inputOoxml, { author });
+        if (rejected.status === "error") return finalize(rejected);
+        workingOoxml = rejected.oxml;
+        normalizedExistingRevisions = true;
+        const rejectedParsed = parseOoxmlSafe(workingOoxml, "text/xml");
+        parseWarnings.push(...rejectedParsed.warnings);
+        xmlDoc = rejectedParsed.doc;
+        const rejectedParseError = xmlDoc ? getXmlParseError(xmlDoc) : null;
+        if (rejectedParsed.error || rejectedParseError) {
+          const message = rejectedParsed.error?.message || rejectedParseError?.textContent || "Could not parse OOXML after rejecting same-author revisions.";
+          error("[OxmlEngine] XML parse error after rejecting same-author revisions:", message);
+          return finalize({
+            oxml: inputOoxml,
+            hasChanges: false,
+            status: "error",
+            error: {
+              code: "PARSE_ERROR",
+              message
+            }
+          });
+        }
+        if (containsTrackedChanges(xmlDoc)) {
+          return finalize({
+            oxml: inputOoxml,
+            hasChanges: false,
+            status: "error",
+            error: {
+              code: "UNSAFE_REVISION_NESTING",
+              message: "Existing same-author revisions could not be completely restored to baseline; refusing to layer new revisions over unsupported revision markup."
+            }
+          });
+        }
+        seedRevisionIdsFromDocument(xmlDoc, revisionIdAllocator);
+        const paragraphsInDoc = xmlDoc.documentElement && String(xmlDoc.documentElement.localName || "").toLowerCase() === "p" ? [xmlDoc.documentElement] : getDocumentParagraphs(xmlDoc);
+        const baselineText = paragraphsInDoc.length > 0 ? paragraphsInDoc.map((p) => extractCanonicalParagraphText(p)).join("\n") : "";
+        originalText = baselineText;
+      } else {
+        log("[OxmlEngine] Existing revisions detected from another/unattributed author; refusing per merge-same-author policy");
+        return finalize({
+          oxml: inputOoxml,
+          hasChanges: false,
+          status: "error",
+          error: {
+            code: "EXISTING_REVISIONS",
+            message: `Input OOXML contains tracked changes from another author (${authors.length ? authors.join(", ") : "unattributed"}). Pass existingRevisions: "accept-all-first" or resolve revisions first.`
+          }
+        });
+      }
+    } else if (existingRevisionsPolicy === "accept-all-first" || existingRevisionsPolicy === "accept-all-first-keep-normalized") {
       log("[OxmlEngine] Existing revisions detected; accepting all input revisions before redlining");
       const accepted = acceptTrackedChangesInOoxml(inputOoxml, { allAuthors: true });
       if (accepted.status === "error") return finalize(accepted);
@@ -6933,7 +7931,7 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
         status: "error",
         error: {
           code: "EXISTING_REVISIONS",
-          message: 'Input OOXML contains existing tracked changes. Pass existingRevisions: "accept-all-first" to normalize before redlining.'
+          message: 'Input OOXML contains existing tracked changes and existingRevisions is "reject-input".'
         }
       });
     }
@@ -6951,10 +7949,29 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
     }
     return isolatedResult;
   }
-  const sanitizedText = options.sanitizeInput === true ? sanitizeAiResponse(modifiedText) : modifiedText;
+  let sanitizedText = options.sanitizeInput === true ? sanitizeAiResponse(modifiedText) : modifiedText;
   if (sanitizedText !== modifiedText) {
     operationWarnings.push("Input was sanitized; pass sanitizeInput: false to disable.");
   }
+  let structuredAnalysis = null;
+  if (options.structuredContent !== false) {
+    structuredAnalysis = analyzeStructuredContent(sanitizedText);
+    if (!structuredAnalysis.valid) {
+      if (options.explicitStructuredContent === true) {
+        const message = structuredAnalysis.issues.map((issue) => `${issue.code}: ${issue.message}`).join(" ");
+        return finalize({
+          oxml: inputOoxml,
+          hasChanges: false,
+          status: "error",
+          error: { code: "STRUCTURED_CONTENT_INVALID", message },
+          warnings: structuredAnalysis.issues.map((issue) => issue.message)
+        });
+      }
+      structuredAnalysis = null;
+    } else if (structuredAnalysis.requiresStructuredContent) {
+      sanitizedText = structuredAnalysis.normalizedMarkdown;
+    }
+  }
   const { cleanText: cleanModifiedText, formatHints } = preprocessMarkdown(sanitizedText);
   const hasTextChanges = cleanModifiedText.trim() !== originalText.trim();
   const hasFormatHints = formatHints.length > 0;
@@ -7011,6 +8028,7 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
   log(`[OxmlEngine] Text changes: ${hasTextChanges}, New format hints: ${formatHints.length}, Existing format hints: ${existingFormatHints.length}`);
   const needsFormatRemoval = options.removeFormatting === true && !hasTextChanges && !hasFormatHints && hasExistingFormatting;
   if (!hasTextChanges && !hasFormatHints && !hasExistingFormatting) {
+    recordRouteSelection(options, "noChange");
     log("[OxmlEngine] No text changes, no format hints, and no existing formatting detected");
     return finalizeUnchanged();
   }
@@ -7019,6 +8037,7 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
     return finalizeUnchanged();
   }
   if (needsFormatRemoval) {
+    recordRouteSelection(options, "formatOnly", { removeFormatting: true });
     log("[OxmlEngine] Format REMOVAL detected: applying surgical replacement in OOXML");
     const tableCellCtx = initialTableCellContext;
     let targetParagraph = tableCellCtx.targetParagraph || null;
@@ -7052,6 +8071,7 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
     return finalize(removalResult);
   }
   if (!hasTextChanges && hasFormatHints) {
+    recordRouteSelection(options, "formatOnly", { removeFormatting: false });
     log(`[OxmlEngine] Format-only change detected: ${formatHints.length} format hints`);
     const tableCellCtx = initialTableCellContext;
     const precomputedFormatContext = {
@@ -7074,17 +8094,21 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
   const hasTables = tables.length > 0;
   const isMarkdownTable = /^\|.+\|/.test(cleanModifiedText.trim()) && cleanModifiedText.includes("\n");
   const isTargetList = isListTargetLoose(cleanModifiedText);
+  const isStructuredContent = options.structuredContent !== false && structuredAnalysis?.requiresStructuredContent === true;
   const tableCellContext = initialTableCellContext;
   log(`[OxmlEngine] Mode: ${hasTables ? "SURGICAL" : "RECONSTRUCTION"}, formatHints: ${formatHints.length}, isMarkdownTable: ${isMarkdownTable}, isTargetList: ${isTargetList}, isTableCellParagraph: ${tableCellContext.isTableCellParagraph}`);
   try {
     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));
     }
     if (hasTables && isMarkdownTable) {
+      recordRouteSelection(options, "table", { transformation: "table-reconciliation" });
       return finalize(applyTableReconciliation(xmlDoc, cleanModifiedText, serializer, null, author, generateRedlines));
     }
     if (hasTables) {
+      recordRouteSelection(options, "surgical", { tableScoped: true });
       const surgicalTarget = tableCellContext.hasTableWrapper && tableCellContext.targetParagraph ? tableCellContext.targetParagraph : null;
       if (surgicalTarget) {
         log("[OxmlEngine] Table cell edit: scoping surgical mode to target paragraph");
@@ -7097,7 +8121,9 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
         author,
         formatHints,
         generateRedlines,
-        surgicalTarget
+        surgicalTarget,
+        {},
+        options
       );
       if (tableCellContext.hasTableWrapper && result.hasChanges && tableCellContext.targetParagraph) {
         log("[OxmlEngine] Stripping table wrapper for table cell paragraph (surgical mode)");
@@ -7105,14 +8131,36 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
       }
       return finalize(result);
     }
-    if (isTargetList) {
-      log("[OxmlEngine] \u{1F3AF} Using reconciliation pipeline for list generation");
-      const pipeline = new ReconciliationPipeline({
-        author,
-        generateRedlines,
-        revisionIdAllocator
+    if (isTargetList || isStructuredContent) {
+      const sourceParagraphs = getElementsByTagNSOrTag(xmlDoc, NS_W, "p");
+      const useDirectListGeneration = sourceParagraphs.length === 1;
+      recordRouteSelection(options, useDirectListGeneration ? "listDirect" : "listCompatibilityPipeline", {
+        sourceParagraphCount: sourceParagraphs.length
       });
-      const result = await pipeline.execute(workingOoxml, sanitizedText, { xmlDoc });
+      log(`[OxmlEngine] \u{1F3AF} Using ${useDirectListGeneration ? "direct list generation" : "compatibility pipeline"} for list reconciliation`);
+      let result;
+      if (useDirectListGeneration) {
+        const ingested = ingestOoxml(workingOoxml, { xmlDoc });
+        const numberingContext = detectNumberingContext(sourceParagraphs[0]);
+        result = await executeListGeneration({
+          cleanText: cleanModifiedText,
+          numberingContext,
+          originalRunModel: ingested.runModel,
+          originalText: ingested.acceptedText,
+          generateRedlines,
+          author,
+          font: options.font || null,
+          revisionIdAllocator,
+          numberingService: new NumberingService()
+        });
+      } else {
+        const pipeline = new ReconciliationPipeline({
+          author,
+          generateRedlines,
+          revisionIdAllocator
+        });
+        result = await pipeline.execute(workingOoxml, sanitizedText, { xmlDoc });
+      }
       if (result.error?.code === "DIFF_TOKEN_LIMIT") {
         return finalize({ oxml: inputOoxml, hasChanges: false, status: "error", error: result.error });
       }
@@ -7124,10 +8172,15 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
           numberingXml: result.numberingXml
         });
         log(`[OxmlEngine] \u2705 Wrapped OOXML length: ${wrapped.length}`);
-        return finalize({ oxml: wrapped, hasChanges: true });
+        return finalize({
+          oxml: wrapped,
+          hasChanges: true,
+          ...Array.isArray(result.warnings) ? { warnings: result.warnings } : {}
+        });
       }
       return finalizeUnchanged();
     }
+    recordRouteSelection(options, "reconstruction");
     return finalize(applyReconstructionMode(
       xmlDoc,
       originalText,
@@ -7135,7 +8188,9 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
       serializer,
       author,
       formatHints,
-      generateRedlines
+      generateRedlines,
+      {},
+      options
     ));
   } catch (caught) {
     if (isDiffTokenLimitError(caught)) {
@@ -7154,10 +8209,10 @@ function normalizeTargetText(text) {
 }
 function textSpanVisibleText(span) {
   const node = span?.textElement;
-  const localName = String(node?.localName || node?.nodeName || "").replace(/^.*:/, "");
-  if (localName === "tab") return "	";
-  if (localName === "br" || localName === "cr") return "\n";
-  if (localName === "noBreakHyphen") return "\u2011";
+  const localName2 = String(node?.localName || node?.nodeName || "").replace(/^.*:/, "");
+  if (localName2 === "tab") return "	";
+  if (localName2 === "br" || localName2 === "cr") return "\n";
+  if (localName2 === "noBreakHyphen") return "\u2011";
   return node?.textContent || "";
 }
 function sanitizeAiResponse(text) {
@@ -7182,39 +8237,27 @@ function createTargetNotFoundError(message) {
   error2.code = "TARGET_NOT_FOUND";
   return error2;
 }
+function createTargetError(code, message, candidates = null) {
+  const error2 = new Error(message);
+  error2.code = code;
+  if (Array.isArray(candidates)) error2.candidates = candidates;
+  return error2;
+}
 var WORD_MAIN_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
-function getElementsByLocalName(node, localName) {
+function getElementsByLocalName(node, localName2) {
   if (!node) return [];
   if (typeof node.getElementsByTagNameNS === "function") {
-    const namespaced = toArray(node.getElementsByTagNameNS("*", localName));
+    const namespaced = toArray(node.getElementsByTagNameNS("*", localName2));
     if (namespaced.length > 0) return namespaced;
   }
   if (typeof node.getElementsByTagName !== "function") return [];
-  const prefixed = toArray(node.getElementsByTagName(`w:${localName}`));
+  const prefixed = toArray(node.getElementsByTagName(`w:${localName2}`));
   if (prefixed.length > 0) return prefixed;
-  return toArray(node.getElementsByTagName(localName));
-}
-function toParagraphText(paragraph) {
-  let text = "";
-  const visit = (node) => {
-    for (const child of toArray(node?.childNodes)) {
-      if (child?.nodeType !== 1) continue;
-      const localName = String(child.localName || child.nodeName || "").replace(/^.*:/, "");
-      if (localName === "t") {
-        text += child.textContent || "";
-      } else if (localName === "tab") {
-        text += "	";
-      } else {
-        visit(child);
-      }
-    }
-  };
-  visit(paragraph);
-  return text;
+  return toArray(node.getElementsByTagName(localName2));
 }
 function getParagraphText(paragraph) {
   if (!paragraph) return "";
-  return toParagraphText(paragraph);
+  return extractCanonicalParagraphText(paragraph);
 }
 function getDocumentParagraphNodes(xmlDoc) {
   if (!xmlDoc) return [];
@@ -7222,6 +8265,75 @@ function getDocumentParagraphNodes(xmlDoc) {
   const searchRoot = bodies.length > 0 ? bodies[0] : xmlDoc;
   return getElementsByLocalName(searchRoot, "p");
 }
+function getParagraphId2(paragraph) {
+  if (!paragraph) return null;
+  const attribute = toArray(paragraph.attributes).find(
+    (candidate) => String(candidate?.localName || candidate?.name || "").replace(/^.*:/, "") === "paraId"
+  );
+  return attribute?.value || null;
+}
+function createParagraphFingerprint(paragraph, metadata = {}) {
+  if (!paragraph) return null;
+  const revisionView = metadata.revisionView === "rejected" ? "rejected" : "accepted";
+  const text = typeof metadata.text === "string" ? metadata.text : extractCanonicalParagraphText(paragraph, { revisionView });
+  const documentIndex = Number.isInteger(metadata.index) ? metadata.index : getDocumentParagraphNodes(paragraph.ownerDocument || paragraph).indexOf(paragraph) + 1;
+  const paragraphId = metadata.paragraphId === void 0 ? getParagraphId2(paragraph) : metadata.paragraphId;
+  const inTable = typeof metadata.inTable === "boolean" ? metadata.inTable : isParagraphInTable(paragraph);
+  const viewPart = revisionView === "rejected" ? "rejected" : "";
+  const identity = `${paragraphId || ""}${documentIndex}${inTable ? "table" : "body"}${viewPart}${text}`;
+  let hash = 2166136261;
+  for (let i = 0; i < identity.length; i++) {
+    hash ^= identity.charCodeAt(i);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return `fnv1a32:${hash.toString(16).padStart(8, "0")}`;
+}
+function buildParagraphMetadataIndex(xmlDoc, options = {}) {
+  const revisionView = options.revisionView === "rejected" ? "rejected" : "accepted";
+  const paragraphs = getDocumentParagraphNodes(xmlDoc);
+  const entries = [];
+  const byParagraph = /* @__PURE__ */ new Map();
+  const byId = /* @__PURE__ */ new Map();
+  const grouped = /* @__PURE__ */ new Map();
+  for (let offset = 0; offset < paragraphs.length; offset++) {
+    const paragraph = paragraphs[offset];
+    const text = extractCanonicalParagraphText(paragraph, { revisionView });
+    const paragraphId = getParagraphId2(paragraph);
+    const inTable = isParagraphInTable(paragraph);
+    const normalizedText = normalizeWhitespaceForTargeting(text);
+    const entry = Object.freeze({
+      paragraph,
+      index: offset + 1,
+      paragraphId,
+      text,
+      normalizedText,
+      revisionView,
+      fingerprint: createParagraphFingerprint(paragraph, {
+        text,
+        index: offset + 1,
+        paragraphId,
+        inTable,
+        revisionView
+      }),
+      inTable
+    });
+    entries.push(entry);
+    byParagraph.set(paragraph, entry);
+    if (paragraphId && !byId.has(paragraphId)) byId.set(paragraphId, entry);
+    if (normalizedText) {
+      if (!grouped.has(normalizedText)) grouped.set(normalizedText, []);
+      grouped.get(normalizedText).push(entry);
+    }
+  }
+  for (const [key, values] of grouped) grouped.set(key, Object.freeze(values));
+  return Object.freeze({
+    revisionView,
+    entries: Object.freeze(entries),
+    byParagraph,
+    byId,
+    byNormalizedText: grouped
+  });
+}
 function normalizeWhitespaceForTargeting(text) {
   return String(text || "").replace(/\s+/g, " ").trim();
 }
@@ -7253,40 +8365,49 @@ function splitLeadingParagraphMarker(text) {
     targetRef: Number.parseInt(marker[1], 10)
   };
 }
-function findParagraphByReference(xmlDoc, targetRef) {
+function findParagraphByReference(xmlDoc, targetRef, paragraphMetadataIndex = null) {
   if (!Number.isInteger(targetRef) || targetRef < 1) return null;
-  const paragraphs = getDocumentParagraphNodes(xmlDoc);
-  return paragraphs[targetRef - 1] || null;
+  if (paragraphMetadataIndex?.entries) {
+    return paragraphMetadataIndex.entries[targetRef - 1]?.paragraph || null;
+  }
+  return getDocumentParagraphNodes(xmlDoc)[targetRef - 1] || null;
 }
-function findContainingWordElement(node, localName, namespaceUri = WORD_MAIN_NS) {
+function findContainingWordElement(node, localName2, namespaceUri = WORD_MAIN_NS) {
   let current = node;
   while (current) {
-    if (current.nodeType === 1 && current.namespaceURI === namespaceUri && current.localName === localName) {
+    if (current.nodeType === 1 && current.namespaceURI === namespaceUri && current.localName === localName2) {
       return current;
     }
     current = current.parentNode;
   }
   return null;
 }
-function findParagraphByStrictText(xmlDoc, targetText) {
-  const paragraphs = getDocumentParagraphNodes(xmlDoc);
+function findParagraphByStrictText(xmlDoc, targetText, options = {}) {
+  const metadataIndex = options.paragraphMetadataIndex || null;
+  const entries = metadataIndex?.entries || null;
+  const paragraphs = entries ? null : getDocumentParagraphNodes(xmlDoc);
   const normalizedTarget = String(targetText || "").trim();
   if (!normalizedTarget) return null;
-  const exact = paragraphs.find((p) => getParagraphText(p).trim() === normalizedTarget);
+  const exact = entries ? entries.find((entry) => entry.text.trim() === normalizedTarget)?.paragraph : paragraphs.find((p) => getParagraphText(p).trim() === normalizedTarget);
   if (exact) return exact;
   const normTarget = normalizeWhitespaceForTargeting(normalizedTarget);
+  if (metadataIndex?.byNormalizedText) {
+    return metadataIndex.byNormalizedText.get(normTarget)?.[0]?.paragraph || null;
+  }
   return paragraphs.find((p) => normalizeWhitespaceForTargeting(getParagraphText(p)) === normTarget) || null;
 }
 function findParagraphByBestTextMatch(xmlDoc, targetText, options = {}) {
   const onInfo = typeof options.onInfo === "function" ? options.onInfo : () => {
   };
-  const paragraphs = getDocumentParagraphNodes(xmlDoc);
+  const metadataIndex = options.paragraphMetadataIndex || null;
+  const entries = metadataIndex?.entries || null;
+  const paragraphs = entries ? null : getDocumentParagraphNodes(xmlDoc);
   const normalizedTarget = String(targetText || "").trim();
   if (!normalizedTarget) return null;
-  const strictMatch = findParagraphByStrictText(xmlDoc, normalizedTarget);
+  const strictMatch = findParagraphByStrictText(xmlDoc, normalizedTarget, { paragraphMetadataIndex: metadataIndex });
   if (strictMatch) return strictMatch;
   const normTarget = normalizeWhitespaceForTargeting(normalizedTarget);
-  const startsWithMatch = paragraphs.find((p) => {
+  const startsWithMatch = entries ? entries.find((entry) => entry.normalizedText.length > 10 && normTarget.startsWith(entry.normalizedText))?.paragraph || null : paragraphs.find((p) => {
     const paragraphText = normalizeWhitespaceForTargeting(getParagraphText(p));
     return paragraphText.length > 10 && normTarget.startsWith(paragraphText);
   });
@@ -7294,7 +8415,7 @@ function findParagraphByBestTextMatch(xmlDoc, targetText, options = {}) {
     onInfo(`[Fuzzy] Prefix match (target starts with paragraph): "${getParagraphText(startsWithMatch).trim().slice(0, 60)}..."`);
     return startsWithMatch;
   }
-  const containsMatch = paragraphs.find((p) => {
+  const containsMatch = entries ? entries.find((entry) => entry.normalizedText.length > 15 && normTarget.includes(entry.normalizedText))?.paragraph || null : paragraphs.find((p) => {
     const paragraphText = normalizeWhitespaceForTargeting(getParagraphText(p));
     return paragraphText.length > 15 && normTarget.includes(paragraphText);
   });
@@ -7305,8 +8426,10 @@ function findParagraphByBestTextMatch(xmlDoc, targetText, options = {}) {
   let bestScore = 0;
   let bestParagraph = null;
   const targetWords = new Set(normTarget.toLowerCase().split(/\s+/).filter((word) => word.length > 2));
-  for (const paragraph of paragraphs) {
-    const paragraphText = getParagraphText(paragraph).trim();
+  const candidateCount = entries?.length ?? paragraphs.length;
+  for (let index = 0; index < candidateCount; index++) {
+    const paragraph = entries?.[index]?.paragraph ?? paragraphs[index];
+    const paragraphText = (entries?.[index]?.text ?? getParagraphText(paragraph)).trim();
     if (!paragraphText) continue;
     const paragraphWords = normalizeWhitespaceForTargeting(paragraphText).toLowerCase().split(/\s+/).filter((word) => word.length > 2);
     const overlap = paragraphWords.filter((word) => targetWords.has(word)).length;
@@ -7328,14 +8451,154 @@ function resolveTargetParagraph(xmlDoc, options = {}) {
   const onWarn = typeof options.onWarn === "function" ? options.onWarn : () => {
   };
   const opType = options.opType || "operation";
-  const cleanTargetText = String(options.targetText || "").trim();
-  const parsedRef = parseParagraphReference(options.targetRef);
+  const descriptor = options.targetDescriptor && typeof options.targetDescriptor === "object" ? options.targetDescriptor : null;
+  const revisionView = descriptor?.revisionView === "rejected" ? "rejected" : "accepted";
+  const cleanTargetText = String(descriptor?.exactText ?? descriptor?.text ?? options.targetText ?? "").trim();
+  const parsedRef = parseParagraphReference(descriptor?.index ?? descriptor?.paragraphIndex ?? options.targetRef);
+  const strictAmbiguity = options.strictAmbiguity === true;
+  let paragraphMetadataIndex = options.paragraphMetadataIndex || null;
+  if (paragraphMetadataIndex && paragraphMetadataIndex.revisionView !== revisionView) {
+    paragraphMetadataIndex = options.metadataIndices?.[revisionView] || buildParagraphMetadataIndex(xmlDoc, { revisionView });
+  } else if (!paragraphMetadataIndex) {
+    paragraphMetadataIndex = buildParagraphMetadataIndex(xmlDoc, { revisionView });
+  }
+  if (descriptor?.paragraphId) {
+    const byId = findParagraphById(xmlDoc, descriptor.paragraphId, paragraphMetadataIndex);
+    if (!byId) {
+      throw createTargetError(
+        "TARGET_NOT_FOUND",
+        `Target paragraphId not found: "${descriptor.paragraphId}".`
+      );
+    }
+    const cachedEntry = paragraphMetadataIndex?.byParagraph?.get(byId) || null;
+    const actualIndex = cachedEntry?.index ?? getDocumentParagraphNodes(xmlDoc).indexOf(byId) + 1;
+    const actualFingerprint = cachedEntry?.fingerprint || createParagraphFingerprint(byId, { revisionView });
+    const actualInTable = cachedEntry?.inTable ?? isParagraphInTable(byId);
+    const actualText = cachedEntry?.normalizedText || normalizeWhitespaceForTargeting(extractCanonicalParagraphText(byId, { revisionView }));
+    if (parsedRef != null && parsedRef !== actualIndex) {
+      throw createTargetError(
+        "TARGET_INDEX_MISMATCH",
+        `Target paragraphId "${descriptor.paragraphId}" (index ${actualIndex}) does not match requested index ${parsedRef}.`,
+        cachedEntry ? [serializeTargetCandidate(cachedEntry)] : null
+      );
+    }
+    if (descriptor.fingerprint && descriptor.fingerprint !== actualFingerprint) {
+      throw createTargetError(
+        "TARGET_FINGERPRINT_MISMATCH",
+        `Target paragraphId "${descriptor.paragraphId}" no longer matches its source fingerprint.`,
+        cachedEntry ? [serializeTargetCandidate(cachedEntry)] : null
+      );
+    }
+    if (typeof descriptor.inTable === "boolean" && descriptor.inTable !== actualInTable) {
+      throw createTargetError(
+        "TARGET_CONTEXT_MISMATCH",
+        `Target paragraphId "${descriptor.paragraphId}" does not match the requested table context.`,
+        cachedEntry ? [serializeTargetCandidate(cachedEntry)] : null
+      );
+    }
+    if (cleanTargetText && actualText !== normalizeWhitespaceForTargeting(cleanTargetText)) {
+      throw createTargetError(
+        "TARGET_TEXT_MISMATCH",
+        `Target paragraphId "${descriptor.paragraphId}" no longer matches the supplied text.`,
+        cachedEntry ? [serializeTargetCandidate(cachedEntry)] : null
+      );
+    }
+    if (descriptor.occurrence != null) {
+      const textToFind = cleanTargetText || actualText;
+      const textCandidates = findStrictTargetCandidates(xmlDoc, textToFind, paragraphMetadataIndex);
+      const actualOccurrence = textCandidates.findIndex((c) => c.paragraph === byId) + 1;
+      if (actualOccurrence === 0 || actualOccurrence !== descriptor.occurrence) {
+        throw createTargetError(
+          "TARGET_OCCURRENCE_MISMATCH",
+          `Target paragraphId "${descriptor.paragraphId}" matches occurrence ${actualOccurrence}, not requested occurrence ${descriptor.occurrence}.`,
+          textCandidates.map(serializeTargetCandidate)
+        );
+      }
+    }
+    return { paragraph: byId, resolvedBy: "paragraph_id" };
+  }
+  let candidates = [];
+  if (cleanTargetText) {
+    const unfilteredCandidates = findStrictTargetCandidates(xmlDoc, cleanTargetText, paragraphMetadataIndex);
+    candidates = filterTargetCandidates(unfilteredCandidates, descriptor);
+    if (descriptor?.fingerprint && unfilteredCandidates.length > 0 && candidates.length === 0) {
+      throw createTargetError(
+        "TARGET_FINGERPRINT_MISMATCH",
+        "Target text matched, but no paragraph matched the supplied source fingerprint.",
+        unfilteredCandidates.map(serializeTargetCandidate)
+      );
+    }
+    if (typeof descriptor?.inTable === "boolean" && unfilteredCandidates.length > 0 && candidates.length === 0) {
+      throw createTargetError(
+        "TARGET_CONTEXT_MISMATCH",
+        "Target text matched, but no paragraph matched the requested table context.",
+        unfilteredCandidates.map(serializeTargetCandidate)
+      );
+    }
+    if (descriptor?.occurrence) {
+      const occurrenceMatch = candidates[descriptor.occurrence - 1] || null;
+      if (!occurrenceMatch) {
+        throw createTargetError(
+          "TARGET_NOT_FOUND",
+          `Target occurrence ${descriptor.occurrence} was not found.`,
+          candidates.map(serializeTargetCandidate)
+        );
+      }
+      return { paragraph: occurrenceMatch.paragraph, resolvedBy: "occurrence" };
+    }
+    if (strictAmbiguity) {
+      if (parsedRef) {
+        const byReference = candidates.find((candidate) => candidate.index === parsedRef) || null;
+        if (byReference) return { paragraph: byReference.paragraph, resolvedBy: "ref" };
+        if (descriptor?.fingerprint && candidates.length > 0) {
+          throw createTargetError(
+            "TARGET_FINGERPRINT_MISMATCH",
+            `Target fingerprint does not match paragraph reference [P${parsedRef}].`,
+            candidates.map(serializeTargetCandidate)
+          );
+        }
+        if (candidates.length === 1) {
+          return { paragraph: candidates[0].paragraph, resolvedBy: "strict_text_after_ref_drift" };
+        }
+      }
+      if (candidates.length > 1) {
+        throw createTargetError(
+          "AMBIGUOUS_TARGET",
+          `Target text matched ${candidates.length} paragraphs; provide paragraphId, index, occurrence, or fingerprint.`,
+          candidates.map(serializeTargetCandidate)
+        );
+      }
+      if (candidates.length === 0) {
+        throw createTargetNotFoundError(`Target paragraph not found: "${cleanTargetText}"`);
+      }
+    }
+    if (!parsedRef && candidates.length === 1) {
+      const candidate = candidates[0];
+      return {
+        paragraph: candidate.paragraph,
+        resolvedBy: descriptor?.fingerprint ? "fingerprint" : "strict_text"
+      };
+    }
+  }
   if (parsedRef) {
-    const byRef = findParagraphByReference(xmlDoc, parsedRef);
+    const byRef = findParagraphByReference(xmlDoc, parsedRef, paragraphMetadataIndex);
     if (byRef) {
+      const cached = paragraphMetadataIndex?.byParagraph?.get(byRef) || null;
+      if (descriptor?.fingerprint && descriptor.fingerprint !== cached?.fingerprint) {
+        throw createTargetError(
+          "TARGET_FINGERPRINT_MISMATCH",
+          `Target fingerprint does not match paragraph reference [P${parsedRef}].`
+        );
+      }
+      if (typeof descriptor?.inTable === "boolean" && descriptor.inTable !== cached?.inTable) {
+        throw createTargetError(
+          "TARGET_CONTEXT_MISMATCH",
+          `Target paragraph reference [P${parsedRef}] does not match requested table context.`
+        );
+      }
       if (cleanTargetText) {
-        const strictMatch = findParagraphByStrictText(xmlDoc, cleanTargetText);
-        const byRefText = getParagraphText(byRef).trim();
+        const strictMatch = findParagraphByStrictText(xmlDoc, cleanTargetText, { paragraphMetadataIndex });
+        const byRefText = (cached?.text || extractCanonicalParagraphText(byRef, { revisionView })).trim();
         const byRefNorm = normalizeWhitespaceForTargeting(byRefText);
         const targetNorm = normalizeWhitespaceForTargeting(cleanTargetText);
         const hasDrift = byRefNorm !== targetNorm;
@@ -7344,7 +8607,7 @@ function resolveTargetParagraph(xmlDoc, options = {}) {
           return { paragraph: strictMatch, resolvedBy: "strict_text_after_ref_drift" };
         }
         if (hasDrift) {
-          const fuzzyMatch = findParagraphByBestTextMatch(xmlDoc, cleanTargetText, { onInfo });
+          const fuzzyMatch = findParagraphByBestTextMatch(xmlDoc, cleanTargetText, { onInfo, paragraphMetadataIndex });
           if (fuzzyMatch && fuzzyMatch !== byRef) {
             onInfo(`[Target] [P${parsedRef}] drifted for ${opType}; using fuzzy text rematch.`);
             return { paragraph: fuzzyMatch, resolvedBy: "fuzzy_text_after_ref_drift" };
@@ -7360,10 +8623,22 @@ function resolveTargetParagraph(xmlDoc, options = {}) {
     }
     onWarn(`[WARN] Target reference [P${parsedRef}] not found; falling back to text matching for ${opType}.`);
   }
-  if (cleanTargetText) {
-    const strictMatch = findParagraphByStrictText(xmlDoc, cleanTargetText);
-    if (strictMatch) return { paragraph: strictMatch, resolvedBy: "strict_text" };
-    const fuzzyMatch = findParagraphByBestTextMatch(xmlDoc, cleanTargetText, { onInfo });
+  if (cleanTargetText && !strictAmbiguity) {
+    const strictMatch = findParagraphByStrictText(xmlDoc, cleanTargetText, { paragraphMetadataIndex });
+    if (strictMatch) {
+      const candidateCount = candidates.length;
+      if (candidateCount > 1) {
+        const warningMsg = `AMBIGUOUS_TARGET_HEURISTIC_USED: Target text matched ${candidateCount} paragraphs; permissive resolution chose candidate 1. Migrate to strict targeting (e.g. strictTargets: true with paragraphId, index, occurrence, or fingerprint) before v1.0.0.`;
+        onWarn(warningMsg);
+        return {
+          paragraph: strictMatch,
+          resolvedBy: "strict_text",
+          warnings: [warningMsg]
+        };
+      }
+      return { paragraph: strictMatch, resolvedBy: "strict_text" };
+    }
+    const fuzzyMatch = findParagraphByBestTextMatch(xmlDoc, cleanTargetText, { onInfo, paragraphMetadataIndex });
     if (fuzzyMatch) return { paragraph: fuzzyMatch, resolvedBy: "fuzzy_text" };
   }
   if (cleanTargetText) throw createTargetNotFoundError(`Target paragraph not found: "${cleanTargetText}"`);
@@ -7373,24 +8648,65 @@ function resolveTargetParagraph(xmlDoc, options = {}) {
 function isParagraphInTable(paragraph) {
   return !!findContainingWordElement(paragraph, "tbl");
 }
-function findStrictTargetCandidates(xmlDoc, targetText) {
+function findStrictTargetCandidates(xmlDoc, targetText, optionsOrIndex = null) {
   const normalizedTarget = normalizeWhitespaceForTargeting(targetText);
   if (!normalizedTarget) return [];
+  const metadataIndex = optionsOrIndex?.byNormalizedText ? optionsOrIndex : optionsOrIndex?.paragraphMetadataIndex || null;
+  const revisionView = optionsOrIndex?.revisionView || metadataIndex?.revisionView || "accepted";
+  if (metadataIndex?.byNormalizedText && metadataIndex.revisionView === revisionView) {
+    return Array.from(metadataIndex.byNormalizedText.get(normalizedTarget) || []);
+  }
   const paragraphs = getDocumentParagraphNodes(xmlDoc);
   const candidates = [];
   for (let i = 0; i < paragraphs.length; i++) {
     const paragraph = paragraphs[i];
-    const paragraphText = getParagraphText(paragraph).trim();
+    const paragraphText = extractCanonicalParagraphText(paragraph, { revisionView }).trim();
     if (!paragraphText) continue;
     if (normalizeWhitespaceForTargeting(paragraphText) !== normalizedTarget) continue;
     candidates.push({
       paragraph,
       index: i + 1,
-      inTable: isParagraphInTable(paragraph)
+      inTable: isParagraphInTable(paragraph),
+      paragraphId: getParagraphId2(paragraph),
+      fingerprint: createParagraphFingerprint(paragraph, {
+        text: paragraphText,
+        index: i + 1,
+        revisionView
+      }),
+      text: paragraphText,
+      revisionView
     });
   }
   return candidates;
 }
+function serializeTargetCandidate(candidate) {
+  return {
+    index: candidate.index,
+    paragraphId: candidate.paragraphId || null,
+    text: candidate.text,
+    inTable: candidate.inTable,
+    fingerprint: candidate.fingerprint,
+    revisionView: candidate.revisionView || "accepted"
+  };
+}
+function filterTargetCandidates(candidates, descriptor) {
+  let scoped = candidates.slice();
+  if (descriptor?.paragraphId) {
+    scoped = scoped.filter((candidate) => candidate.paragraphId === descriptor.paragraphId);
+  }
+  if (typeof descriptor?.inTable === "boolean") {
+    scoped = scoped.filter((candidate) => candidate.inTable === descriptor.inTable);
+  }
+  if (descriptor?.fingerprint) {
+    scoped = scoped.filter((candidate) => candidate.fingerprint === descriptor.fingerprint);
+  }
+  return scoped;
+}
+function findParagraphById(xmlDoc, paragraphId, paragraphMetadataIndex = null) {
+  if (!paragraphId) return null;
+  if (paragraphMetadataIndex?.byId) return paragraphMetadataIndex.byId.get(paragraphId)?.paragraph || null;
+  return getDocumentParagraphNodes(xmlDoc).find((paragraph) => getParagraphId2(paragraph) === paragraphId) || null;
+}
 function selectBestTargetCandidate(candidates, parsedRef, expectedInTable = null) {
   if (!Array.isArray(candidates) || candidates.length === 0) return null;
   let scoped = candidates.slice();
@@ -7403,16 +8719,18 @@ function selectBestTargetCandidate(candidates, parsedRef, expectedInTable = null
   }
   return scoped[0] || null;
 }
-function buildTargetReferenceSnapshot(xmlDoc) {
-  const paragraphs = getDocumentParagraphNodes(xmlDoc);
+function buildTargetReferenceSnapshot(xmlDoc, paragraphMetadataIndex = null) {
+  const entries = paragraphMetadataIndex?.entries || null;
+  const paragraphs = entries ? null : getDocumentParagraphNodes(xmlDoc);
   const snapshot = /* @__PURE__ */ new Map();
-  for (let i = 0; i < paragraphs.length; i++) {
-    const paragraph = paragraphs[i];
-    const text = getParagraphText(paragraph).trim();
+  const paragraphCount = entries?.length ?? paragraphs.length;
+  for (let i = 0; i < paragraphCount; i++) {
+    const paragraph = entries?.[i]?.paragraph ?? paragraphs[i];
+    const text = (entries?.[i]?.text ?? getParagraphText(paragraph)).trim();
     snapshot.set(i + 1, {
       text,
-      normalizedText: normalizeWhitespaceForTargeting(text),
-      inTable: isParagraphInTable(paragraph)
+      normalizedText: entries?.[i]?.normalizedText ?? normalizeWhitespaceForTargeting(text),
+      inTable: entries?.[i]?.inTable ?? isParagraphInTable(paragraph)
     });
   }
   return snapshot;
@@ -7429,7 +8747,7 @@ function resolveTargetParagraphWithSnapshot(xmlDoc, options = {}) {
   const expectedText = cleanTargetText || snapshotEntry.text || "";
   const expectedNorm = normalizeWhitespaceForTargeting(expectedText);
   if (!expectedNorm) return resolved;
-  const resolvedNorm = normalizeWhitespaceForTargeting(getParagraphText(resolved.paragraph));
+  const resolvedNorm = options.paragraphMetadataIndex?.byParagraph?.get(resolved.paragraph)?.normalizedText || normalizeWhitespaceForTargeting(getParagraphText(resolved.paragraph));
   if (resolvedNorm === expectedNorm) return resolved;
   const candidateTexts = [];
   if (cleanTargetText) candidateTexts.push(cleanTargetText);
@@ -7441,7 +8759,7 @@ function resolveTargetParagraphWithSnapshot(xmlDoc, options = {}) {
   }
   let bestCandidate = null;
   for (const candidateText of candidateTexts) {
-    const candidates = findStrictTargetCandidates(xmlDoc, candidateText);
+    const candidates = findStrictTargetCandidates(xmlDoc, candidateText, options.paragraphMetadataIndex || null);
     const selected = selectBestTargetCandidate(candidates, parsedRef, snapshotEntry.inTable);
     if (!selected) continue;
     if (!bestCandidate) bestCandidate = selected;
@@ -7496,11 +8814,11 @@ function resolveParagraphRangeByRefs(xmlDoc, startRef, endRef, options = {}) {
 }
 
 // core/list-targeting.js
-function getFirstDescendantByLocalName(node, localName) {
+function getFirstDescendantByLocalName(node, localName2) {
   if (!node || typeof node.getElementsByTagNameNS !== "function") return null;
-  const namespaced = node.getElementsByTagNameNS(WORD_MAIN_NS, localName);
+  const namespaced = node.getElementsByTagNameNS(WORD_MAIN_NS, localName2);
   if (namespaced.length > 0) return namespaced[0];
-  const anyNs = node.getElementsByTagNameNS("*", localName);
+  const anyNs = node.getElementsByTagNameNS("*", localName2);
   return anyNs.length > 0 ? anyNs[0] : null;
 }
 function readValAttribute(element) {
@@ -7511,18 +8829,13 @@ function readValAttribute(element) {
   }
   return element.getAttribute("w:val") || element.getAttribute("val") || null;
 }
-function parseOutlineLevelFromMarker(marker) {
-  const normalized = String(marker || "").trim();
-  if (!/^\d+(?:\.\d+)+\.?$/.test(normalized)) return null;
-  const parts = normalized.replace(/\.$/, "").split(".");
-  return Math.max(0, parts.length - 1);
-}
-var REDUNDANT_LIST_PREFIX_REGEX = /^(?:(?:\d+(?:\.\d+)*\.?|\((?:\d+|[a-zA-Z]|[ivxlcIVXLC]+)\)|[a-zA-Z]\.|[ivxlcIVXLC]+\.|[-*+\u2022]))\s+/;
 function stripRedundantLeadingListMarkers(text) {
   let value = String(text || "").trim();
   let passes = 0;
-  while (passes < 4 && REDUNDANT_LIST_PREFIX_REGEX.test(value)) {
-    value = value.replace(REDUNDANT_LIST_PREFIX_REGEX, "").trimStart();
+  while (passes < 4) {
+    const stripped = stripListMarker(value);
+    if (stripped === value) break;
+    value = stripped.trimStart();
     passes++;
   }
   return value.trim();
@@ -7534,19 +8847,16 @@ function parseModifiedListItems(modifiedText) {
   for (const rawLine of rawLines) {
     const line = rawLine.trimEnd();
     if (!line.trim()) continue;
-    const markerMatch = line.match(/^(\s*)((?:\d+(?:\.\d+)*\.?|\((?:\d+|[a-zA-Z]|[ivxlcIVXLC]+)\)|[a-zA-Z]\.|[ivxlcIVXLC]+\.|[-*+\u2022]))\s+(.*)$/);
-    if (markerMatch) {
+    const parsed = parseListItem(line, { indentSpaces: 2 });
+    if (parsed) {
       hasListMarkers = true;
-      const marker = markerMatch[2];
-      const markerType = /^[-*+\u2022]$/.test(marker) ? "bullet" : "numbered";
-      const level = Math.floor((markerMatch[1] || "").length / 2);
       items.push({
         kind: "list",
-        markerType,
-        level,
-        marker,
-        outlineLevel: markerType === "numbered" ? parseOutlineLevelFromMarker(marker) : null,
-        text: stripRedundantLeadingListMarkers(markerMatch[3])
+        markerType: parsed.markerType,
+        level: parsed.level,
+        marker: parsed.marker,
+        outlineLevel: parsed.outlineLevel,
+        text: stripRedundantLeadingListMarkers(parsed.text)
       });
       continue;
     }
@@ -7573,7 +8883,7 @@ function resolveInsertionLevel(item, anchorLevel, baselineLevel) {
 }
 function shouldPromoteBulletInsertionsToChildDepth(parsedItems, normalizedTargetText, anchorLevel) {
   if (!Array.isArray(parsedItems) || parsedItems.length < 2) return false;
-  if (!Number.isInteger(anchorLevel) || anchorLevel < 1) return false;
+  if (!Number.isInteger(anchorLevel) || anchorLevel < 0) return false;
   const firstItem = parsedItems[0];
   const trailingListItems = parsedItems.slice(1).filter((item) => item.kind === "list");
   if (trailingListItems.length === 0) return false;
@@ -7633,7 +8943,7 @@ function getParagraphListInfo(paragraph) {
   const numIdEl = getFirstDescendantByLocalName(numPr, "numId");
   if (!numIdEl) return null;
   const numId = readValAttribute(numIdEl);
-  if (!numId) return null;
+  if (!numId || numId === "0") return null;
   const ilvlEl = getFirstDescendantByLocalName(numPr, "ilvl");
   const ilvlRaw = readValAttribute(ilvlEl);
   const ilvl = Number.parseInt(ilvlRaw || "0", 10);
@@ -7780,18 +9090,13 @@ function parseMarkdownListContent(content) {
   const items = [];
   for (const line of lines) {
     if (!line.trim()) continue;
-    const markerMatch = matchListMarker(line, { allowZeroSpaceAfterMarker: false });
-    if (markerMatch) {
-      const indent = markerMatch[1] || "";
-      const marker = markerMatch[2].trim();
-      const text = stripListMarker(line, { allowZeroSpaceAfterMarker: false }).trim();
-      const level = Math.floor(indent.length / 2);
-      const isBullet = /^[-*+\u2022]$/.test(marker);
+    const parsed = parseListItem(line, { allowZeroSpaceAfterMarker: false, indentSpaces: 2 });
+    if (parsed) {
       items.push({
-        type: isBullet ? "bullet" : "numbered",
-        level,
-        text,
-        marker
+        type: parsed.markerType,
+        level: parsed.level,
+        text: parsed.text.trim(),
+        marker: parsed.marker
       });
       continue;
     }
@@ -7815,16 +9120,6 @@ function hasListItems(parsedListData) {
 }
 
 // orchestration/list-markdown.js
-function inferNumberingStyleFromMarker(marker) {
-  const m = (marker || "").trim();
-  if (!m) return "decimal";
-  if (/^\d+(?:\.\d+)*\.?$/.test(m) || /^\(\d+\)$/.test(m)) return "decimal";
-  if (/^[ivxlcdm]+\.$/.test(m)) return "lowerRoman";
-  if (/^[IVXLCDM]{2,}\.$/.test(m)) return "upperRoman";
-  if (/^[a-z]\.$/.test(m)) return "lowerAlpha";
-  if (/^[A-Z]\.$/.test(m)) return "upperAlpha";
-  return "decimal";
-}
 function buildListMarkdown(itemsWithLevels, listType, numberingStyle) {
   const levelCounters = /* @__PURE__ */ new Map();
   const lines = [];
@@ -7845,7 +9140,6 @@ function buildListMarkdown(itemsWithLevels, listType, numberingStyle) {
 }
 function normalizeListItemsWithLevels(rawItems, options = {}) {
   const indentSpaces = Math.max(1, Number(options.indentSpaces) || 4);
-  const markersRegex = /^((?:\d+(?:\.\d+)*\.?|\((?:\d+|[a-zA-Z]|[ivxlcIVXLC]+)\)|[a-zA-Z]\.|\d+\.|[ivxlcIVXLC]+\.|[-*•])\s*)/;
   return (rawItems || []).map((rawItem) => {
     const item = String(rawItem ?? "");
     const indentMatch = item.match(/^(\s*)/);
@@ -7853,10 +9147,10 @@ function normalizeListItemsWithLevels(rawItems, options = {}) {
     const level = Math.floor(indentSize / indentSpaces);
     let stripped = item.trim();
     let removedMarker = null;
-    const markerMatch = stripped.match(markersRegex);
+    const markerMatch = matchListMarker(stripped, { allowZeroSpaceAfterMarker: true });
     if (markerMatch) {
-      removedMarker = markerMatch[1].trim() || null;
-      stripped = stripped.replace(markersRegex, "");
+      removedMarker = markerMatch[2].trim() || null;
+      stripped = stripListMarker(stripped, { allowZeroSpaceAfterMarker: true });
     }
     return {
       text: stripped.trim(),
@@ -8009,10 +9303,10 @@ function clearSingleLineListFallbackExplicitSequence(sequenceState, numberingKey
   if (!numberingKey) return;
   sequenceState.explicitByNumberingKey.delete(String(numberingKey));
 }
-function getDirectWordChild2(element, localName) {
+function getDirectWordChild2(element, localName2) {
   if (!element) return null;
   return Array.from(element.childNodes || []).find(
-    (node) => node && node.nodeType === 1 && node.namespaceURI === "http://schemas.openxmlformats.org/wordprocessingml/2006/main" && node.localName === localName
+    (node) => node && node.nodeType === 1 && node.namespaceURI === "http://schemas.openxmlformats.org/wordprocessingml/2006/main" && node.localName === localName2
   ) || null;
 }
 function enforceListBindingOnParagraphNodes(nodes, options = {}) {
@@ -8198,13 +9492,21 @@ async function executeSingleLineListStructuralFallback(plan, options = {}) {
   }
   const author = options.author || "AI";
   const generateRedlines = options.generateRedlines ?? true;
-  const pipeline = options.pipeline || new ReconciliationPipeline({ author, generateRedlines });
-  const result = await pipeline.executeListGeneration(
+  const result = options.pipeline ? await options.pipeline.executeListGeneration(
     plan.listInput,
     null,
     null,
     String(plan.originalText || "")
-  );
+  ) : await executeListGeneration({
+    cleanText: plan.listInput,
+    numberingContext: null,
+    originalRunModel: [],
+    originalText: String(plan.originalText || ""),
+    generateRedlines,
+    author,
+    revisionIdAllocator: options.revisionIdAllocator || null,
+    numberingService: new NumberingService()
+  });
   const rawOxml = result?.oxml || result?.ooxml || "";
   const oxml = trimTrailingBlankParagraph(rawOxml);
   const generatedNumId = extractFirstParagraphNumIdFromOxml(oxml);
@@ -8379,10 +9681,10 @@ function validateRedlineOoxml(oxml) {
 }
 
 // core/table-targeting.js
-function getDirectWordChildren(element, localName) {
+function getDirectWordChildren(element, localName2) {
   if (!element) return [];
   return Array.from(element.childNodes || []).filter(
-    (node) => node && node.nodeType === 1 && node.namespaceURI === WORD_MAIN_NS && node.localName === localName
+    (node) => node && node.nodeType === 1 && node.namespaceURI === WORD_MAIN_NS && node.localName === localName2
   );
 }
 function escapeMarkdownCell(text) {
@@ -8627,8 +9929,8 @@ function hasXmlParseError(doc) {
   if (doc.documentElement.localName === "parsererror") return true;
   return doc.getElementsByTagName("parsererror").length > 0;
 }
-function isDirectWordChild(node, localName) {
-  return !!(node && node.nodeType === 1 && node.namespaceURI === WORD_MAIN_NS && node.localName === localName);
+function isDirectWordChild(node, localName2) {
+  return !!(node && node.nodeType === 1 && node.namespaceURI === WORD_MAIN_NS && node.localName === localName2);
 }
 function insertNumberingNodeInSchemaOrder(root, node, kind) {
   if (!root || !node) return;
@@ -8820,17 +10122,17 @@ function getWordParagraphs(doc) {
   if (namespaced.length > 0) return namespaced;
   return Array.from(doc.getElementsByTagNameNS("*", "p")).filter((node) => node?.localName === "p");
 }
-function getDirectWordChild3(node, localName) {
+function getDirectWordChild3(node, localName2) {
   const children = Array.from(node?.childNodes || []);
   for (const child of children) {
     if (child?.nodeType !== 1) continue;
     if (child.namespaceURI !== NS_W) continue;
-    if (child.localName === localName) return child;
+    if (child.localName === localName2) return child;
   }
   return null;
 }
-function getWordDescendants(node, localName) {
-  return Array.from(node?.getElementsByTagNameNS?.(NS_W, localName) || []);
+function getWordDescendants(node, localName2) {
+  return Array.from(node?.getElementsByTagNameNS?.(NS_W, localName2) || []);
 }
 function getWordAttribute(element, names) {
   if (!element) return "";
@@ -8840,32 +10142,6 @@ function getWordAttribute(element, names) {
   }
   return "";
 }
-function hasWordAncestorWithin(node, localName, boundary) {
-  let cursor = node?.parentNode || null;
-  while (cursor && cursor !== boundary) {
-    if (cursor.nodeType === 1 && cursor.namespaceURI === NS_W && cursor.localName === localName) {
-      return true;
-    }
-    cursor = cursor.parentNode;
-  }
-  return false;
-}
-function readRunText(run) {
-  let text = "";
-  for (const child of Array.from(run?.childNodes || [])) {
-    if (!child || child.nodeType !== 1 || child.namespaceURI !== NS_W) continue;
-    if (child.localName === "t") {
-      text += child.textContent || "";
-    } else if (child.localName === "tab") {
-      text += "	";
-    } else if (child.localName === "br" || child.localName === "cr") {
-      text += "\n";
-    } else if (child.localName === "noBreakHyphen") {
-      text += "\u2011";
-    }
-  }
-  return text;
-}
 function getRunFormatting(run) {
   const rPr = getDirectWordChild3(run, "rPr");
   if (!rPr) return { bold: false, italic: false };
@@ -8882,9 +10158,8 @@ function collectParagraphSegments(paragraph) {
   const segments = [];
   const runs = Array.from(paragraph?.getElementsByTagNameNS?.(NS_W, "r") || []);
   for (const run of runs) {
-    if (hasWordAncestorWithin(run, "del", paragraph)) continue;
-    if (hasWordAncestorWithin(run, "moveFrom", paragraph)) continue;
-    const text = readRunText(run);
+    if (!isNodeVisibleInRevisionView(run, paragraph, "accepted")) continue;
+    const text = readCanonicalRunText(run, { boundary: paragraph, revisionView: "accepted" });
     if (!text) continue;
     segments.push({
       text,
@@ -8955,9 +10230,9 @@ function paragraphToMarkdown(paragraph) {
   const inline = segments.map((segment) => wrapRunMarkdown(segment.text, segment)).join("");
   const normalizedInline = normalizeInlineWhitespace(inline);
   if (!normalizedInline) return "";
-  const headingLevel = parseHeadingLevel(paragraph);
-  if (headingLevel != null) {
-    return `${"#".repeat(headingLevel)} ${normalizedInline}`;
+  const headingLevel2 = parseHeadingLevel(paragraph);
+  if (headingLevel2 != null) {
+    return `${"#".repeat(headingLevel2)} ${normalizedInline}`;
   }
   const list = parseListInfo(paragraph);
   if (list) {
@@ -9000,13 +10275,512 @@ function ingestWordOoxmlToMarkdownResult(ooxml) {
   return { text: lines.join("\n\n").trim(), status: "ok", warnings: parsed.warnings };
 }
 
+// services/revision-token.js
+var textEncoder = new TextEncoder();
+function normalizeOpcEntryName(name) {
+  if (typeof name !== "string") {
+    throw new TypeError(`Entry name must be a string, got ${typeof name}`);
+  }
+  let normalized = name.replace(/\\/g, "/");
+  normalized = normalized.replace(/^\/+/, "");
+  while (normalized.startsWith("./")) {
+    normalized = normalized.slice(2);
+  }
+  normalized = normalized.replace(/\/+/g, "/");
+  if (!normalized) {
+    throw new Error(`Invalid empty entry name: "${name}"`);
+  }
+  return normalized;
+}
+function buildRevisionTokenFraming({ scope, entries = [] }) {
+  if (typeof scope !== "string" || !scope) {
+    throw new TypeError("Revision token scope must be a non-empty string.");
+  }
+  const magicBytes = textEncoder.encode("docx-redline-revision-token\0");
+  const version = 1;
+  const scopeBytes = textEncoder.encode(scope);
+  const normalizedEntries = [];
+  const seenNames = /* @__PURE__ */ new Set();
+  const rawList = Array.isArray(entries) ? entries : entries instanceof Map ? Array.from(entries.entries()) : Object.entries(entries || {});
+  for (const item of rawList) {
+    if (!item) continue;
+    const rawName = Array.isArray(item) ? item[0] : item.name;
+    const rawPayload = Array.isArray(item) ? item[1] : item.payload ?? item.bytes;
+    if (rawName == null) continue;
+    const normName = normalizeOpcEntryName(String(rawName));
+    if (seenNames.has(normName)) {
+      throw new Error(`Duplicate normalized entry path detected: "${normName}"`);
+    }
+    seenNames.add(normName);
+    let payloadBytes;
+    if (typeof rawPayload === "string") {
+      payloadBytes = textEncoder.encode(rawPayload);
+    } else if (rawPayload instanceof Uint8Array) {
+      payloadBytes = rawPayload;
+    } else if (rawPayload && typeof rawPayload.length === "number") {
+      payloadBytes = new Uint8Array(rawPayload);
+    } else {
+      payloadBytes = new Uint8Array(0);
+    }
+    normalizedEntries.push({
+      name: normName,
+      nameBytes: textEncoder.encode(normName),
+      payloadBytes
+    });
+  }
+  normalizedEntries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+  let totalSize = magicBytes.length + 4 + 4 + scopeBytes.length + 4;
+  for (const e of normalizedEntries) {
+    totalSize += 4 + e.nameBytes.length + 4 + e.payloadBytes.length;
+  }
+  const buffer = new Uint8Array(totalSize);
+  const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  let offset = 0;
+  buffer.set(magicBytes, offset);
+  offset += magicBytes.length;
+  view.setUint32(offset, version, false);
+  offset += 4;
+  view.setUint32(offset, scopeBytes.length, false);
+  offset += 4;
+  buffer.set(scopeBytes, offset);
+  offset += scopeBytes.length;
+  view.setUint32(offset, normalizedEntries.length, false);
+  offset += 4;
+  for (const e of normalizedEntries) {
+    view.setUint32(offset, e.nameBytes.length, false);
+    offset += 4;
+    buffer.set(e.nameBytes, offset);
+    offset += e.nameBytes.length;
+    view.setUint32(offset, e.payloadBytes.length, false);
+    offset += 4;
+    buffer.set(e.payloadBytes, offset);
+    offset += e.payloadBytes.length;
+  }
+  return {
+    framing: buffer,
+    scope,
+    version,
+    coveredParts: normalizedEntries.map((e) => e.name)
+  };
+}
+async function computeRevisionToken({ scope, entries = [], digestFn = null }) {
+  const { framing, coveredParts, version } = buildRevisionTokenFraming({ scope, entries });
+  let hashHex = "";
+  if (typeof digestFn === "function") {
+    hashHex = await digestFn(framing);
+  } else if (typeof globalThis.crypto?.subtle?.digest === "function") {
+    const hashBuf = await globalThis.crypto.subtle.digest("SHA-256", framing);
+    const hashBytes = new Uint8Array(hashBuf);
+    hashHex = Array.from(hashBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  } else {
+    throw new Error("No crypto provider available for SHA-256 revision token computation.");
+  }
+  return {
+    algorithm: "sha256",
+    version,
+    scope,
+    value: hashHex,
+    coveredParts
+  };
+}
+function computeRevisionTokenSync({ scope, entries = [], digestFn }) {
+  if (typeof digestFn !== "function") {
+    throw new TypeError("computeRevisionTokenSync requires a synchronous digestFn.");
+  }
+  const { framing, coveredParts, version } = buildRevisionTokenFraming({ scope, entries });
+  const hashHex = digestFn(framing);
+  return {
+    algorithm: "sha256",
+    version,
+    scope,
+    value: hashHex,
+    coveredParts
+  };
+}
+function extractDocumentPartsEntries(parts) {
+  const entries = [];
+  if (parts?.documentXml) {
+    entries.push({ name: "word/document.xml", payload: parts.documentXml });
+  }
+  if (parts?.commentsXml) {
+    entries.push({ name: "word/comments.xml", payload: parts.commentsXml });
+  }
+  if (parts?.commentsExtendedXml) {
+    entries.push({ name: "word/commentsExtended.xml", payload: parts.commentsExtendedXml });
+  }
+  if (parts?.numberingXml) {
+    entries.push({ name: "word/numbering.xml", payload: parts.numberingXml });
+  }
+  if (parts?.stylesXml) {
+    entries.push({ name: "word/styles.xml", payload: parts.stylesXml });
+  }
+  if (parts?.parts instanceof Map) {
+    for (const [name, payload] of parts.parts.entries()) {
+      entries.push({ name, payload });
+    }
+  } else if (parts?.additionalParts && typeof parts.additionalParts === "object") {
+    for (const [name, payload] of Object.entries(parts.additionalParts)) {
+      entries.push({ name, payload });
+    }
+  }
+  return entries;
+}
+async function computeDocumentPartsRevisionToken(parts, options = {}) {
+  const entries = extractDocumentPartsEntries(parts);
+  return computeRevisionToken({
+    scope: "document-parts",
+    entries,
+    digestFn: options.digestFn
+  });
+}
+function validateRevisionToken(token) {
+  if (!token || typeof token !== "object") {
+    return { valid: false, error: { code: "INVALID_REVISION_TOKEN", message: "Revision token must be an object." } };
+  }
+  if (token.algorithm !== "sha256") {
+    return { valid: false, error: { code: "INVALID_REVISION_TOKEN", message: `Unsupported revision token algorithm: "${token.algorithm}". Expected "sha256".` } };
+  }
+  if (token.version !== 1) {
+    return { valid: false, error: { code: "INVALID_REVISION_TOKEN", message: `Unsupported revision token version: "${token.version}". Expected 1.` } };
+  }
+  if (token.scope !== "document-parts" && token.scope !== "package") {
+    return { valid: false, error: { code: "INVALID_REVISION_TOKEN", message: `Unsupported revision token scope: "${token.scope}". Expected "document-parts" or "package".` } };
+  }
+  if (typeof token.value !== "string" || !/^[0-9a-f]{64}$/i.test(token.value.trim())) {
+    return { valid: false, error: { code: "INVALID_REVISION_TOKEN", message: "Revision token value must be a 64-character hex string." } };
+  }
+  return { valid: true };
+}
+function areRevisionTokensEqual(a, b) {
+  if (typeof a !== "string" || typeof b !== "string") return false;
+  const aNorm = a.trim().toLowerCase();
+  const bNorm = b.trim().toLowerCase();
+  if (aNorm.length !== bNorm.length) return false;
+  const aBuf = textEncoder.encode(aNorm);
+  const bBuf = textEncoder.encode(bNorm);
+  let diff = 0;
+  for (let i = 0; i < aBuf.length; i++) {
+    diff |= aBuf[i] ^ bBuf[i];
+  }
+  return diff === 0;
+}
+
+// services/document-inspection.js
+var attr2 = (node, name) => node?.getAttribute?.(`w:${name}`) || node?.getAttribute?.(name) || "";
+var descendants = (node, name) => Array.from(node?.getElementsByTagNameNS?.(NS_W, name) || []);
+var first = (node, name) => descendants(node, name)[0] || null;
+function hasAncestor(node, localName2) {
+  let cursor = node?.parentNode;
+  while (cursor) {
+    if (cursor.localName === localName2 && (!cursor.namespaceURI || cursor.namespaceURI === NS_W)) return true;
+    cursor = cursor.parentNode;
+  }
+  return false;
+}
+function parseXml2(xml, partName, required = false) {
+  if (!xml) return required ? { error: { code: "MISSING_PART", message: `Missing ${partName}.` } } : { doc: null };
+  const parsed = parseOoxmlSafe(xml, "application/xml");
+  if (!parsed.doc || parsed.error) return { error: { code: "PARSE_ERROR", message: `Could not parse ${partName}: ${parsed.error?.message || "invalid XML"}` } };
+  return { doc: parsed.doc, warnings: parsed.warnings || [] };
+}
+function paragraphListProperties(paragraph) {
+  const numPr = first(first(paragraph, "pPr"), "numPr");
+  if (!numPr) return null;
+  const numId = attr2(first(numPr, "numId"), "val");
+  if (!numId || numId === "0") return null;
+  return { numId, level: Number.parseInt(attr2(first(numPr, "ilvl"), "val") || "0", 10) || 0 };
+}
+function parseNumbering(numberingDoc) {
+  const abstracts = /* @__PURE__ */ new Map();
+  for (const abstract of descendants(numberingDoc, "abstractNum")) {
+    const levels = /* @__PURE__ */ new Map();
+    for (const level of descendants(abstract, "lvl")) {
+      const ilvl = Number.parseInt(attr2(level, "ilvl") || "0", 10) || 0;
+      levels.set(ilvl, {
+        start: Number.parseInt(attr2(first(level, "start"), "val") || "1", 10) || 1,
+        format: attr2(first(level, "numFmt"), "val") || "decimal",
+        text: attr2(first(level, "lvlText"), "val") || `%${ilvl + 1}.`
+      });
+    }
+    abstracts.set(attr2(abstract, "abstractNumId"), levels);
+  }
+  const nums = /* @__PURE__ */ new Map();
+  for (const num of descendants(numberingDoc, "num")) {
+    const abstractId = attr2(first(num, "abstractNumId"), "val");
+    const levels = new Map(abstracts.get(abstractId) || []);
+    for (const override of descendants(num, "lvlOverride")) {
+      const ilvl = Number.parseInt(attr2(override, "ilvl") || "0", 10) || 0;
+      const embedded = first(override, "lvl");
+      const base = { ...levels.get(ilvl) || { start: 1, format: "decimal", text: `%${ilvl + 1}.` } };
+      if (embedded) {
+        base.start = Number.parseInt(attr2(first(embedded, "start"), "val") || String(base.start), 10) || base.start;
+        base.format = attr2(first(embedded, "numFmt"), "val") || base.format;
+        base.text = attr2(first(embedded, "lvlText"), "val") || base.text;
+      }
+      const startOverride = first(override, "startOverride");
+      if (startOverride) base.start = Number.parseInt(attr2(startOverride, "val") || String(base.start), 10) || base.start;
+      levels.set(ilvl, base);
+    }
+    nums.set(attr2(num, "numId"), levels);
+  }
+  return nums;
+}
+function alpha(value, upper) {
+  let n = Math.max(1, value);
+  let out = "";
+  while (n > 0) {
+    n -= 1;
+    out = String.fromCharCode(97 + n % 26) + out;
+    n = Math.floor(n / 26);
+  }
+  return upper ? out.toUpperCase() : out;
+}
+function roman(value) {
+  const pairs = [[1e3, "M"], [900, "CM"], [500, "D"], [400, "CD"], [100, "C"], [90, "XC"], [50, "L"], [40, "XL"], [10, "X"], [9, "IX"], [5, "V"], [4, "IV"], [1, "I"]];
+  let n = value;
+  let out = "";
+  for (const [amount, glyph] of pairs) while (n >= amount) {
+    out += glyph;
+    n -= amount;
+  }
+  return out;
+}
+function formatCounter(value, format) {
+  if (format === "lowerLetter") return alpha(value, false);
+  if (format === "upperLetter") return alpha(value, true);
+  if (format === "lowerRoman") return roman(value).toLowerCase();
+  if (format === "upperRoman") return roman(value);
+  return String(value);
+}
+function createNumberingResolver(numberingDoc) {
+  const nums = numberingDoc ? parseNumbering(numberingDoc) : /* @__PURE__ */ new Map();
+  const counters = /* @__PURE__ */ new Map();
+  return (list) => {
+    if (!list?.numId) return null;
+    const levels = nums.get(String(list.numId));
+    if (!levels) return { ...list, label: null, format: null };
+    const state = counters.get(list.numId) || [];
+    const definition = levels.get(list.level) || { start: 1, format: "decimal", text: `%${list.level + 1}.` };
+    state[list.level] = state[list.level] == null ? definition.start : state[list.level] + 1;
+    state.length = list.level + 1;
+    counters.set(list.numId, state);
+    const label = definition.text.replace(/%([1-9])/g, (_, raw) => {
+      const level = Number(raw) - 1;
+      const levelDef = levels.get(level) || definition;
+      return formatCounter(state[level] ?? levelDef.start, levelDef.format);
+    });
+    return { ...list, label, format: definition.format };
+  };
+}
+function headingLevel(paragraph) {
+  const pPr = first(paragraph, "pPr");
+  const style = attr2(first(pPr, "pStyle"), "val");
+  const match = style.match(/^heading\s*([1-9])$/i);
+  if (match) return Math.min(Number(match[1]), 6);
+  const outline = Number.parseInt(attr2(first(pPr, "outlineLvl"), "val"), 10);
+  return Number.isInteger(outline) ? Math.min(outline + 1, 6) : null;
+}
+function structuralContext(paragraph, text) {
+  const references = [];
+  for (const [name, type] of [["footnoteReference", "footnote"], ["endnoteReference", "endnote"], ["commentReference", "comment"]]) {
+    for (const node of descendants(paragraph, name)) references.push({ type, id: attr2(node, "id") || null });
+  }
+  let cell = paragraph.parentNode;
+  while (cell && cell.localName !== "tc") cell = cell.parentNode;
+  let row = cell?.parentNode;
+  while (row && row.localName !== "tr") row = row.parentNode;
+  let table = row?.parentNode;
+  while (table && table.localName !== "tbl") table = table.parentNode;
+  const all = paragraph.ownerDocument;
+  return {
+    references,
+    table: table ? {
+      tableIndex: Array.from(all.getElementsByTagNameNS(NS_W, "tbl")).indexOf(table) + 1,
+      rowIndex: Array.from(table.getElementsByTagNameNS(NS_W, "tr")).indexOf(row) + 1,
+      cellIndex: Array.from(row.getElementsByTagNameNS(NS_W, "tc")).indexOf(cell) + 1
+    } : null,
+    empty: text.length === 0
+  };
+}
+function revisionAuthors(paragraph) {
+  const authors = /* @__PURE__ */ new Set();
+  for (const name of ["ins", "del", "moveFrom", "moveTo", "rPrChange", "pPrChange"]) {
+    for (const node of descendants(paragraph, name)) if (attr2(node, "author")) authors.add(attr2(node, "author"));
+  }
+  return [...authors].sort();
+}
+function readCommentDefinitions(commentsDoc) {
+  const result = /* @__PURE__ */ new Map();
+  for (const comment of descendants(commentsDoc, "comment")) {
+    const paragraphs = descendants(comment, "p");
+    result.set(attr2(comment, "id"), {
+      id: attr2(comment, "id"),
+      author: attr2(comment, "author") || null,
+      date: attr2(comment, "date") || null,
+      text: paragraphs.map((p) => extractCanonicalParagraphText(p)).join("\n"),
+      paraId: paragraphs[0]?.getAttribute?.("w14:paraId") || paragraphs[0]?.getAttribute?.("paraId") || null
+    });
+  }
+  return result;
+}
+function attachCommentThreadMetadata(comments, commentsExtendedDoc) {
+  if (!commentsExtendedDoc) return;
+  const byParaId = new Map([...comments.values()].filter((c) => c.paraId).map((c) => [c.paraId.toUpperCase(), c]));
+  for (const entry of Array.from(commentsExtendedDoc.getElementsByTagNameNS("*", "commentEx"))) {
+    const paraId = entry.getAttribute("w15:paraId") || entry.getAttribute("paraId") || "";
+    const parentParaId = entry.getAttribute("w15:paraIdParent") || entry.getAttribute("paraIdParent") || "";
+    const comment = byParaId.get(paraId.toUpperCase());
+    if (!comment) continue;
+    comment.done = (entry.getAttribute("w15:done") || entry.getAttribute("done")) === "1";
+    if (parentParaId) {
+      comment.parentParaId = parentParaId;
+      comment.parentCommentId = byParaId.get(parentParaId.toUpperCase())?.id || null;
+    }
+  }
+}
+function collectDocumentCommentAnchors(paragraphNodes, revisionView) {
+  const active = /* @__PURE__ */ new Map();
+  const anchors = /* @__PURE__ */ new Map();
+  let paragraphBoundary = null;
+  const append = (value) => {
+    for (const item of active.values()) item.text += value;
+  };
+  const visit = (node) => {
+    for (const child of Array.from(node?.childNodes || [])) {
+      if (child?.nodeType !== 1) continue;
+      const name = child.localName;
+      if (revisionView === "accepted" && (name === "del" || name === "moveFrom") || revisionView === "rejected" && (name === "ins" || name === "moveTo")) continue;
+      if (name === "commentRangeStart") active.set(attr2(child, "id"), { text: "" });
+      else if (name === "commentRangeEnd") {
+        const id = attr2(child, "id");
+        if (active.has(id)) {
+          anchors.set(id, active.get(id).text);
+          active.delete(id);
+        }
+      } else if (name === "r") append(readCanonicalRunText(child, { revisionView, boundary: paragraphBoundary }));
+      else visit(child);
+    }
+  };
+  paragraphNodes.forEach((paragraph, index) => {
+    paragraphBoundary = paragraph;
+    visit(paragraph);
+    if (index < paragraphNodes.length - 1 && active.size) append("\n");
+  });
+  return anchors;
+}
+function inspectDocumentParts(parts, options = {}) {
+  const documentPart = parseXml2(parts?.documentXml, "word/document.xml", true);
+  if (documentPart.error) return { status: "error", error: documentPart.error, paragraphs: [], comments: [], warnings: [] };
+  const commentsPart = parseXml2(parts?.commentsXml, "word/comments.xml");
+  const commentsExtendedPart = parseXml2(parts?.commentsExtendedXml, "word/commentsExtended.xml");
+  const numberingPart = parseXml2(parts?.numberingXml, "word/numbering.xml");
+  const warnings = [...documentPart.warnings || []];
+  if (commentsPart.error) warnings.push(commentsPart.error.message);
+  if (commentsExtendedPart.error) warnings.push(commentsExtendedPart.error.message);
+  if (numberingPart.error) warnings.push(numberingPart.error.message);
+  const comments = readCommentDefinitions(commentsPart.doc);
+  attachCommentThreadMetadata(comments, commentsExtendedPart.doc);
+  const resolveNumbering = createNumberingResolver(numberingPart.doc);
+  let nearestHeading = null;
+  const paragraphNodes = getDocumentParagraphNodes(documentPart.doc);
+  const commentAnchors = collectDocumentCommentAnchors(paragraphNodes, options.revisionView || "accepted");
+  let paragraphs = paragraphNodes.map((paragraph, zeroIndex) => {
+    const text = extractCanonicalParagraphText(paragraph, { revisionView: options.revisionView || "accepted" });
+    const level = headingLevel(paragraph);
+    if (level) nearestHeading = { level, text };
+    const ids = [...new Set([...descendants(paragraph, "commentRangeStart"), ...descendants(paragraph, "commentReference")].map((node) => attr2(node, "id")).filter(Boolean))];
+    const authors = revisionAuthors(paragraph);
+    const list = resolveNumbering(paragraphListProperties(paragraph));
+    const styleId = attr2(first(first(paragraph, "pPr"), "pStyle"), "val") || null;
+    const structure = structuralContext(paragraph, text);
+    const index = zeroIndex + 1;
+    const provision = list?.label && list.format !== "bullet" ? list.label : null;
+    const headingText = nearestHeading?.text || null;
+    const humanReference = [provision, headingText, text.slice(0, options.excerptLength || 120)].filter(Boolean).join(" \u2014 ");
+    const segments = extractParagraphRevisionSegments(paragraph);
+    return {
+      index,
+      ref: `P${index}`,
+      paragraphId: getParagraphId2(paragraph),
+      fingerprint: createParagraphFingerprint(paragraph),
+      text,
+      exactText: text,
+      excerpt: text.slice(0, options.excerptLength || 120),
+      humanReference,
+      inTable: hasAncestor(paragraph, "tc"),
+      table: structure.table,
+      styleId,
+      headingLevel: level,
+      nearestHeading,
+      list,
+      structuralReferences: structure.references,
+      hasRevisions: authors.length > 0,
+      revisionAuthors: authors,
+      commentIds: ids,
+      segments
+    };
+  });
+  for (const paragraph of paragraphs) for (const id of paragraph.commentIds) {
+    const definition = comments.get(id) || { id, author: null, date: null, text: "" };
+    definition.paragraphIndex ?? (definition.paragraphIndex = paragraph.index);
+    definition.targetRef ?? (definition.targetRef = paragraph.ref);
+    definition.anchoredText ?? (definition.anchoredText = commentAnchors.get(id) || paragraph.text);
+    comments.set(id, definition);
+  }
+  if (options.revisedOnly) paragraphs = paragraphs.filter((item) => item.hasRevisions);
+  if (options.inTable != null) paragraphs = paragraphs.filter((item) => item.inTable === !!options.inTable);
+  if (options.skipEmpty) paragraphs = paragraphs.filter((item) => item.text.length > 0);
+  if (options.search) {
+    const needle = String(options.search).toLowerCase();
+    paragraphs = paragraphs.filter((item) => item.text.toLowerCase().includes(needle));
+  }
+  if (Array.isArray(options.indexes)) {
+    const indexes = new Set(options.indexes);
+    paragraphs = paragraphs.filter((item) => indexes.has(item.index));
+  }
+  if (options.range) {
+    const start = Number(options.range.start ?? options.range[0]);
+    const end = Number(options.range.end ?? options.range[1]);
+    paragraphs = paragraphs.filter((item) => item.index >= start && item.index <= end);
+  }
+  const allRevisionAuthors = [...new Set(paragraphs.flatMap((item) => item.revisionAuthors))].sort();
+  const coveredEntries = extractDocumentPartsEntries(parts);
+  const coveredParts = coveredEntries.map((e) => e.name).sort();
+  let revisionToken = null;
+  if (typeof options.digestFn === "function") {
+    revisionToken = computeRevisionTokenSync({
+      scope: "document-parts",
+      entries: coveredEntries,
+      digestFn: options.digestFn
+    });
+  }
+  return {
+    status: "ok",
+    revisionToken,
+    coveredParts,
+    paragraphs,
+    comments: [...comments.values()],
+    revisionAuthors: allRevisionAuthors,
+    commentAuthors: [...new Set([...comments.values()].map((item) => item.author).filter(Boolean))].sort(),
+    counts: { paragraphs: paragraphs.length, comments: comments.size, revisedParagraphs: paragraphs.filter((item) => item.hasRevisions).length },
+    warnings
+  };
+}
+
 // services/comment-builders.js
-function buildCommentElement(commentId, author, content, date) {
+var NS_W14 = "http://schemas.microsoft.com/office/word/2010/wordml";
+var NS_W15 = "http://schemas.microsoft.com/office/word/2012/wordml";
+function createCommentParaId(commentId) {
+  const numeric = Number.parseInt(String(commentId), 10);
+  const value = Number.isFinite(numeric) ? 1879048192 + (numeric >>> 0) >>> 0 : 1879048192;
+  return value.toString(16).toUpperCase().padStart(8, "0").slice(-8);
+}
+function buildCommentElement(commentId, author, content, date, paraId = createCommentParaId(commentId)) {
   const initials = author.split(" ").map((word) => word[0]).join("").toUpperCase() || "AI";
   const escapedContent = escapeXml(content);
   const escapedAuthor = escapeXml(author);
   return `<w:comment w:id="${commentId}" w:author="${escapedAuthor}" w:date="${date}" w:initials="${initials}">
-      <w:p>
+      <w:p w14:paraId="${escapeXml(paraId)}" xmlns:w14="${NS_W14}">
         <w:r><w:t>${escapedContent}</w:t></w:r>
       </w:p>
     </w:comment>`;
@@ -9016,60 +10790,158 @@ function buildCommentsPartXml(comments) {
     return `<w:comments xmlns:w="${NS_W}"></w:comments>`;
   }
   const commentElements = comments.map(
-    (comment) => buildCommentElement(comment.id, comment.author, comment.content, comment.date)
+    (comment) => buildCommentElement(comment.id, comment.author, comment.content, comment.date, comment.paraId)
   ).join("\n    ");
   return `<w:comments xmlns:w="${NS_W}">
     ${commentElements}
   </w:comments>`;
 }
+function buildCommentsExtendedPartXml(entries) {
+  const body = (entries || []).map((entry) => {
+    const parent = entry.paraIdParent ? ` w15:paraIdParent="${escapeXml(entry.paraIdParent)}"` : "";
+    return `<w15:commentEx w15:paraId="${escapeXml(entry.paraId)}"${parent} w15:done="${entry.done ? "1" : "0"}"/>`;
+  }).join("");
+  return `<w15:commentsEx xmlns:w15="${NS_W15}">${body}</w15:commentsEx>`;
+}
+
+// core/revision-cloning.js
+function refreshRunPropertyChangeIds(root, allocator = null) {
+  if (!root) return root;
+  const xmlDoc = root.nodeType === 9 ? root : root.ownerDocument;
+  const resolvedAllocator = allocator instanceof RevisionIdAllocator ? allocator : getRevisionIdAllocatorForDocument(xmlDoc) || createRevisionIdAllocator(xmlDoc);
+  const candidates = [root, ...Array.from(root.getElementsByTagName?.("*") || [])];
+  for (const node of candidates) {
+    if (!isWordElement(node, "rPrChange")) continue;
+    const nextId = String(resolvedAllocator.next());
+    if (typeof node.setAttributeNS === "function") {
+      node.setAttributeNS(NS_W, "w:id", nextId);
+    } else {
+      node.setAttribute("w:id", nextId);
+    }
+  }
+  return root;
+}
 
 // services/comment-locator.js
-function createParagraphTextIndex(paragraph) {
+function createParagraphTextIndex(paragraph, options = {}) {
+  const revisionView = options.revisionView === "current" ? "accepted" : options.revisionView || "accepted";
   const runs = getElementsByTag(paragraph, "w:r");
   const runOffsets = [];
   let fullText = "";
   for (const run of runs) {
+    if (!isNodeVisibleInRevisionView(run, paragraph, revisionView)) continue;
     const start = fullText.length;
-    const textNodes = getElementsByTag(run, "w:t");
-    for (const textNode of textNodes) {
-      fullText += textNode.textContent || "";
-    }
+    const text = readCanonicalRunText(run, { revisionView, boundary: paragraph });
+    fullText += text;
     runOffsets.push({ run, start, end: fullText.length });
   }
   return { fullText, runOffsets };
 }
-function findTextInParagraphIndex(paragraphIndex, searchText) {
-  const searchIndex = paragraphIndex.fullText.indexOf(searchText);
-  if (searchIndex === -1) {
-    return { found: false };
+function candidateOffsets(haystack, needle) {
+  if (!needle) return [];
+  const candidates = [];
+  let offset = haystack.indexOf(needle);
+  while (offset !== -1) {
+    candidates.push({ start: offset, end: offset + needle.length });
+    offset = haystack.indexOf(needle, offset + 1);
   }
-  const searchEnd = searchIndex + searchText.length;
+  return candidates;
+}
+function spaceEquivalentText(value) {
+  return String(value).replace(/[ \u00a0]/g, " ");
+}
+function anchorError(code, message, candidates = []) {
+  return {
+    code,
+    message,
+    ...candidates.length > 0 ? { candidates } : {}
+  };
+}
+function attachRunOffsets(paragraphIndex, candidate, resolvedBy) {
   let startRun = null;
   let endRun = null;
   let startOffset = 0;
   let endOffset = 0;
   for (const { run, start, end } of paragraphIndex.runOffsets) {
-    if (searchIndex >= start && searchIndex < end) {
+    if (candidate.start >= start && candidate.start < end) {
       startRun = run;
-      startOffset = searchIndex - start;
+      startOffset = candidate.start - start;
     }
-    if (searchEnd > start && searchEnd <= end) {
+    if (candidate.end > start && candidate.end <= end) {
       endRun = run;
-      endOffset = searchEnd - start;
+      endOffset = candidate.end - start;
+    }
+  }
+  if (!startRun || !endRun) return null;
+  return { found: true, resolvedBy, ...candidate, startRun, startOffset, endRun, endOffset };
+}
+function findAncestorTag(node, tagNames, boundary = null) {
+  let current = node?.parentNode;
+  while (current && current.nodeType === 1 && current !== boundary && (current.localName || current.nodeName.replace(/^.*:/, "")) !== "p") {
+    const local = current.localName || current.nodeName.replace(/^.*:/, "");
+    if (tagNames.includes(local)) return { node: current, tag: local };
+    current = current.parentNode;
+  }
+  return null;
+}
+function validateAnchorLocation(paragraphIndex, location) {
+  if (!location || !location.found) return location;
+  const intersectingRuns = paragraphIndex.runOffsets.filter((entry) => entry.end > location.start && entry.start < location.end).map((entry) => entry.run);
+  for (const run of intersectingRuns) {
+    if (findAncestorTag(run, ["del"])) {
+      return {
+        found: false,
+        error: anchorError("UNSAFE_REVISION_NESTING", "Refusing to attach comment to pending deletion.", [location])
+      };
+    }
+    if (findAncestorTag(run, ["moveFrom", "moveTo"])) {
+      return {
+        found: false,
+        error: anchorError("UNSAFE_REVISION_NESTING", "Refusing to comment on move revision until move lifecycle is designed.", [location])
+      };
     }
   }
+  return location;
+}
+function resolveTextInParagraphIndex(paragraphIndex, searchText) {
+  const needle = String(searchText ?? "");
+  const exactCandidates = candidateOffsets(paragraphIndex.fullText, needle);
+  if (exactCandidates.length > 1) {
+    return {
+      found: false,
+      error: anchorError("AMBIGUOUS_ANCHOR", `Anchor text matched ${exactCandidates.length} locations in the target paragraph.`, exactCandidates)
+    };
+  }
+  if (exactCandidates.length === 1) {
+    const resolved = attachRunOffsets(paragraphIndex, exactCandidates[0], "exact_anchor");
+    if (resolved) return validateAnchorLocation(paragraphIndex, resolved);
+  }
+  const normalizedNeedle = spaceEquivalentText(needle);
+  const normalizedParagraph = spaceEquivalentText(paragraphIndex.fullText);
+  const equivalentCandidates = candidateOffsets(normalizedParagraph, normalizedNeedle);
+  if (equivalentCandidates.length > 1) {
+    return {
+      found: false,
+      error: anchorError("AMBIGUOUS_ANCHOR", `Space-equivalent anchor text matched ${equivalentCandidates.length} locations in the target paragraph.`, equivalentCandidates)
+    };
+  }
+  if (equivalentCandidates.length === 1) {
+    const resolved = attachRunOffsets(paragraphIndex, equivalentCandidates[0], "space_equivalent_anchor");
+    if (resolved) return validateAnchorLocation(paragraphIndex, resolved);
+  }
   return {
-    found: true,
-    startRun,
-    startOffset,
-    endRun,
-    endOffset
+    found: false,
+    error: anchorError("ANCHOR_NOT_FOUND", `Could not find anchor text in the target paragraph: "${needle}".`)
   };
 }
-function cloneRunWithText(xmlDoc, rPr, newText) {
+function cloneRunWithText(xmlDoc, rPr, newText, revisionIdAllocator, preserveRevisionIds = false) {
   const newRun = createWordElement(xmlDoc, "w:r");
   if (rPr) {
-    newRun.appendChild(rPr.cloneNode(true));
+    const clonedRPr = rPr.cloneNode(true);
+    if (!preserveRevisionIds) {
+      refreshRunPropertyChangeIds(clonedRPr, revisionIdAllocator);
+    }
+    newRun.appendChild(clonedRPr);
   }
   const newTextNode = createWordElement(xmlDoc, "w:t");
   newTextNode.setAttribute("xml:space", "preserve");
@@ -9077,9 +10949,9 @@ function cloneRunWithText(xmlDoc, rPr, newText) {
   newRun.appendChild(newTextNode);
   return newRun;
 }
-function injectMarkersIntoParagraph(xmlDoc, paragraph, textToFind, commentId, paragraphIndex = null) {
+function injectMarkersIntoParagraph(xmlDoc, paragraph, textToFind, commentId, paragraphIndex = null, revisionIdAllocator = null, resolvedLocation = null) {
   const activeIndex = paragraphIndex || createParagraphTextIndex(paragraph);
-  const location = findTextInParagraphIndex(activeIndex, textToFind);
+  const location = resolvedLocation || resolveTextInParagraphIndex(activeIndex, textToFind);
   if (!location.found || !location.startRun) {
     return false;
   }
@@ -9112,7 +10984,8 @@ function injectMarkersIntoParagraph(xmlDoc, paragraph, textToFind, commentId, pa
     const rPr = getFirstElementByTag(run, "w:rPr");
     const parent = run.parentNode;
     if (beforeText) {
-      parent.insertBefore(cloneRunWithText(xmlDoc, rPr, beforeText), run);
+      parent.insertBefore(cloneRunWithText(xmlDoc, rPr, beforeText, revisionIdAllocator, true), run);
+      refreshRunPropertyChangeIds(rPr, revisionIdAllocator);
     }
     parent.insertBefore(startMarker, run);
     textNode.textContent = highlightedText;
@@ -9123,7 +10996,7 @@ function injectMarkersIntoParagraph(xmlDoc, paragraph, textToFind, commentId, pa
     }
     parent.insertBefore(referenceRun, endMarker.nextSibling || null);
     if (afterText) {
-      parent.insertBefore(cloneRunWithText(xmlDoc, rPr, afterText), referenceRun.nextSibling || null);
+      parent.insertBefore(cloneRunWithText(xmlDoc, rPr, afterText, revisionIdAllocator), referenceRun.nextSibling || null);
     }
     return true;
   }
@@ -9134,7 +11007,11 @@ function injectMarkersIntoParagraph(xmlDoc, paragraph, textToFind, commentId, pa
     const highlightedStart = fullText.substring(location.startOffset);
     if (beforeText) {
       const rPr = getFirstElementByTag(location.startRun, "w:rPr");
-      location.startRun.parentNode.insertBefore(cloneRunWithText(xmlDoc, rPr, beforeText), location.startRun);
+      location.startRun.parentNode.insertBefore(
+        cloneRunWithText(xmlDoc, rPr, beforeText, revisionIdAllocator, true),
+        location.startRun
+      );
+      refreshRunPropertyChangeIds(rPr, revisionIdAllocator);
     }
     startTextNode.textContent = highlightedStart;
   }
@@ -9149,9 +11026,12 @@ function injectMarkersIntoParagraph(xmlDoc, paragraph, textToFind, commentId, pa
     if (afterText) {
       const rPr = getFirstElementByTag(endRun, "w:rPr");
       if (endRun.nextSibling) {
-        endRun.parentNode.insertBefore(cloneRunWithText(xmlDoc, rPr, afterText), endRun.nextSibling);
+        endRun.parentNode.insertBefore(
+          cloneRunWithText(xmlDoc, rPr, afterText, revisionIdAllocator),
+          endRun.nextSibling
+        );
       } else {
-        endRun.parentNode.appendChild(cloneRunWithText(xmlDoc, rPr, afterText));
+        endRun.parentNode.appendChild(cloneRunWithText(xmlDoc, rPr, afterText, revisionIdAllocator));
       }
     }
   }
@@ -9252,6 +11132,8 @@ function injectCommentsIntoOoxml(oxml, comments, options = {}) {
   const date = getRevisionTimestamp();
   const warnings = [];
   const placedComments = [];
+  const resolvedAnchors = [];
+  const errors = [];
   if (!comments || comments.length === 0) {
     return {
       oxml,
@@ -9278,19 +11160,22 @@ function injectCommentsIntoOoxml(oxml, comments, options = {}) {
     };
   }
   const xmlDoc = parseResult.xmlDoc;
+  const revisionIdAllocator = createRevisionIdAllocator(xmlDoc);
   const paragraphs = getElementsByTag(xmlDoc, "w:p");
   log(`[CommentEngine] Found ${paragraphs.length} paragraphs, processing ${comments.length} comment requests`);
   const remainingRequestsByParagraph = /* @__PURE__ */ new Map();
   for (const request of comments) {
     const paragraphIndex = request.paragraphIndex - 1;
     if (paragraphIndex < 0 || paragraphIndex >= paragraphs.length) {
-      warnings.push(`Paragraph ${request.paragraphIndex} out of range (1-${paragraphs.length})`);
+      const message = `Paragraph ${request.paragraphIndex} out of range (1-${paragraphs.length})`;
+      warnings.push(message);
+      errors.push({ code: "TARGET_NOT_FOUND", message, paragraphIndex: request.paragraphIndex });
       continue;
     }
     remainingRequestsByParagraph.set(paragraphIndex, (remainingRequestsByParagraph.get(paragraphIndex) || 0) + 1);
   }
   const paragraphIndexes = /* @__PURE__ */ new Map();
-  for (const request of comments) {
+  for (const [requestIndex, request] of comments.entries()) {
     const paragraphIndex = request.paragraphIndex - 1;
     if (paragraphIndex < 0 || paragraphIndex >= paragraphs.length) {
       continue;
@@ -9301,18 +11186,40 @@ function injectCommentsIntoOoxml(oxml, comments, options = {}) {
       textIndex = createParagraphTextIndex(targetParagraph);
       paragraphIndexes.set(paragraphIndex, textIndex);
     }
-    const commentId = getNextRevisionId();
+    const anchorText = String(request.textToFind ?? "");
+    const resolution = resolveTextInParagraphIndex(textIndex, anchorText);
+    const remaining = (remainingRequestsByParagraph.get(paragraphIndex) || 1) - 1;
+    remainingRequestsByParagraph.set(paragraphIndex, remaining);
+    if (!resolution.found) {
+      const error2 = {
+        ...resolution.error,
+        requestIndex: requestIndex + 1,
+        paragraphIndex: request.paragraphIndex
+      };
+      errors.push(error2);
+      warnings.push(error2.message);
+      if (remaining === 0) paragraphIndexes.delete(paragraphIndex);
+      continue;
+    }
+    const commentId = typeof options.commentIdAllocator === "function" ? options.commentIdAllocator() : getNextRevisionId();
     const success = injectMarkersIntoParagraph(
       xmlDoc,
       targetParagraph,
-      request.textToFind,
+      anchorText,
       commentId,
-      textIndex
+      textIndex,
+      revisionIdAllocator,
+      resolution
     );
-    const remaining = (remainingRequestsByParagraph.get(paragraphIndex) || 1) - 1;
-    remainingRequestsByParagraph.set(paragraphIndex, remaining);
     if (!success) {
-      warnings.push(`Could not find "${request.textToFind.substring(0, 30)}..." in paragraph ${request.paragraphIndex}`);
+      const error2 = {
+        code: "ANCHOR_INSERTION_FAILED",
+        message: `Resolved comment anchor could not be inserted in paragraph ${request.paragraphIndex}.`,
+        requestIndex: requestIndex + 1,
+        paragraphIndex: request.paragraphIndex
+      };
+      errors.push(error2);
+      warnings.push(error2.message);
       if (remaining === 0) {
         paragraphIndexes.delete(paragraphIndex);
       }
@@ -9324,6 +11231,14 @@ function injectCommentsIntoOoxml(oxml, comments, options = {}) {
       author,
       date
     });
+    resolvedAnchors.push({
+      requestIndex: requestIndex + 1,
+      paragraphIndex: request.paragraphIndex,
+      text: anchorText,
+      resolvedBy: resolution.resolvedBy,
+      start: resolution.start,
+      end: resolution.end
+    });
     if (remaining > 0) {
       paragraphIndexes.set(paragraphIndex, createParagraphTextIndex(targetParagraph));
     } else {
@@ -9335,7 +11250,9 @@ function injectCommentsIntoOoxml(oxml, comments, options = {}) {
       oxml,
       hasChanges: false,
       commentsApplied: 0,
-      warnings
+      warnings,
+      resolvedAnchors,
+      ...errors.length > 0 ? { status: "error", error: errors[0], errors } : {}
     };
   }
   return {
@@ -9343,13 +11260,107 @@ function injectCommentsIntoOoxml(oxml, comments, options = {}) {
     hasChanges: true,
     commentsXml: buildCommentsPartXml(placedComments),
     commentsApplied: placedComments.length,
-    warnings
+    placedComments,
+    warnings,
+    resolvedAnchors,
+    ...errors.length > 0 ? { status: "error", error: errors[0], errors } : {}
   };
 }
 function injectCommentsIntoPackage2(packageOxml, commentsXml) {
   return injectCommentsIntoPackage(packageOxml, commentsXml);
 }
 
+// services/comment-replies.js
+var NS_W6 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+function attr3(node, qualified, local) {
+  return node?.getAttribute?.(qualified) || node?.getAttribute?.(local) || "";
+}
+function parseRequired(xml, partName) {
+  const parsed = parseOoxmlSafe(xml, "application/xml");
+  if (!parsed.doc || parsed.error) {
+    return { error: { code: "PARSE_ERROR", message: `Could not parse ${partName}: ${parsed.error?.message || "invalid XML"}` } };
+  }
+  return { doc: parsed.doc };
+}
+function usedParaIds(commentsDoc, extendedDoc) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const p of Array.from(commentsDoc?.getElementsByTagNameNS("*", "p") || [])) {
+    const id = attr3(p, "w14:paraId", "paraId");
+    if (id) ids.add(id.toUpperCase());
+  }
+  for (const ex of Array.from(extendedDoc?.getElementsByTagNameNS("*", "commentEx") || [])) {
+    const id = attr3(ex, "w15:paraId", "paraId");
+    if (id) ids.add(id.toUpperCase());
+  }
+  return ids;
+}
+function allocateParaId(commentId, occupied) {
+  let candidate = createCommentParaId(commentId);
+  let value = Number.parseInt(candidate, 16) >>> 0;
+  while (occupied.has(candidate)) {
+    value = value + 1 >>> 0;
+    candidate = value.toString(16).toUpperCase().padStart(8, "0");
+  }
+  occupied.add(candidate);
+  return candidate;
+}
+function applyCommentReplyToParts({ commentsXml, commentsExtendedXml = null, parentCommentId, commentId, commentContent, author, date = (/* @__PURE__ */ new Date()).toISOString() }) {
+  if (!commentsXml) return { status: "error", error: { code: "COMMENTS_PART_MISSING", message: "A comment reply requires an existing word/comments.xml part." } };
+  const commentsParsed = parseRequired(commentsXml, "word/comments.xml");
+  if (commentsParsed.error) return { status: "error", error: commentsParsed.error };
+  const commentsDoc = commentsParsed.doc;
+  const parent = Array.from(commentsDoc.getElementsByTagNameNS("*", "comment")).find((node) => attr3(node, "w:id", "id") === String(parentCommentId));
+  if (!parent) return { status: "error", error: { code: "PARENT_COMMENT_NOT_FOUND", message: `Parent comment '${parentCommentId}' was not found.` } };
+  let extendedDoc = null;
+  if (commentsExtendedXml) {
+    const parsed = parseRequired(commentsExtendedXml, "word/commentsExtended.xml");
+    if (parsed.error) return { status: "error", error: parsed.error };
+    extendedDoc = parsed.doc;
+  }
+  const occupied = usedParaIds(commentsDoc, extendedDoc);
+  const parentParagraph = Array.from(parent.getElementsByTagNameNS(NS_W6, "p"))[0] || Array.from(parent.getElementsByTagNameNS("*", "p"))[0];
+  if (!parentParagraph) return { status: "error", error: { code: "PARENT_COMMENT_INVALID", message: `Parent comment '${parentCommentId}' has no paragraph.` } };
+  let parentParaId = attr3(parentParagraph, "w14:paraId", "paraId");
+  if (!parentParaId) {
+    parentParaId = allocateParaId(parentCommentId, occupied);
+    parentParagraph.setAttributeNS(NS_W14, "w14:paraId", parentParaId);
+  } else {
+    parentParaId = parentParaId.toUpperCase();
+  }
+  const replyParaId = allocateParaId(commentId, occupied);
+  const replyParsed = parseRequired(`<w:comments xmlns:w="${NS_W6}" xmlns:w14="${NS_W14}">${buildCommentElement(commentId, author, commentContent, date, replyParaId)}</w:comments>`, "reply comment");
+  commentsDoc.documentElement.appendChild(commentsDoc.importNode(replyParsed.doc.documentElement.firstChild, true));
+  if (!extendedDoc) {
+    extendedDoc = parseRequired(buildCommentsExtendedPartXml([]), "word/commentsExtended.xml").doc;
+  }
+  const root = extendedDoc.documentElement;
+  const entries = Array.from(root.getElementsByTagNameNS("*", "commentEx"));
+  if (!entries.some((node) => attr3(node, "w15:paraId", "paraId").toUpperCase() === parentParaId)) {
+    const parentEx = extendedDoc.createElementNS(NS_W15, "w15:commentEx");
+    parentEx.setAttributeNS(NS_W15, "w15:paraId", parentParaId);
+    parentEx.setAttributeNS(NS_W15, "w15:done", "0");
+    root.appendChild(parentEx);
+  }
+  const replyEx = extendedDoc.createElementNS(NS_W15, "w15:commentEx");
+  replyEx.setAttributeNS(NS_W15, "w15:paraId", replyParaId);
+  replyEx.setAttributeNS(NS_W15, "w15:paraIdParent", parentParaId);
+  replyEx.setAttributeNS(NS_W15, "w15:done", "0");
+  root.appendChild(replyEx);
+  const serializer = createSerializer();
+  return {
+    status: "ok",
+    hasChanges: true,
+    commentsXml: serializer.serializeToString(commentsDoc),
+    commentsExtendedXml: serializer.serializeToString(extendedDoc),
+    commentsXmlMode: "replace",
+    commentsExtendedXmlMode: "replace",
+    commentId,
+    parentCommentId: String(parentCommentId),
+    paraId: replyParaId,
+    parentParaId
+  };
+}
+
 // engine/formatting-removal.js
 function removeNode2(node) {
   if (node?.parentNode) {
@@ -9411,19 +11422,19 @@ function applyFormattingRemovalToOoxml(ooxmlString, targetText, formatTypes) {
   if (!targetText || !ooxmlString) return ooxmlString;
   const doc = parseOoxml(ooxmlString);
   if (!doc) return ooxmlString;
-  const NS_W7 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
-  const runs = doc.getElementsByTagNameNS(NS_W7, "r");
-  const insertions = doc.getElementsByTagNameNS(NS_W7, "ins");
+  const NS_W8 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+  const runs = doc.getElementsByTagNameNS(NS_W8, "r");
+  const insertions = doc.getElementsByTagNameNS(NS_W8, "ins");
   const allRuns = [...Array.from(runs)];
   for (const ins of insertions) {
-    const insideRuns = ins.getElementsByTagNameNS(NS_W7, "r");
+    const insideRuns = ins.getElementsByTagNameNS(NS_W8, "r");
     allRuns.push(...Array.from(insideRuns));
   }
   for (const run of allRuns) {
-    const textNodes = run.getElementsByTagNameNS(NS_W7, "t");
+    const textNodes = run.getElementsByTagNameNS(NS_W8, "t");
     const runText = Array.from(textNodes).map((t) => t.textContent).join("");
     if (runText.includes(targetText) || runText === targetText) {
-      const rPrElements = run.getElementsByTagNameNS(NS_W7, "rPr");
+      const rPrElements = run.getElementsByTagNameNS(NS_W8, "rPr");
       if (rPrElements.length > 0) {
         const rPr = rPrElements[0];
         const newRPr = removeFormattingFromRPr(rPr, formatTypes);
@@ -9458,7 +11469,7 @@ var HIGHLIGHT_COLOR_MAP = {
   "white": "white"
 };
 function injectHighlightIntoRPr(doc, rPr, color = "yellow", options = {}) {
-  const NS_W7 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+  const NS_W8 = "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();
@@ -9477,10 +11488,10 @@ function injectHighlightIntoRPr(doc, rPr, color = "yellow", options = {}) {
       }
     });
   }
-  const existingHighlight = rPrElement.getElementsByTagNameNS(NS_W7, "highlight");
+  const existingHighlight = rPrElement.getElementsByTagNameNS(NS_W8, "highlight");
   Array.from(existingHighlight).forEach(removeNode2);
   const highlightEl = createWordElement(doc, "w:highlight");
-  highlightEl.setAttributeNS(NS_W7, "w:val", ooxmlColor);
+  highlightEl.setAttributeNS(NS_W8, "w:val", ooxmlColor);
   rPrElement.appendChild(highlightEl);
   if (generateRedlines && previousRPrState) {
     const rPrChange = createWordElement(doc, "w:rPrChange");
@@ -9489,7 +11500,7 @@ function injectHighlightIntoRPr(doc, rPr, color = "yellow", options = {}) {
     rPrChange.setAttribute("w:author", metadata.author);
     rPrChange.setAttribute("w:date", metadata.date);
     rPrChange.appendChild(previousRPrState);
-    const existingChange = rPrElement.getElementsByTagNameNS(NS_W7, "rPrChange");
+    const existingChange = rPrElement.getElementsByTagNameNS(NS_W8, "rPrChange");
     Array.from(existingChange).forEach(removeNode2);
     rPrElement.appendChild(rPrChange);
   }
@@ -9499,27 +11510,35 @@ function applyHighlightToOoxml(ooxmlString, targetText, color = "yellow", option
   if (!targetText || !ooxmlString) return ooxmlString;
   const doc = parseOoxml(ooxmlString);
   if (!doc) return ooxmlString;
+  let revisionIdAllocator;
   if (options?._revisionIdAllocator instanceof RevisionIdAllocator) {
-    seedRevisionIdsFromDocument(doc, options._revisionIdAllocator);
+    revisionIdAllocator = options._revisionIdAllocator;
+    seedRevisionIdsFromDocument(doc, revisionIdAllocator);
   } else {
-    createRevisionIdAllocator(doc);
+    revisionIdAllocator = createRevisionIdAllocator(doc);
   }
-  const NS_W7 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+  const NS_W8 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
   const getRunText = (run) => {
-    const textNodes = run.getElementsByTagNameNS(NS_W7, "t");
+    const textNodes = run.getElementsByTagNameNS(NS_W8, "t");
     return Array.from(textNodes).map((t) => t.textContent).join("");
   };
-  const allRuns = Array.from(doc.getElementsByTagNameNS(NS_W7, "r"));
+  const allRuns = Array.from(doc.getElementsByTagNameNS(NS_W8, "r"));
+  const sourceRunsWithClaimedRevisionIds = /* @__PURE__ */ new WeakSet();
   const cloneRunWithText2 = (sourceRun, text, shouldHighlight) => {
     const clonedRun = sourceRun.cloneNode(true);
-    const textNodes = clonedRun.getElementsByTagNameNS(NS_W7, "t");
+    if (sourceRunsWithClaimedRevisionIds.has(sourceRun)) {
+      refreshRunPropertyChangeIds(clonedRun, revisionIdAllocator);
+    } else {
+      sourceRunsWithClaimedRevisionIds.add(sourceRun);
+    }
+    const textNodes = clonedRun.getElementsByTagNameNS(NS_W8, "t");
     Array.from(textNodes).forEach(removeNode2);
     const newText = createWordElement(doc, "w:t");
     newText.setAttribute("xml:space", "preserve");
     newText.textContent = text;
     clonedRun.appendChild(newText);
     if (shouldHighlight) {
-      const rPrElements = clonedRun.getElementsByTagNameNS(NS_W7, "rPr");
+      const rPrElements = clonedRun.getElementsByTagNameNS(NS_W8, "rPr");
       const existingRPr = rPrElements.length > 0 ? rPrElements[0] : null;
       const newRPr = injectHighlightIntoRPr(doc, existingRPr, color, options);
       if (existingRPr) {
@@ -9569,16 +11588,19 @@ function applyHighlightToOoxml(ooxmlString, targetText, color = "yellow", option
 }
 
 // services/standalone-docx-plumbing.js
-var NS_W6 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+var NS_W7 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
 var NS_CT = "http://schemas.openxmlformats.org/package/2006/content-types";
 var NS_RELS = "http://schemas.openxmlformats.org/package/2006/relationships";
 var NUMBERING_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering";
 var NUMBERING_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml";
 var COMMENTS_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments";
 var COMMENTS_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml";
+var COMMENTS_EXTENDED_REL_TYPE = "http://schemas.microsoft.com/office/2011/relationships/commentsExtended";
+var COMMENTS_EXTENDED_CONTENT_TYPE = "application/vnd.ms-word.commentsExtended+xml";
 var DOCUMENT_PATH = "word/document.xml";
 var NUMBERING_PATH = "word/numbering.xml";
 var COMMENTS_PATH = "word/comments.xml";
+var COMMENTS_EXTENDED_PATH = "word/commentsExtended.xml";
 var CONTENT_TYPES_PATH = "[Content_Types].xml";
 var DOCUMENT_RELS_PATH = "word/_rels/document.xml.rels";
 function parseXmlStrictStandalone(xmlText, label = "xml") {
@@ -9591,7 +11613,7 @@ function parseXmlStrictStandalone(xmlText, label = "xml") {
   return parsed.doc;
 }
 function isSectionPropertiesElement(node) {
-  return !!node && node.nodeType === 1 && node.namespaceURI === NS_W6 && node.localName === "sectPr";
+  return !!node && node.nodeType === 1 && node.namespaceURI === NS_W7 && node.localName === "sectPr";
 }
 function getBodyElementFromDocument(xmlDoc) {
   return xmlDoc.getElementsByTagNameNS("*", "body")[0] || null;
@@ -9627,15 +11649,15 @@ function normalizeBodySectionOrderStandalone(xmlDoc) {
 function sanitizeNestedParagraphsInTables(xmlDoc, options = {}) {
   const onInfo = typeof options?.onInfo === "function" ? options.onInfo : () => {
   };
-  const tcs = xmlDoc.getElementsByTagNameNS(NS_W6, "tc");
+  const tcs = xmlDoc.getElementsByTagNameNS(NS_W7, "tc");
   let fixed = 0;
   for (const tc of Array.from(tcs)) {
     const outerParagraphs = Array.from(tc.childNodes || []).filter(
-      (node) => node.nodeType === 1 && node.namespaceURI === NS_W6 && node.localName === "p"
+      (node) => node.nodeType === 1 && node.namespaceURI === NS_W7 && node.localName === "p"
     );
     for (const outerParagraph of outerParagraphs) {
       const innerParagraphs = Array.from(outerParagraph.childNodes || []).filter(
-        (node) => node.nodeType === 1 && node.namespaceURI === NS_W6 && node.localName === "p"
+        (node) => node.nodeType === 1 && node.namespaceURI === NS_W7 && node.localName === "p"
       );
       for (const innerParagraph of innerParagraphs) {
         tc.insertBefore(innerParagraph, outerParagraph);
@@ -9704,7 +11726,7 @@ function extractReplacementNodesFromOoxml(outputOxml) {
       const replacementNodes2 = body ? Array.from(body.childNodes || []).filter((node) => node.nodeType === 1 && !isSectionPropertiesElement(node)) : Array.from(doc.childNodes || []).filter((node) => node.nodeType === 1);
       return { replacementNodes: replacementNodes2, numberingXml: null, sourceType: "document" };
     }
-    const wrapped = `<root xmlns:w="${NS_W6}">${outputOxml}</root>`;
+    const wrapped = `<root xmlns:w="${NS_W7}">${outputOxml}</root>`;
     const fragmentDoc = parseXmlStrictStandalone(wrapped, "OOXML fragment");
     const replacementNodes = Array.from(fragmentDoc.documentElement.childNodes || []).filter((node) => node.nodeType === 1);
     return { replacementNodes, numberingXml: null, sourceType: "fragment" };
@@ -9720,17 +11742,21 @@ function extractReplacementNodesFromOoxml(outputOxml) {
 }
 function upsertContentTypeOverride(ctDoc, partName, contentType) {
   const overrides = Array.from(ctDoc.getElementsByTagNameNS("*", "Override"));
-  const hasOverride = overrides.some(
+  const existingOverride = overrides.find(
     (override2) => (override2.getAttribute("PartName") || "").toLowerCase() === String(partName).toLowerCase()
   );
-  if (hasOverride) return false;
+  if (existingOverride) {
+    if ((existingOverride.getAttribute("ContentType") || "") === contentType) return false;
+    existingOverride.setAttribute("ContentType", contentType);
+    return true;
+  }
   const override = ctDoc.createElementNS(NS_CT, "Override");
   override.setAttribute("PartName", partName);
   override.setAttribute("ContentType", contentType);
   ctDoc.documentElement.appendChild(override);
   return true;
 }
-function upsertDocumentRelationship(relsDoc, relType, target) {
+function upsertDocumentRelationship(relsDoc, relType, target, options = {}) {
   const relsRoot = relsDoc.getElementsByTagNameNS("*", "Relationships")[0] || relsDoc.documentElement;
   const rels = Array.from(relsRoot.getElementsByTagNameNS("*", "Relationship"));
   const hasRel = rels.some((rel2) => (rel2.getAttribute("Type") || "") === relType);
@@ -9743,11 +11769,17 @@ function upsertDocumentRelationship(relsDoc, relType, target) {
       maxId = Math.max(maxId, idNum);
     }
   }
+  const newId = `rId${maxId + 1}`;
   const rel = relsDoc.createElementNS(NS_RELS, "Relationship");
-  rel.setAttribute("Id", `rId${maxId + 1}`);
+  rel.setAttribute("Id", newId);
   rel.setAttribute("Type", relType);
   rel.setAttribute("Target", target);
   relsRoot.appendChild(rel);
+  if (options?._receiptCollector) {
+    options._receiptCollector.recordRelationship(newId);
+  } else if (options?._documentOperationSession?.receiptCollector) {
+    options._documentOperationSession.receiptCollector.recordRelationship(newId);
+  }
   return true;
 }
 async function readZipText(zip, filePath) {
@@ -9759,9 +11791,13 @@ async function ensureNumberingArtifactsInZip(zip, numberingXmlList, options = {}
   const onInfo = typeof options?.onInfo === "function" ? options.onInfo : () => {
   };
   const mergeNumberingXml = typeof options?.mergeNumberingXml === "function" ? options.mergeNumberingXml : null;
+  const onWarn = typeof options?.onWarn === "function" ? options.onWarn : warn;
   const incomingPayloads = (Array.isArray(numberingXmlList) ? numberingXmlList : [numberingXmlList]).filter(Boolean);
   if (incomingPayloads.length === 0) return;
   const existing = await readZipText(zip, NUMBERING_PATH);
+  if (existing && !mergeNumberingXml) {
+    onWarn("[Deprecation] Replacing an existing numbering.xml without mergeNumberingXml is deprecated and will throw in the next major version.");
+  }
   let mergedNumberingXml = existing || null;
   for (const incomingNumberingXml of incomingPayloads) {
     if (!mergedNumberingXml) {
@@ -9787,7 +11823,7 @@ async function ensureNumberingArtifactsInZip(zip, numberingXmlList, options = {}
   const relsText = await readZipText(zip, DOCUMENT_RELS_PATH);
   if (relsText) {
     const relsDoc = parseXmlStrictStandalone(relsText, DOCUMENT_RELS_PATH);
-    if (upsertDocumentRelationship(relsDoc, NUMBERING_REL_TYPE, "numbering.xml")) {
+    if (upsertDocumentRelationship(relsDoc, NUMBERING_REL_TYPE, "numbering.xml", options)) {
       zip.file(DOCUMENT_RELS_PATH, serializer.serializeToString(relsDoc));
     }
   }
@@ -9798,7 +11834,7 @@ async function ensureCommentsArtifactsInZip(zip, commentsXml, options = {}) {
   if (!commentsXml) return;
   const serializer = createSerializer();
   const existingText = await readZipText(zip, COMMENTS_PATH);
-  if (!existingText) {
+  if (!existingText || options.replaceExisting === true) {
     onInfo("[Demo] Adding comments.xml");
     zip.file(COMMENTS_PATH, commentsXml);
   } else {
@@ -9806,9 +11842,9 @@ async function ensureCommentsArtifactsInZip(zip, commentsXml, options = {}) {
     const incomingDoc = parseXmlStrictStandalone(commentsXml, "word/comments.xml (incoming)");
     const existingRoot = existingDoc.documentElement;
     const existingIds = new Set(
-      Array.from(existingRoot.getElementsByTagNameNS(NS_W6, "comment")).map((comment) => comment.getAttribute("w:id") || comment.getAttribute("id")).filter(Boolean)
+      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_W6, "comment"))) {
+    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}`);
@@ -9827,7 +11863,27 @@ async function ensureCommentsArtifactsInZip(zip, commentsXml, options = {}) {
   const relsText = await readZipText(zip, DOCUMENT_RELS_PATH);
   if (relsText) {
     const relsDoc = parseXmlStrictStandalone(relsText, DOCUMENT_RELS_PATH);
-    if (upsertDocumentRelationship(relsDoc, COMMENTS_REL_TYPE, "comments.xml")) {
+    if (upsertDocumentRelationship(relsDoc, COMMENTS_REL_TYPE, "comments.xml", options)) {
+      zip.file(DOCUMENT_RELS_PATH, serializer.serializeToString(relsDoc));
+    }
+  }
+}
+async function ensureCommentsExtendedArtifactsInZip(zip, commentsExtendedXml, options = {}) {
+  if (!commentsExtendedXml) return;
+  parseXmlStrictStandalone(commentsExtendedXml, "word/commentsExtended.xml");
+  zip.file(COMMENTS_EXTENDED_PATH, commentsExtendedXml);
+  const serializer = createSerializer();
+  const ctText = await readZipText(zip, CONTENT_TYPES_PATH);
+  if (ctText) {
+    const ctDoc = parseXmlStrictStandalone(ctText, CONTENT_TYPES_PATH);
+    if (upsertContentTypeOverride(ctDoc, "/word/commentsExtended.xml", COMMENTS_EXTENDED_CONTENT_TYPE)) {
+      zip.file(CONTENT_TYPES_PATH, serializer.serializeToString(ctDoc));
+    }
+  }
+  const relsText = await readZipText(zip, DOCUMENT_RELS_PATH);
+  if (relsText) {
+    const relsDoc = parseXmlStrictStandalone(relsText, DOCUMENT_RELS_PATH);
+    if (upsertDocumentRelationship(relsDoc, COMMENTS_EXTENDED_REL_TYPE, "commentsExtended.xml", options)) {
       zip.file(DOCUMENT_RELS_PATH, serializer.serializeToString(relsDoc));
     }
   }
@@ -9851,12 +11907,12 @@ async function validateDocxPackage(zip) {
   if (sectPrIndexes.length === 1 && sectPrIndexes[0] !== directBodyElements.length - 1) {
     throw new Error("Validation failed: w:sectPr not last");
   }
-  const tcs = documentDoc.getElementsByTagNameNS(NS_W6, "tc");
+  const tcs = documentDoc.getElementsByTagNameNS(NS_W7, "tc");
   for (const tc of Array.from(tcs)) {
     for (const child of Array.from(tc.childNodes || []).filter((node) => node.nodeType === 1)) {
-      if (child.namespaceURI === NS_W6 && child.localName === "p") {
+      if (child.namespaceURI === NS_W7 && child.localName === "p") {
         const hasNestedParagraph = Array.from(child.childNodes || []).some(
-          (node) => node.nodeType === 1 && node.namespaceURI === NS_W6 && node.localName === "p"
+          (node) => node.nodeType === 1 && node.namespaceURI === NS_W7 && node.localName === "p"
         );
         if (hasNestedParagraph) {
           throw new Error("Validation failed: nested w:p");
@@ -9864,17 +11920,77 @@ async function validateDocxPackage(zip) {
       }
     }
   }
-  const hasNumberingUsage = documentDoc.getElementsByTagNameNS(NS_W6, "numPr").length > 0;
-  const hasCommentUsage = documentDoc.getElementsByTagNameNS(NS_W6, "commentRangeStart").length > 0 || documentDoc.getElementsByTagNameNS(NS_W6, "commentRangeEnd").length > 0 || documentDoc.getElementsByTagNameNS(NS_W6, "commentReference").length > 0;
+  const hasNumberingUsage = documentDoc.getElementsByTagNameNS(NS_W7, "numPr").length > 0;
+  const hasCommentUsage = documentDoc.getElementsByTagNameNS(NS_W7, "commentRangeStart").length > 0 || documentDoc.getElementsByTagNameNS(NS_W7, "commentRangeEnd").length > 0 || documentDoc.getElementsByTagNameNS(NS_W7, "commentReference").length > 0;
   const numberingXml = await readZipText(zip, NUMBERING_PATH);
   const commentsXml = await readZipText(zip, COMMENTS_PATH);
+  const commentsExtendedXml = await readZipText(zip, COMMENTS_EXTENDED_PATH);
+  if (commentsExtendedXml && !commentsXml) {
+    throw new Error("Validation failed: commentsExtended part exists but comments part is missing");
+  }
   if (numberingXml) {
     parseXmlStrictStandalone(numberingXml, NUMBERING_PATH);
   } else if (hasNumberingUsage) {
     throw new Error("Validation failed: numbering used but part missing");
   }
   if (commentsXml) {
-    parseXmlStrictStandalone(commentsXml, COMMENTS_PATH);
+    const commentsDoc = parseXmlStrictStandalone(commentsXml, COMMENTS_PATH);
+    const idsFor = (doc, localName2) => Array.from(doc.getElementsByTagNameNS(NS_W7, localName2)).map((node) => node.getAttribute("w:id") || node.getAttribute("id")).filter((id) => id !== "");
+    const starts = new Set(idsFor(documentDoc, "commentRangeStart"));
+    const ends = new Set(idsFor(documentDoc, "commentRangeEnd"));
+    const references = new Set(idsFor(documentDoc, "commentReference"));
+    const definitionIds = idsFor(commentsDoc, "comment");
+    const definitions = new Set(definitionIds);
+    const sorted = (ids) => Array.from(ids).sort((a, b) => Number(a) - Number(b) || a.localeCompare(b));
+    const difference = (left, right) => sorted(new Set(Array.from(left).filter((id) => !right.has(id))));
+    const duplicateDefinitions = sorted(new Set(definitionIds.filter((id, index) => definitionIds.indexOf(id) !== index)));
+    if (duplicateDefinitions.length > 0) {
+      throw new Error(`Validation failed: duplicate comment definitions for id(s): ${duplicateDefinitions.join(", ")}`);
+    }
+    const startsWithoutEnds = difference(starts, ends);
+    const endsWithoutStarts = difference(ends, starts);
+    if (startsWithoutEnds.length > 0 || endsWithoutStarts.length > 0) {
+      const parts = [];
+      if (startsWithoutEnds.length > 0) parts.push(`start without end: ${startsWithoutEnds.join(", ")}`);
+      if (endsWithoutStarts.length > 0) parts.push(`end without start: ${endsWithoutStarts.join(", ")}`);
+      throw new Error(`Validation failed: unbalanced comment range marker(s) (${parts.join("; ")})`);
+    }
+    const rangesWithoutReferences = difference(/* @__PURE__ */ new Set([...starts, ...ends]), references);
+    if (rangesWithoutReferences.length > 0) {
+      throw new Error(`Validation failed: comment range has no reference for id(s): ${rangesWithoutReferences.join(", ")}`);
+    }
+    const usagesWithoutDefinitions = difference(/* @__PURE__ */ new Set([...starts, ...ends, ...references]), definitions);
+    if (usagesWithoutDefinitions.length > 0) {
+      throw new Error(`Validation failed: comment usage has no definition for id(s): ${usagesWithoutDefinitions.join(", ")}`);
+    }
+    const replyCommentIds = /* @__PURE__ */ new Set();
+    if (commentsExtendedXml) {
+      const extendedDoc = parseXmlStrictStandalone(commentsExtendedXml, COMMENTS_EXTENDED_PATH);
+      const paraIdToCommentId = /* @__PURE__ */ new Map();
+      for (const comment of Array.from(commentsDoc.getElementsByTagNameNS("*", "comment"))) {
+        const id = comment.getAttribute("w:id") || comment.getAttribute("id");
+        const paragraph = Array.from(comment.getElementsByTagNameNS("*", "p"))[0];
+        const paraId = paragraph?.getAttribute("w14:paraId") || paragraph?.getAttribute("paraId");
+        if (paraId) paraIdToCommentId.set(paraId.toUpperCase(), id);
+      }
+      const knownParaIds = new Set(paraIdToCommentId.keys());
+      const extendedParaIds = /* @__PURE__ */ new Set();
+      for (const entry of Array.from(extendedDoc.getElementsByTagNameNS("*", "commentEx"))) {
+        const paraId = entry.getAttribute("w15:paraId") || entry.getAttribute("paraId");
+        const parentParaId = entry.getAttribute("w15:paraIdParent") || entry.getAttribute("paraIdParent");
+        if (!paraId || !knownParaIds.has(paraId.toUpperCase())) throw new Error(`Validation failed: commentsExtended entry has no matching comment paragraph: ${paraId || "(missing)"}`);
+        if (extendedParaIds.has(paraId.toUpperCase())) throw new Error(`Validation failed: duplicate commentsExtended entry for paraId: ${paraId}`);
+        extendedParaIds.add(paraId.toUpperCase());
+        if (parentParaId) {
+          if (!knownParaIds.has(parentParaId.toUpperCase())) throw new Error(`Validation failed: commentsExtended parent paragraph was not found: ${parentParaId}`);
+          replyCommentIds.add(paraIdToCommentId.get(paraId.toUpperCase()));
+        }
+      }
+    }
+    const definitionsWithoutReferences = difference(new Set([...definitions].filter((id) => !replyCommentIds.has(id))), references);
+    if (definitionsWithoutReferences.length > 0) {
+      throw new Error(`Validation failed: comment definition has no document reference for id(s): ${definitionsWithoutReferences.join(", ")}`);
+    }
   } else if (hasCommentUsage) {
     throw new Error("Validation failed: comments used but part missing");
   }
@@ -9916,6 +12032,16 @@ async function validateDocxPackage(zip) {
       throw new Error("Validation failed: comments rel missing");
     }
   }
+  if (commentsExtendedXml) {
+    const hasContentType = Array.from(ctDoc.getElementsByTagNameNS("*", "Override")).some(
+      (override) => (override.getAttribute("PartName") || "").toLowerCase() === "/word/commentsextended.xml" && (override.getAttribute("ContentType") || "") === COMMENTS_EXTENDED_CONTENT_TYPE
+    );
+    const hasRelationship = Array.from(relsDoc.getElementsByTagNameNS("*", "Relationship")).some(
+      (rel) => (rel.getAttribute("Type") || "") === COMMENTS_EXTENDED_REL_TYPE
+    );
+    if (!hasContentType) throw new Error("Validation failed: commentsExtended CT override missing");
+    if (!hasRelationship) throw new Error("Validation failed: commentsExtended rel missing");
+  }
 }
 
 // orchestration/route-plan.js
@@ -10040,6 +12166,239 @@ function extractParagraphIdFromOoxml(ooxml) {
   return match ? match[1] : null;
 }
 
+// services/receipt-collector.js
+var ReceiptCollector = class {
+  constructor() {
+    this.receipts = [];
+    this.activeReceipt = null;
+  }
+  beginOperation(operationIndex, operationId = null, authorUsed = null) {
+    this.activeReceipt = {
+      operationIndex: typeof operationIndex === "number" ? operationIndex : 1,
+      ...operationId ? { operationId: String(operationId) } : {},
+      attemptedDisposition: "applied",
+      finalDisposition: "applied",
+      committed: true,
+      ...authorUsed ? { authorUsed: String(authorUsed) } : {},
+      revisionItems: [],
+      commentIds: [],
+      numberingIds: [],
+      relationshipIds: [],
+      affectedTargets: [],
+      warnings: []
+    };
+  }
+  recordRevision(id, kind = "structural", partName = "word/document.xml") {
+    if (!this.activeReceipt || id == null) return;
+    const strId = String(id);
+    if (!this.activeReceipt.revisionItems.some((item) => item.id === strId && item.kind === kind && item.partName === partName)) {
+      this.activeReceipt.revisionItems.push({
+        id: strId,
+        kind,
+        partName
+      });
+    }
+  }
+  recordComment(id, _partName = "word/comments.xml") {
+    if (!this.activeReceipt || id == null) return;
+    const strId = String(id);
+    if (!this.activeReceipt.commentIds.includes(strId)) {
+      this.activeReceipt.commentIds.push(strId);
+    }
+  }
+  recordNumbering(id, _partName = "word/numbering.xml") {
+    if (!this.activeReceipt || id == null) return;
+    const strId = String(id);
+    if (!this.activeReceipt.numberingIds.includes(strId)) {
+      this.activeReceipt.numberingIds.push(strId);
+    }
+  }
+  recordRelationship(id, _partName = "word/_rels/document.xml.rels") {
+    if (!this.activeReceipt || id == null) return;
+    const strId = String(id);
+    if (!this.activeReceipt.relationshipIds.includes(strId)) {
+      this.activeReceipt.relationshipIds.push(strId);
+    }
+  }
+  recordAffectedTarget(target) {
+    if (!this.activeReceipt || !target) return;
+    this.activeReceipt.affectedTargets.push(JSON.parse(JSON.stringify(target)));
+  }
+  recordWarning(warning) {
+    if (!this.activeReceipt || !warning) return;
+    this.activeReceipt.warnings.push(String(warning));
+  }
+  commitOperation(disposition = "applied") {
+    if (!this.activeReceipt) return null;
+    this.activeReceipt.attemptedDisposition = disposition;
+    this.activeReceipt.finalDisposition = disposition;
+    this.activeReceipt.committed = disposition === "applied";
+    const committed = JSON.parse(JSON.stringify(this.activeReceipt));
+    this.receipts.push(committed);
+    this.activeReceipt = null;
+    return committed;
+  }
+  abortOperation(disposition = "refused") {
+    if (!this.activeReceipt) return null;
+    this.activeReceipt.attemptedDisposition = disposition;
+    this.activeReceipt.finalDisposition = disposition;
+    this.activeReceipt.committed = false;
+    const aborted = JSON.parse(JSON.stringify(this.activeReceipt));
+    this.activeReceipt = null;
+    return aborted;
+  }
+  createSavepoint() {
+    return {
+      receipts: JSON.parse(JSON.stringify(this.receipts)),
+      activeReceipt: this.activeReceipt ? JSON.parse(JSON.stringify(this.activeReceipt)) : null
+    };
+  }
+  restoreSavepoint(savepoint) {
+    if (!savepoint) return;
+    this.receipts = Array.isArray(savepoint.receipts) ? JSON.parse(JSON.stringify(savepoint.receipts)) : [];
+    this.activeReceipt = savepoint.activeReceipt ? JSON.parse(JSON.stringify(savepoint.activeReceipt)) : null;
+  }
+  clear() {
+    this.receipts = [];
+    this.activeReceipt = null;
+  }
+  markRolledBack() {
+    for (const receipt of this.receipts) {
+      if (receipt.attemptedDisposition === "applied") {
+        receipt.finalDisposition = "rolled_back";
+        receipt.committed = false;
+      }
+    }
+    this.activeReceipt = null;
+  }
+  getReceipts() {
+    return JSON.parse(JSON.stringify(this.receipts));
+  }
+  getCurrentReceipt() {
+    return this.activeReceipt ? JSON.parse(JSON.stringify(this.activeReceipt)) : null;
+  }
+};
+function createEmptyReceipt(operationIndex, operationId = null, authorUsed = null, disposition = "not_attempted") {
+  return {
+    operationIndex: typeof operationIndex === "number" ? operationIndex : 1,
+    ...operationId ? { operationId: String(operationId) } : {},
+    attemptedDisposition: disposition,
+    finalDisposition: disposition,
+    committed: false,
+    ...authorUsed ? { authorUsed: String(authorUsed) } : {},
+    revisionItems: [],
+    commentIds: [],
+    numberingIds: [],
+    relationshipIds: [],
+    affectedTargets: [],
+    warnings: []
+  };
+}
+function reconcileReceiptsAgainstOutput(parts, receipts) {
+  if (!Array.isArray(receipts) || receipts.length === 0) {
+    return { valid: true };
+  }
+  const committedReceipts = receipts.filter((r) => r && r.committed === true && r.finalDisposition === "applied");
+  if (committedReceipts.length === 0) {
+    return { valid: true };
+  }
+  const revisionIdSet = /* @__PURE__ */ new Set();
+  if (parts?.documentXml && typeof parts.documentXml === "string") {
+    const revRegex = /<(?:w:)?(?:ins|del|rPrChange|pPrChange|moveFrom|moveTo)\b[^>]*?\b(?:w:)?id="([^"]+)"/g;
+    let m;
+    while ((m = revRegex.exec(parts.documentXml)) !== null) {
+      revisionIdSet.add(m[1]);
+    }
+  }
+  const commentIdSet = /* @__PURE__ */ new Set();
+  if (parts?.commentsXml && typeof parts.commentsXml === "string") {
+    const comRegex = /<(?:w:)?comment\b[^>]*?\b(?:w:)?id="([^"]+)"/g;
+    let m;
+    while ((m = comRegex.exec(parts.commentsXml)) !== null) {
+      commentIdSet.add(m[1]);
+    }
+  }
+  const numberingIdSet = /* @__PURE__ */ new Set();
+  const combinedNumbering = [parts?.numberingXml, ...parts?.numberingXmlParts || []].filter(Boolean).join("\n");
+  if (combinedNumbering) {
+    const numRegex = /<(?:w:)?num\b[^>]*?\b(?:w:)?numId="([^"]+)"/g;
+    let m;
+    while ((m = numRegex.exec(combinedNumbering)) !== null) {
+      numberingIdSet.add(m[1]);
+    }
+  }
+  if (parts?.documentXml && typeof parts.documentXml === "string") {
+    const docNumRegex = /<(?:w:)?numId\b[^>]*?\b(?:w:)?val="([^"]+)"/g;
+    let m;
+    while ((m = docNumRegex.exec(parts.documentXml)) !== null) {
+      numberingIdSet.add(m[1]);
+    }
+  }
+  const relIdSet = /* @__PURE__ */ new Set();
+  if (parts?.relationshipsXml && typeof parts.relationshipsXml === "string") {
+    const relRegex = /<Relationship\b[^>]*?\bId="([^"]+)"/g;
+    let m;
+    while ((m = relRegex.exec(parts.relationshipsXml)) !== null) {
+      relIdSet.add(m[1]);
+    }
+  }
+  for (const receipt of committedReceipts) {
+    if (Array.isArray(receipt.revisionItems)) {
+      for (const item of receipt.revisionItems) {
+        if (item.partName === "word/document.xml" && !revisionIdSet.has(String(item.id))) {
+          return {
+            valid: false,
+            error: {
+              code: "RECEIPT_RECONCILIATION_FAILED",
+              message: `Committed revision id '${item.id}' (kind: ${item.kind}) was not found in word/document.xml.`
+            }
+          };
+        }
+      }
+    }
+    if (Array.isArray(receipt.commentIds)) {
+      for (const id of receipt.commentIds) {
+        if (!commentIdSet.has(String(id))) {
+          return {
+            valid: false,
+            error: {
+              code: "RECEIPT_RECONCILIATION_FAILED",
+              message: `Committed comment id '${id}' was not found in word/comments.xml.`
+            }
+          };
+        }
+      }
+    }
+    if (Array.isArray(receipt.numberingIds)) {
+      for (const id of receipt.numberingIds) {
+        if (!numberingIdSet.has(String(id))) {
+          return {
+            valid: false,
+            error: {
+              code: "RECEIPT_RECONCILIATION_FAILED",
+              message: `Committed numbering id '${id}' was not found in numbering parts or document.`
+            }
+          };
+        }
+      }
+    }
+    if (parts?.relationshipsXml && Array.isArray(receipt.relationshipIds)) {
+      for (const id of receipt.relationshipIds) {
+        if (!relIdSet.has(String(id))) {
+          return {
+            valid: false,
+            error: {
+              code: "RECEIPT_RECONCILIATION_FAILED",
+              message: `Committed relationship id '${id}' was not found in document.xml.rels.`
+            }
+          };
+        }
+      }
+    }
+  }
+  return { valid: true };
+}
+
 // index.js
 async function applyRedlineToOxml2(oxml, originalText, modifiedText, options = {}) {
   const result = await applyRedlineToOxml(oxml, originalText, modifiedText, options);
@@ -10185,49 +12544,66 @@ export {
   DiffOp,
   NS_W,
   NumberingService,
+  ReceiptCollector,
   ReconciliationPipeline,
   RoutePlanKind,
   RunKind,
   WORD_MAIN_NS,
   acceptTrackedChangesInOoxml,
+  analyzeStructuredContent,
+  applyCommentReplyToParts,
   applyFormattingRemovalToOoxml,
   applyHighlightToOoxml,
   applyRedlineToOxml2 as applyRedlineToOxml,
   applyRedlineToOxmlWithListFallback,
+  areRevisionTokensEqual,
   buildCommentElement,
   buildCommentsPartXml,
   buildExplicitDecimalMultilevelNumberingXml,
   buildListMarkdown,
   buildReconciliationPlan,
+  buildRevisionTokenFraming,
   buildSingleLineListStructuralFallbackPlan,
   buildTargetReferenceSnapshot,
   clearSingleLineListFallbackExplicitSequence,
   collectContiguousListParagraphBlock,
+  computeDocumentPartsRevisionToken,
+  computeRevisionToken,
+  computeRevisionTokenSync,
   configureLogger,
   configureXmlProvider,
   containsTrackedChanges,
   createDynamicNumberingIdState,
+  createEmptyReceipt,
+  createParagraphFingerprint,
   deleteCommentsByAuthorInOoxml,
   enforceListBindingOnParagraphNodes,
   ensureCommentsArtifactsInZip,
+  ensureCommentsExtendedArtifactsInZip,
   ensureNumberingArtifactsInZip,
   escapeXml,
   executeSingleLineListStructuralFallback,
+  extractCanonicalParagraphText,
+  extractDocumentPartsEntries,
   extractFirstParagraphNumId,
   extractParagraphIdFromOoxml,
+  extractParagraphRevisionSegments,
   extractReplacementNodesFromOoxml,
   findContainingWordElement,
   findParagraphByBestTextMatch,
   findParagraphByReference,
   findParagraphByStrictText,
+  findStrictTargetCandidates,
   generateTableOoxml,
   getBodyElementFromDocument,
   getDefaultAuthor,
   getDocumentParagraphNodes,
   getPackagePartName,
+  getParagraphId2 as getParagraphId,
   getParagraphListInfo,
   getParagraphText,
   getPlatform,
+  getTrackedChangeAuthors,
   hasListItems,
   inferNumberingStyleFromMarker,
   inferTableReplacementParagraphBlock,
@@ -10239,12 +12615,15 @@ export {
   injectCommentsIntoOoxml,
   injectCommentsIntoPackage2 as injectCommentsIntoPackage,
   insertBodyElementBeforeSectPr,
+  inspectDocumentParts,
   isLikelyStructuredTableSourceParagraph,
   isMarkdownTableText,
+  isNodeVisibleInRevisionView,
   mergeNumberingXmlBySchemaOrder,
   normalizeBodySectionOrderStandalone,
   normalizeContentEscapesForRouting,
   normalizeListItemsWithLevels,
+  normalizeOpcEntryName,
   normalizeWhitespaceForTargeting,
   overwriteParagraphNumIds,
   parseMarkdownListContent,
@@ -10252,8 +12631,11 @@ export {
   parseOoxmlSafe,
   parseParagraphReference,
   planListInsertionOnlyEdit,
+  planStructuredReplacement,
   preprocessMarkdown,
+  readCanonicalRunText,
   reconcileMarkdownTableOoxml,
+  reconcileReceiptsAgainstOutput,
   recordSingleLineListFallbackExplicitSequence,
   rejectTrackedChangesInOoxml,
   remapNumberingPayloadForDocument,
@@ -10278,6 +12660,7 @@ export {
   synthesizeTableMarkdownFromMultilineCellEdit,
   validateDocxPackage,
   validateRedlineOoxml,
+  validateRevisionToken,
   wrapInDocumentFragment
 };
 //# sourceMappingURL=docx-redline-js.esm.js.map