@ansonlai/docx-redline-js 0.1.3 → 0.1.6

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

@@ -1,4 +1,4 @@
-// @ansonlai/docx-redline-js v0.1.3 — https://github.com/AnsonLai/docx-redline-js
+// @ansonlai/docx-redline-js v0.1.6 — https://github.com/AnsonLai/docx-redline-js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -1797,6 +1797,23 @@ function createRevisionMetadata(author) {
     date: getRevisionTimestamp()
   };
 }
+function seedRevisionIdsFromDocument(xmlDoc) {
+  let maxFound = -1;
+  const elements = Array.from(xmlDoc?.getElementsByTagName?.("*") || []);
+  for (const element of elements) {
+    for (const attr of Array.from(element.attributes || [])) {
+      if ((attr.localName || "").toLowerCase() !== "id") continue;
+      const parsed = Number.parseInt(attr.value, 10);
+      if (Number.isFinite(parsed)) {
+        maxFound = Math.max(maxFound, parsed);
+      }
+    }
+  }
+  if (maxFound >= revisionIdCounter) {
+    revisionIdCounter = maxFound + 1;
+  }
+  return revisionIdCounter;
+}
 
 // core/paragraph-offset-policy.js
 var PARAGRAPH_BOUNDARY_TEXT = "\n";
@@ -2016,6 +2033,26 @@ function getNodeHandlers(runModel) {
     }
     return { offset, text: "" };
   });
+  handlers.set("moveFrom", (child, offset) => {
+    const deletionEntry = processDeletion(child, offset);
+    if (deletionEntry) {
+      runModel.push(deletionEntry);
+    }
+    return { offset, text: "" };
+  });
+  handlers.set("moveTo", (child, offset) => processNodeRecursive(child, offset, runModel));
+  for (const markerName of ["moveFromRangeStart", "moveFromRangeEnd", "moveToRangeStart", "moveToRangeEnd"]) {
+    handlers.set(markerName, (child, offset) => {
+      runModel.push({
+        kind: RunKind.BOOKMARK,
+        nodeXml: serializeXml(child),
+        startOffset: offset,
+        endOffset: offset,
+        text: ""
+      });
+      return { offset, text: "" };
+    });
+  }
   handlers.set("bookmarkStart", (child, offset) => {
     runModel.push({
       kind: RunKind.BOOKMARK,
@@ -2127,9 +2164,13 @@ function processDeletion(delElement, offset) {
 function ingestTableToVirtualGrid(tableNode) {
   const tblGrid = getFirstElementByTagNS(tableNode, NS_W, "tblGrid");
   const gridCols = tblGrid ? getElementsByTagNS(tblGrid, NS_W, "gridCol") : [];
-  const colCount = gridCols.length;
-  const trElements = getElementsByTagNS(tableNode, NS_W, "tr");
+  const trElements = getElementsByTagNSOrTag(tableNode, NS_W, "tr");
   const rowCount = trElements.length;
+  const inferredColCount = trElements.reduce((max, tr) => {
+    const tcElements = getElementsByTagNSOrTag(tr, NS_W, "tc");
+    return Math.max(max, tcElements.length);
+  }, 0);
+  const colCount = gridCols.length || inferredColCount;
   const grid = Array.from(
     { length: rowCount },
     () => Array.from({ length: colCount }, () => null)
@@ -2138,7 +2179,7 @@ function ingestTableToVirtualGrid(tableNode) {
   const vMergeOrigins = /* @__PURE__ */ new Map();
   for (let rowIdx = 0; rowIdx < trElements.length; rowIdx++) {
     const tr = trElements[rowIdx];
-    const tcElements = getElementsByTagNS(tr, NS_W, "tc");
+    const tcElements = getElementsByTagNSOrTag(tr, NS_W, "tc");
     let gridCol = 0;
     for (let tcIdx = 0; tcIdx < tcElements.length; tcIdx++) {
       const tc = tcElements[tcIdx];
@@ -3243,8 +3284,7 @@ var NumberingService = class {
 // services/table-reconciliation.js
 function generateTableOoxml(tableData, options = {}) {
   const { generateRedlines = false, author = "AI" } = options;
-  const date = getRevisionTimestamp();
-  const revId = generateRedlines ? getNextRevisionId() : null;
+  const tableInsertMeta = generateRedlines ? createRevisionMetadata(author) : null;
   const numCols = tableData.headers?.length || (tableData.rows?.[0]?.length || 1);
   const tblPr = `
         <w:tblPr>
@@ -3287,8 +3327,8 @@ function generateTableOoxml(tableData, options = {}) {
     rowsXml += `<w:tr>${trPr}${cellsXml}</w:tr>`;
   }
   let tableXml = `<w:tbl>${tblPr}${tblGrid}${rowsXml}</w:tbl>`;
-  if (generateRedlines && revId) {
-    tableXml = `<w:ins w:id="${revId}" w:author="${escapeXml(author)}" w:date="${date}">${tableXml}</w:ins>`;
+  if (tableInsertMeta) {
+    tableXml = `<w:ins w:id="${tableInsertMeta.id}" w:author="${escapeXml(tableInsertMeta.author)}" w:date="${tableInsertMeta.date}">${tableXml}</w:ins>`;
   }
   return tableXml;
 }
@@ -3931,6 +3971,55 @@ 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";
+  }
+  return "fragment";
+}
+function withOoxmlSourceType(result) {
+  if (!result || typeof result !== "object" || result.sourceType || typeof result.oxml !== "string") {
+    return result;
+  }
+  return { ...result, sourceType: classifyOoxmlSourceType(result.oxml) };
+}
+
 // engine/rpr-helpers.js
 var RPR_SCHEMA_ORDER = [
   "w:rStyle",
@@ -4018,28 +4107,28 @@ function _applyOverrides(xmlDoc, rPr, formatFlags, mode) {
     }
   }
   if (applyBold) {
-    const b = xmlDoc.createElement("w:b");
+    const b = createWordElement(xmlDoc, "w:b");
     b.setAttribute("w:val", mode === "add" ? "1" : "0");
     insertRPrChildInOrder(rPr, b);
-    const bCs = xmlDoc.createElement("w:bCs");
+    const bCs = createWordElement(xmlDoc, "w:bCs");
     bCs.setAttribute("w:val", mode === "add" ? "1" : "0");
     insertRPrChildInOrder(rPr, bCs);
   }
   if (applyItalic) {
-    const i = xmlDoc.createElement("w:i");
+    const i = createWordElement(xmlDoc, "w:i");
     i.setAttribute("w:val", mode === "add" ? "1" : "0");
     insertRPrChildInOrder(rPr, i);
-    const iCs = xmlDoc.createElement("w:iCs");
+    const iCs = createWordElement(xmlDoc, "w:iCs");
     iCs.setAttribute("w:val", mode === "add" ? "1" : "0");
     insertRPrChildInOrder(rPr, iCs);
   }
   if (applyUnderline) {
-    const u = xmlDoc.createElement("w:u");
+    const u = createWordElement(xmlDoc, "w:u");
     u.setAttribute("w:val", mode === "add" ? "single" : "none");
     insertRPrChildInOrder(rPr, u);
   }
   if (applyStrike) {
-    const strike = xmlDoc.createElement("w:strike");
+    const strike = createWordElement(xmlDoc, "w:strike");
     strike.setAttribute("w:val", mode === "add" ? "1" : "0");
     insertRPrChildInOrder(rPr, strike);
   }
@@ -4080,7 +4169,7 @@ function isFormattingElementEnabled(element, isUnderline) {
 
 // engine/format-extraction.js
 var NS_W3 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
-function isWordElement(node, localName) {
+function isWordElement2(node, localName) {
   if (!node || node.nodeType !== 1) return false;
   if (node.namespaceURI === NS_W3 && node.localName === localName) return true;
   const nodeName = String(node.nodeName || "");
@@ -4097,7 +4186,7 @@ function collectParagraphRuns(paragraph) {
     const node = stack.pop();
     if (!node || node.nodeType !== 1) continue;
     if (isExcludedRevisionContainer(node)) continue;
-    if (isWordElement(node, "r")) {
+    if (isWordElement2(node, "r")) {
       runs.push(node);
       continue;
     }
@@ -4132,7 +4221,7 @@ function buildTextSpansFromParagraphs(paragraphs) {
     for (const run of runs) {
       const rPr = getFirstElementByTag(run, "w:rPr");
       Array.from(run.childNodes || []).forEach((rc) => {
-        if (isWordElement(rc, "t")) {
+        if (isWordElement2(rc, "t")) {
           const text = rc.textContent || "";
           if (text.length > 0) {
             textSpans.push({
@@ -4146,7 +4235,7 @@ function buildTextSpansFromParagraphs(paragraphs) {
             });
             charOffset += text.length;
           }
-        } else if (isWordElement(rc, "br") || isWordElement(rc, "cr") || isWordElement(rc, "tab") || isWordElement(rc, "noBreakHyphen")) {
+        } else if (isWordElement2(rc, "br") || isWordElement2(rc, "cr") || isWordElement2(rc, "tab") || isWordElement2(rc, "noBreakHyphen")) {
           textSpans.push({
             charStart: charOffset,
             charEnd: charOffset + 1,
@@ -4167,7 +4256,7 @@ function buildTextSpansFromParagraphs(paragraphs) {
 function processRunForFormatting(run, paragraph, charOffset, textSpans, formatHints, pFormat = null) {
   let rPr = null;
   for (const child of Array.from(run.childNodes)) {
-    if (isWordElement(child, "rPr")) {
+    if (isWordElement2(child, "rPr")) {
       rPr = child;
       break;
     }
@@ -4182,7 +4271,7 @@ function processRunForFormatting(run, paragraph, charOffset, textSpans, formatHi
   format.hasFormatting = format.bold || format.italic || format.underline || format.strikethrough;
   let currentOffset = charOffset;
   for (const child of Array.from(run.childNodes)) {
-    if (isWordElement(child, "t")) {
+    if (isWordElement2(child, "t")) {
       const text = child.textContent || "";
       if (text.length > 0) {
         const start = currentOffset;
@@ -4220,9 +4309,9 @@ function extractFormattingFromOoxml(xmlDoc) {
     const p = paragraphs[pIndex];
     let pRPr = null;
     for (const child of Array.from(p.childNodes)) {
-      if (isWordElement(child, "pPr")) {
+      if (isWordElement2(child, "pPr")) {
         for (const pChild of Array.from(child.childNodes)) {
-          if (isWordElement(pChild, "rPr")) {
+          if (isWordElement2(pChild, "rPr")) {
             pRPr = pChild;
             break;
           }
@@ -4246,7 +4335,7 @@ function extractFormattingFromOoxml(xmlDoc) {
 
 // engine/run-builders.js
 function createTrackChange(xmlDoc, type, run, author) {
-  const wrapper = xmlDoc.createElement(type === "ins" ? "w:ins" : "w:del");
+  const wrapper = createWordElement(xmlDoc, type === "ins" ? "w:ins" : "w:del");
   const metadata = createRevisionMetadata(author);
   wrapper.setAttribute("w:id", String(metadata.id));
   wrapper.setAttribute("w:author", metadata.author);
@@ -4256,10 +4345,60 @@ 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 ensureParagraphProperties(xmlDoc, paragraph) {
+  let pPr = getDirectWordChild(paragraph, "pPr");
+  if (!pPr) {
+    pPr = createWordElement(xmlDoc, "w:pPr");
+    paragraph.insertBefore(pPr, paragraph.firstChild || null);
+  } else if (paragraph.firstChild !== pPr) {
+    paragraph.insertBefore(pPr, paragraph.firstChild || null);
+  }
+  return pPr;
+}
+function ensureParagraphMarkRunProperties(xmlDoc, pPr) {
+  let rPr = getDirectWordChild(pPr, "rPr");
+  if (!rPr) {
+    rPr = createWordElement(xmlDoc, "w:rPr");
+    pPr.appendChild(rPr);
+  } else if (pPr.lastChild !== rPr) {
+    pPr.appendChild(rPr);
+  }
+  return rPr;
+}
+function markParagraphMark(xmlDoc, paragraph, author, type) {
+  const pPr = ensureParagraphProperties(xmlDoc, paragraph);
+  const rPr = ensureParagraphMarkRunProperties(xmlDoc, pPr);
+  for (const child of Array.from(rPr.childNodes || [])) {
+    if (child.nodeType !== 1) continue;
+    if (child.localName === "ins" || child.localName === "del" || child.nodeName === "w:ins" || child.nodeName === "w:del") {
+      rPr.removeChild(child);
+    }
+  }
+  const marker = createWordElement(xmlDoc, type === "ins" ? "w:ins" : "w:del");
+  const metadata = createRevisionMetadata(author);
+  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 markParagraphMarkDeleted(xmlDoc, paragraph, author) {
+  return markParagraphMark(xmlDoc, paragraph, author, "del");
+}
 function createTextRun(xmlDoc, text, rPr, isDelete) {
-  const run = xmlDoc.createElement("w:r");
+  const run = createWordElement(xmlDoc, "w:r");
   if (rPr) run.appendChild(rPr.cloneNode(true));
-  const textEl = xmlDoc.createElement(isDelete ? "w:delText" : "w:t");
+  if (!isDelete) {
+    appendVisibleTextPieces(xmlDoc, run, text);
+    return run;
+  }
+  const textEl = createWordElement(xmlDoc, isDelete ? "w:delText" : "w:t");
   textEl.setAttribute("xml:space", "preserve");
   textEl.textContent = text;
   run.appendChild(textEl);
@@ -4296,16 +4435,45 @@ function createFormattedRuns(xmlDoc, text, baseRPr, formatHints, baseOffset, aut
   return runs;
 }
 function createTextRunWithRPrElement(xmlDoc, text, rPrElement, isDelete) {
-  const run = xmlDoc.createElement("w:r");
+  const run = createWordElement(xmlDoc, "w:r");
   if (rPrElement) run.appendChild(rPrElement);
-  const textEl = xmlDoc.createElement(isDelete ? "w:delText" : "w:t");
+  if (!isDelete) {
+    appendVisibleTextPieces(xmlDoc, run, text);
+    return run;
+  }
+  const textEl = createWordElement(xmlDoc, isDelete ? "w:delText" : "w:t");
   textEl.setAttribute("xml:space", "preserve");
   textEl.textContent = text;
   run.appendChild(textEl);
   return run;
 }
+function appendVisibleTextPieces(xmlDoc, run, text) {
+  const source = String(text || "");
+  const parts = source.split(/(\t|\n|\u2011)/);
+  for (const part of parts) {
+    if (!part) continue;
+    if (part === "	") {
+      run.appendChild(createWordElement(xmlDoc, "w:tab"));
+      continue;
+    }
+    if (part === "\n") {
+      run.appendChild(createWordElement(xmlDoc, "w:br"));
+      continue;
+    }
+    if (part === "\u2011") {
+      run.appendChild(createWordElement(xmlDoc, "w:noBreakHyphen"));
+      continue;
+    }
+    const textEl = createWordElement(xmlDoc, "w:t");
+    if (/^\s|\s$/.test(part)) {
+      textEl.setAttribute("xml:space", "preserve");
+    }
+    textEl.textContent = part;
+    run.appendChild(textEl);
+  }
+}
 function injectFormattingToRPr(xmlDoc, baseRPr, format, author, generateRedlines) {
-  const rPr = xmlDoc.createElement("w:rPr");
+  const rPr = createWordElement(xmlDoc, "w:rPr");
   if (baseRPr) {
     Array.from(baseRPr.childNodes).forEach((child) => {
       if (!["w:b", "w:bCs", "w:i", "w:iCs", "w:u", "w:strike", "w:rPrChange"].includes(child.nodeName)) {
@@ -4318,7 +4486,7 @@ function injectFormattingToRPr(xmlDoc, baseRPr, format, author, generateRedlines
     createRPrChange(xmlDoc, rPr, author, baseRPr);
   }
   const syncElement = (tagName, isOn, valOn = null, valOff = "0") => {
-    const el = xmlDoc.createElement(tagName);
+    const el = createWordElement(xmlDoc, tagName);
     if (isOn) {
       if (valOn) el.setAttribute("w:val", valOn);
     } else if (valOff) {
@@ -4348,11 +4516,12 @@ function injectFormattingToRPr(xmlDoc, baseRPr, format, author, generateRedlines
   return rPr;
 }
 function snapshotAndAttachRPrChange(xmlDoc, rPr, author, dateStr, sourceNode) {
-  const rPrChange = xmlDoc.createElement("w:rPrChange");
-  rPrChange.setAttribute("w:id", String(createRevisionMetadata(author).id));
-  rPrChange.setAttribute("w:author", author);
-  rPrChange.setAttribute("w:date", dateStr);
-  const previousRPr = xmlDoc.createElement("w:rPr");
+  const rPrChange = createWordElement(xmlDoc, "w:rPrChange");
+  const metadata = createRevisionMetadata(author);
+  rPrChange.setAttribute("w:id", String(metadata.id));
+  rPrChange.setAttribute("w:author", metadata.author);
+  rPrChange.setAttribute("w:date", dateStr || metadata.date);
+  const previousRPr = createWordElement(xmlDoc, "w:rPr");
   const source = sourceNode || rPr;
   Array.from(source.childNodes).forEach((child) => {
     if (child.nodeName !== "w:rPrChange") {
@@ -4368,12 +4537,12 @@ function snapshotAndAttachRPrChange(xmlDoc, rPr, author, dateStr, sourceNode) {
   return rPrChange;
 }
 function createRPrChange(xmlDoc, rPr, author, previousRPrArg) {
-  snapshotAndAttachRPrChange(xmlDoc, rPr, author, getRevisionTimestamp(), previousRPrArg || rPr);
+  snapshotAndAttachRPrChange(xmlDoc, rPr, author, null, previousRPrArg || rPr);
 }
 
 // engine/format-paragraph-targeting.js
 var NS_W4 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
-function isWordElement2(node, localName) {
+function isWordElement3(node, localName) {
   if (!node || node.nodeType !== 1) return false;
   if (node.namespaceURI === NS_W4 && node.localName === localName) return true;
   const nodeName = String(node.nodeName || "");
@@ -4475,7 +4644,7 @@ function findTargetParagraphInfo(paragraphInfos, originalText) {
 function getContainingParagraph(node) {
   let current = node;
   while (current) {
-    if (isWordElement2(current, "p")) return current;
+    if (isWordElement3(current, "p")) return current;
     current = current.parentNode;
   }
   return null;
@@ -4486,13 +4655,13 @@ function buildParagraphTextFromSpans(spans) {
   for (const span of spans) {
     if (!span || !span.textElement) continue;
     const textElement = span.textElement;
-    if (isWordElement2(textElement, "t")) {
+    if (isWordElement3(textElement, "t")) {
       text += span.textElement.textContent || "";
-    } else if (isWordElement2(textElement, "tab")) {
+    } else if (isWordElement3(textElement, "tab")) {
       text += "	";
-    } else if (isWordElement2(textElement, "br") || isWordElement2(textElement, "cr")) {
+    } else if (isWordElement3(textElement, "br") || isWordElement3(textElement, "cr")) {
       text += "\n";
-    } else if (isWordElement2(textElement, "noBreakHyphen")) {
+    } else if (isWordElement3(textElement, "noBreakHyphen")) {
       text += "\u2011";
     }
   }
@@ -4556,7 +4725,7 @@ function splitSpanAtOffset(xmlDoc, span, absoluteOffset) {
 
 // engine/format-application.js
 var NS_W5 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
-function isWordElement3(node, localName) {
+function isWordElement4(node, localName) {
   if (!node || node.nodeType !== 1) return false;
   if (node.namespaceURI === NS_W5 && node.localName === localName) return true;
   const nodeName = String(node.nodeName || "");
@@ -4586,7 +4755,6 @@ function normalizePrecomputedFormatContext(precomputedContext) {
 function applyFormatRemovalAsSurgicalReplacement(xmlDoc, textSpans, existingFormatHints, serializer, author, generateRedlines = true) {
   let hasAnyChanges = false;
   const processedRuns = /* @__PURE__ */ new Set();
-  const dateStr = getRevisionTimestamp();
   log(`[OxmlEngine] Surgical format removal: ${existingFormatHints.length} hints to process (using w:rPrChange)`);
   for (const hint of existingFormatHints) {
     const run = hint.run;
@@ -4596,11 +4764,11 @@ function applyFormatRemovalAsSurgicalReplacement(xmlDoc, textSpans, existingForm
     log("[OxmlEngine] Processing run for surgical format removal, format:", hint.format);
     let rPr = getFirstElementByTag(run, "w:rPr");
     if (!rPr) {
-      rPr = xmlDoc.createElement("w:rPr");
+      rPr = createWordElement(xmlDoc, "w:rPr");
       run.insertBefore(rPr, run.firstChild);
     }
     if (generateRedlines) {
-      snapshotAndAttachRPrChange(xmlDoc, rPr, author || getDefaultAuthor(), dateStr);
+      snapshotAndAttachRPrChange(xmlDoc, rPr, author || getDefaultAuthor());
     }
     applyFormatOverridesToRPr(xmlDoc, rPr, hint.format);
     hasAnyChanges = true;
@@ -4626,7 +4794,7 @@ function applyFormatAdditionsAsSurgicalReplacement(xmlDoc, textSpans, formatHint
   const orderedSpans = currentSpans.slice().sort((a, b) => a.charStart - b.charStart || a.charEnd - b.charEnd);
   const getOverlappingHints = createFormatHintOverlapLookup(formatHints);
   for (const span of orderedSpans) {
-    if (!span || !span.textElement || !isWordElement3(span.textElement, "t")) continue;
+    if (!span || !span.textElement || !isWordElement4(span.textElement, "t")) continue;
     const applicableHints = getOverlappingHints(span.charStart, span.charEnd);
     if (applicableHints.length === 0) continue;
     const mergedDesiredFormat = mergeFormats(...applicableHints.map((h) => h.format));
@@ -4746,7 +4914,7 @@ function createFormatHintOverlapLookup(formatHints) {
 var W14_NS = "http://schemas.microsoft.com/office/word/2010/wordml";
 function detectTableCellContext(xmlDoc, originalText, options = {}) {
   const { targetParagraphId = null } = options;
-  const tables = getElementsByTag(xmlDoc, "w:tbl");
+  const tables = getElementsByTagNSOrTag(xmlDoc, NS_W, "tbl");
   if (tables.length === 0) {
     return { hasTableWrapper: false, isTableCellParagraph: false, paragraphs: [], paragraph: null, tableElement: null };
   }
@@ -4754,7 +4922,7 @@ function detectTableCellContext(xmlDoc, originalText, options = {}) {
   const paragraphsInCells = allParagraphs.filter((p) => {
     let parent = p.parentNode;
     while (parent) {
-      if (parent.nodeName === "w:tc") return true;
+      if (isWordElement(parent, "tc")) return true;
       parent = parent.parentNode;
     }
     return false;
@@ -4777,7 +4945,7 @@ function detectTableCellContext(xmlDoc, originalText, options = {}) {
     const normalizedTarget = originalText.trim();
     if (!targetParagraph) {
       for (const p of paragraphsInCells) {
-        const textNodes = getElementsByTag(p, "w:t");
+        const textNodes = getElementsByTagNSOrTag(p, NS_W, "t");
         let paragraphText = "";
         for (const t of textNodes) {
           paragraphText += t.textContent || "";
@@ -4824,89 +4992,247 @@ function getParagraphId(paragraph) {
   return paragraph.getAttribute("w14:paraId") || paragraph.getAttribute("w:paraId") || paragraph.getAttribute("paraId") || null;
 }
 
-// engine/surgical-mode.js
-function applySurgicalMode(xmlDoc, originalText, modifiedText, serializer, author, formatHints, generateRedlines = true, targetParagraph = null) {
+// engine/surgical-spans.js
+function getRunChildText(child) {
+  if (isWordElement(child, "t")) return child.textContent || "";
+  if (isWordElement(child, "br") || isWordElement(child, "cr")) return "\n";
+  if (isWordElement(child, "tab")) return "	";
+  if (isWordElement(child, "noBreakHyphen")) return "\u2011";
+  return "";
+}
+function isTextLikeRunChild(child) {
+  return isWordElement(child, "t") || isWordElement(child, "br") || isWordElement(child, "cr") || isWordElement(child, "tab") || isWordElement(child, "noBreakHyphen");
+}
+function buildSurgicalTextSpans(paragraphs) {
   let fullText = "";
   const textSpans = [];
-  const allParagraphs = targetParagraph ? [targetParagraph] : getDocumentParagraphs(xmlDoc);
-  allParagraphs.forEach((p, pIndex) => {
-    const container = p.parentNode;
-    for (let child = p.firstChild; child; child = child.nextSibling) {
-      if (child.nodeName === "w:r") {
-        const runResult = processRunElement(child, p, container, fullText.length, textSpans);
-        fullText += runResult.text;
-      } else if (child.nodeName === "w:hyperlink") {
+  paragraphs.forEach((paragraph, paragraphIndex) => {
+    const container = paragraph.parentNode;
+    for (let child = paragraph.firstChild; child; child = child.nextSibling) {
+      if (isWordElement(child, "r")) {
+        fullText += processRunElement(child, paragraph, container, fullText.length, textSpans).text;
+      } else if (isWordElement(child, "hyperlink")) {
         for (let hc = child.firstChild; hc; hc = hc.nextSibling) {
-          if (hc.nodeName === "w:r") {
-            const runResult = processRunElement(hc, p, container, fullText.length, textSpans);
-            fullText += runResult.text;
+          if (isWordElement(hc, "r")) {
+            fullText += processRunElement(hc, paragraph, container, fullText.length, textSpans).text;
           }
         }
       }
     }
-    fullText = appendParagraphBoundary(fullText, pIndex, allParagraphs.length);
+    fullText = appendParagraphBoundary(fullText, paragraphIndex, paragraphs.length);
   });
-  const diffs = computeWordDiffs(fullText, modifiedText);
-  const spanIndex = buildSpanIndex(textSpans);
-  let originalPos = 0;
-  let newPos = 0;
-  const processedSpans = /* @__PURE__ */ new Set();
-  for (const [op, text] of diffs) {
-    if (op === 0) {
-      const len = text.length;
-      const startPos = originalPos;
-      const endPos = originalPos + len;
-      forEachOverlappingSpan(spanIndex, startPos, endPos, (span) => {
-        const overlapStartOriginal = Math.max(span.charStart, startPos);
-        const overlapEndOriginal = Math.min(span.charEnd, endPos);
-        const segmentLen = overlapEndOriginal - overlapStartOriginal;
-        const relativeOffset = overlapStartOriginal - startPos;
-        const overlapStartNew = newPos + relativeOffset;
-        const overlapEndNew = overlapStartNew + segmentLen;
-        const applicableHints = getApplicableFormatHints(formatHints, overlapStartNew, overlapEndNew);
-        reconcileFormattingForTextSpan(xmlDoc, span, overlapStartOriginal, overlapEndOriginal, applicableHints, author, generateRedlines);
+  return { fullText, textSpans };
+}
+function processRunElement(run, paragraph, container, currentOffset, textSpans) {
+  const rPr = getFirstElementByTag(run, "w:rPr");
+  let localOffset = currentOffset;
+  const textParts = [];
+  for (let child = run.firstChild; child; child = child.nextSibling) {
+    if (isWordElement(child, "t")) {
+      const text = child.textContent || "";
+      if (text.length === 0) continue;
+      textSpans.push({
+        charStart: localOffset,
+        charEnd: localOffset + text.length,
+        textElement: child,
+        runElement: run,
+        paragraph,
+        container,
+        rPr
       });
-      originalPos += len;
-      newPos += len;
-    } else if (op === -1) {
-      processDelete(xmlDoc, spanIndex, originalPos, originalPos + text.length, processedSpans, author, generateRedlines);
-      originalPos += text.length;
-    } else if (op === 1) {
-      const textWithoutNewlines = text.replace(/\n/g, " ");
-      if (textWithoutNewlines.trim().length > 0) {
-        processInsert(xmlDoc, spanIndex, originalPos, textWithoutNewlines, processedSpans, author, formatHints, newPos, generateRedlines);
-      }
-      newPos += text.length;
+      localOffset += text.length;
+      textParts.push(text);
+    } else if (isTextLikeRunChild(child)) {
+      const text = getRunChildText(child);
+      textSpans.push({
+        charStart: localOffset,
+        charEnd: localOffset + 1,
+        textElement: child,
+        runElement: run,
+        paragraph,
+        container,
+        rPr
+      });
+      localOffset += 1;
+      textParts.push(text);
     }
   }
-  return { oxml: serializer.serializeToString(xmlDoc), hasChanges: true };
+  return { text: textParts.join("") };
+}
+function buildSpanIndex(textSpans) {
+  const spans = textSpans.slice().sort((a, b) => a.charStart - b.charStart || a.charEnd - b.charEnd);
+  const starts = spans.map((span) => span.charStart);
+  const ends = spans.map((span) => span.charEnd);
+  return { spans, starts, ends };
+}
+function forEachOverlappingSpan(spanIndex, startPos, endPos, callback) {
+  if (endPos <= startPos || spanIndex.spans.length === 0) {
+    return;
+  }
+  let index = upperBound(spanIndex.ends, startPos);
+  while (index < spanIndex.spans.length) {
+    const span = spanIndex.spans[index];
+    if (span.charStart >= endPos) {
+      break;
+    }
+    callback(span);
+    index++;
+  }
+}
+function findContainingSpan(spanIndex, pos) {
+  if (spanIndex.spans.length === 0) return null;
+  const index = upperBound(spanIndex.starts, pos) - 1;
+  if (index < 0) return null;
+  const span = spanIndex.spans[index];
+  return pos >= span.charStart && pos < span.charEnd ? span : null;
+}
+function findFirstSpanEndingAt(spanIndex, pos) {
+  const index = lowerBound(spanIndex.ends, pos);
+  if (index < spanIndex.spans.length && spanIndex.ends[index] === pos) {
+    return spanIndex.spans[index];
+  }
+  return null;
+}
+function findLastSpanEndingBeforeOrAt(spanIndex, pos) {
+  const index = upperBound(spanIndex.ends, pos) - 1;
+  if (index >= 0) {
+    return spanIndex.spans[index];
+  }
+  return null;
+}
+function upperBound(values, target) {
+  let left = 0;
+  let right = values.length;
+  while (left < right) {
+    const middle = left + right >> 1;
+    if (values[middle] <= target) {
+      left = middle + 1;
+    } else {
+      right = middle;
+    }
+  }
+  return left;
 }
+function lowerBound(values, target) {
+  let left = 0;
+  let right = values.length;
+  while (left < right) {
+    const middle = left + right >> 1;
+    if (values[middle] < target) {
+      left = middle + 1;
+    } else {
+      right = middle;
+    }
+  }
+  return left;
+}
+
+// engine/surgical-run-splitting.js
+function getRunContentPieces(runElement) {
+  const pieces = [];
+  let offset = 0;
+  for (const child of Array.from(runElement.childNodes || [])) {
+    if (isWordElement(child, "rPr")) continue;
+    if (!isTextLikeRunChild(child)) continue;
+    const text = getRunChildText(child);
+    if (text.length === 0) continue;
+    pieces.push({
+      node: child,
+      start: offset,
+      end: offset + text.length,
+      text
+    });
+    offset += text.length;
+  }
+  return pieces;
+}
+function getRunTextLength(pieces) {
+  if (pieces.length === 0) return 0;
+  return pieces[pieces.length - 1].end;
+}
+function sliceRunPieces(xmlDoc, pieces, start, end, asDeletedText) {
+  const sliced = [];
+  if (end <= start) return sliced;
+  pieces.forEach((piece) => {
+    const overlapStart = Math.max(start, piece.start);
+    const overlapEnd = Math.min(end, piece.end);
+    if (overlapEnd <= overlapStart) return;
+    const localStart = overlapStart - piece.start;
+    const localEnd = overlapEnd - piece.start;
+    const text = piece.text.slice(localStart, localEnd);
+    sliced.push(cloneRunPiece(xmlDoc, piece.node, text, asDeletedText));
+  });
+  return sliced;
+}
+function createRunFromPieces(xmlDoc, pieces, rPr) {
+  const run = createWordElement(xmlDoc, "w:r");
+  if (rPr) run.appendChild(rPr.cloneNode(true));
+  pieces.forEach((piece) => run.appendChild(piece));
+  return run;
+}
+function insertRunPiecesBefore(xmlDoc, parent, referenceNode, pieces, rPr) {
+  if (pieces.length === 0) return null;
+  const run = createRunFromPieces(xmlDoc, pieces, rPr);
+  parent.insertBefore(run, referenceNode);
+  return run;
+}
+function cloneRunPiece(xmlDoc, sourceNode, text, asDeletedText) {
+  if (asDeletedText) {
+    const delText = createWordElement(xmlDoc, "w:delText");
+    delText.setAttribute("xml:space", "preserve");
+    delText.textContent = text;
+    return delText;
+  }
+  if (isWordElement(sourceNode, "t")) {
+    const textNode2 = sourceNode.cloneNode(false);
+    textNode2.textContent = text;
+    if (/^\s|\s$/.test(text)) {
+      textNode2.setAttribute("xml:space", "preserve");
+    }
+    return textNode2;
+  }
+  if (text === "\n" && (isWordElement(sourceNode, "br") || isWordElement(sourceNode, "cr"))) {
+    return sourceNode.cloneNode(true);
+  }
+  if (text === "	" && isWordElement(sourceNode, "tab")) {
+    return sourceNode.cloneNode(true);
+  }
+  if (text === "\u2011" && isWordElement(sourceNode, "noBreakHyphen")) {
+    return sourceNode.cloneNode(true);
+  }
+  const textNode = createWordElement(xmlDoc, "w:t");
+  textNode.setAttribute("xml:space", "preserve");
+  textNode.textContent = text;
+  return textNode;
+}
+
+// engine/surgical-diff-application.js
 function reconcileFormattingForTextSpan(xmlDoc, span, start, end, applicableHints, author, generateRedlines) {
   const desiredFormat = {};
   if (applicableHints.length > 0) {
     applicableHints.forEach((h) => Object.assign(desiredFormat, h.format));
   }
   const rPr = span.rPr;
-  const hasElement = (tagName) => {
+  const hasElement = (localName) => {
     if (!rPr) return false;
     for (let node = rPr.firstChild; node; node = node.nextSibling) {
-      if (node.nodeName === tagName) {
+      if (isWordElement(node, localName)) {
         return true;
       }
     }
     return false;
   };
   const existingFormat = {
-    bold: hasElement("w:b"),
-    italic: hasElement("w:i"),
-    underline: hasElement("w:u"),
-    strikethrough: hasElement("w:strike")
+    bold: hasElement("b"),
+    italic: hasElement("i"),
+    underline: hasElement("u"),
+    strikethrough: hasElement("strike")
   };
   const formatsToCheck = ["bold", "italic", "underline", "strikethrough"];
   const changesNeeded = formatsToCheck.some((f) => !!desiredFormat[f] !== existingFormat[f]);
-  if (!changesNeeded) return;
+  if (!changesNeeded) return false;
   const parent = span.runElement.parentNode;
-  if (!parent) return;
+  if (!parent) return false;
   const fullText = span.textElement.textContent || "";
   const runStart = span.charStart;
   const localStart = start - runStart;
@@ -4926,109 +5252,54 @@ function reconcileFormattingForTextSpan(xmlDoc, span, start, end, applicableHint
     parent.insertBefore(afterRun, span.runElement);
   }
   parent.removeChild(span.runElement);
+  return true;
 }
-function processRunElement(r, p, container, currentOffset, textSpans) {
-  const rPr = getFirstElementByTag(r, "w:rPr");
-  let localOffset = currentOffset;
-  const textParts = [];
-  for (let rc = r.firstChild; rc; rc = rc.nextSibling) {
-    if (rc.nodeName === "w:t") {
-      const text = rc.textContent || "";
-      if (text.length > 0) {
-        textSpans.push({
-          charStart: localOffset,
-          charEnd: localOffset + text.length,
-          textElement: rc,
-          runElement: r,
-          paragraph: p,
-          container,
-          rPr
-        });
-        localOffset += text.length;
-        textParts.push(text);
-      }
-    } else if (rc.nodeName === "w:br" || rc.nodeName === "w:cr") {
-      textSpans.push({
-        charStart: localOffset,
-        charEnd: localOffset + 1,
-        textElement: rc,
-        runElement: r,
-        paragraph: p,
-        container,
-        rPr
-      });
-      localOffset += 1;
-      textParts.push("\n");
-    } else if (rc.nodeName === "w:tab") {
-      textSpans.push({
-        charStart: localOffset,
-        charEnd: localOffset + 1,
-        textElement: rc,
-        runElement: r,
-        paragraph: p,
-        container,
-        rPr
-      });
-      localOffset += 1;
-      textParts.push("	");
-    } else if (rc.nodeName === "w:noBreakHyphen") {
-      textSpans.push({
-        charStart: localOffset,
-        charEnd: localOffset + 1,
-        textElement: rc,
-        runElement: r,
-        paragraph: p,
-        container,
-        rPr
-      });
-      localOffset += 1;
-      textParts.push("\u2011");
-    }
-  }
-  return { nextOffset: localOffset, text: textParts.join("") };
-}
-function processDelete(xmlDoc, spanIndex, startPos, endPos, processedSpans, author, generateRedlines) {
+function processDelete(xmlDoc, spanIndex, startPos, endPos, author, generateRedlines) {
+  const spans = [];
   forEachOverlappingSpan(spanIndex, startPos, endPos, (span) => {
-    if (processedSpans.has(span.textElement)) return;
-    const deleteStart = Math.max(0, startPos - span.charStart);
-    const deleteEnd = Math.min(span.charEnd - span.charStart, endPos - span.charStart);
-    const originalText = span.textElement.textContent || "";
-    const beforeText = originalText.substring(0, deleteStart);
-    const deletedText = originalText.substring(deleteStart, deleteEnd);
-    const afterText = originalText.substring(deleteEnd);
-    if (deletedText.length === 0) return;
-    const parent = span.runElement.parentNode;
+    spans.push(span);
+  });
+  if (spans.length === 0) return false;
+  const spansByRun = /* @__PURE__ */ new Map();
+  spans.forEach((span) => {
+    if (!span.runElement?.parentNode) return;
+    if (!spansByRun.has(span.runElement)) spansByRun.set(span.runElement, []);
+    spansByRun.get(span.runElement).push(span);
+  });
+  let changed = false;
+  spansByRun.forEach((runSpans, runElement) => {
+    const parent = runElement.parentNode;
     if (!parent) return;
-    if (beforeText.length === 0 && afterText.length === 0) {
-      const delRun = createTextRun(xmlDoc, deletedText, span.rPr, true);
-      if (generateRedlines) {
-        const delWrapper = createTrackChange(xmlDoc, "del", delRun, author);
-        parent.insertBefore(delWrapper, span.runElement);
-      }
-      parent.removeChild(span.runElement);
-    } else {
-      const oldRun = span.runElement;
-      if (beforeText.length > 0) {
-        const beforeRun = createTextRun(xmlDoc, beforeText, span.rPr, false);
-        parent.insertBefore(beforeRun, oldRun);
-      }
-      const delRun = createTextRun(xmlDoc, deletedText, span.rPr, true);
-      if (generateRedlines) {
-        const delWrapper = createTrackChange(xmlDoc, "del", delRun, author);
-        parent.insertBefore(delWrapper, oldRun);
-      }
-      if (afterText.length > 0) {
-        const afterRun = createTextRun(xmlDoc, afterText, span.rPr, false);
-        parent.insertBefore(afterRun, oldRun);
-        span.runElement = afterRun;
-        span.textElement = getFirstElementByTag(afterRun, "w:t") || getFirstElementByTag(afterRun, "t");
-      }
-      parent.removeChild(oldRun);
-    }
-    processedSpans.add(span.textElement);
+    const pieces = getRunContentPieces(runElement);
+    if (pieces.length === 0) return;
+    let deleteStart = Infinity;
+    let deleteEnd = -Infinity;
+    runSpans.forEach((span) => {
+      const piece = pieces.find((candidate) => candidate.node === span.textElement);
+      if (!piece) return;
+      const spanDeleteStart = Math.max(0, startPos - span.charStart);
+      const spanDeleteEnd = Math.min(span.charEnd - span.charStart, endPos - span.charStart);
+      if (spanDeleteEnd <= spanDeleteStart) return;
+      deleteStart = Math.min(deleteStart, piece.start + spanDeleteStart);
+      deleteEnd = Math.max(deleteEnd, piece.start + spanDeleteEnd);
+    });
+    if (!Number.isFinite(deleteStart) || deleteEnd <= deleteStart) return;
+    const beforePieces = sliceRunPieces(xmlDoc, pieces, 0, deleteStart, false);
+    const deletedPieces = sliceRunPieces(xmlDoc, pieces, deleteStart, deleteEnd, true);
+    const afterPieces = sliceRunPieces(xmlDoc, pieces, deleteEnd, getRunTextLength(pieces), false);
+    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);
+      parent.insertBefore(delWrapper, runElement);
+    }
+    insertRunPiecesBefore(xmlDoc, parent, runElement, afterPieces, runSpans[0].rPr);
+    parent.removeChild(runElement);
+    changed = true;
   });
+  return changed;
 }
-function processInsert(xmlDoc, spanIndex, pos, text, processedSpans, author, formatHints = [], insertOffset = 0, generateRedlines = true) {
+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);
@@ -5039,99 +5310,99 @@ function processInsert(xmlDoc, spanIndex, pos, text, processedSpans, author, for
   if (!targetSpan && spanIndex.spans.length > 0) {
     targetSpan = spanIndex.spans[spanIndex.spans.length - 1];
   }
-  if (targetSpan) {
-    const applicableHints = getApplicableFormatHints(formatHints, insertOffset, insertOffset + text.length);
-    const baseRPr = targetSpan.rPr;
-    const parent = targetSpan.runElement.parentNode;
-    if (parent) {
-      const referenceNode = pos === targetSpan.charStart ? targetSpan.runElement : targetSpan.runElement.nextSibling;
-      if (applicableHints.length === 0) {
-        const insRun = createTextRun(xmlDoc, text, baseRPr, false);
-        if (generateRedlines) {
-          const insWrapper = createTrackChange(xmlDoc, "ins", insRun, author);
-          parent.insertBefore(insWrapper, referenceNode);
-        } else {
-          parent.insertBefore(insRun, referenceNode);
-        }
-      } else {
-        const runs = createFormattedRuns(xmlDoc, text, baseRPr, applicableHints, insertOffset, author, generateRedlines);
-        if (generateRedlines) {
-          const insWrapper = createTrackChange(xmlDoc, "ins", null, author);
-          runs.forEach((run) => insWrapper.appendChild(run));
-          parent.insertBefore(insWrapper, referenceNode);
-        } else {
-          runs.forEach((run) => parent.insertBefore(run, referenceNode));
-        }
-      }
-    }
-  }
-}
-function buildSpanIndex(textSpans) {
-  const spans = textSpans.slice().sort((a, b) => a.charStart - b.charStart || a.charEnd - b.charEnd);
-  const starts = spans.map((span) => span.charStart);
-  const ends = spans.map((span) => span.charEnd);
-  return { spans, starts, ends };
-}
-function upperBound(values, target) {
-  let left = 0;
-  let right = values.length;
-  while (left < right) {
-    const middle = left + right >> 1;
-    if (values[middle] <= target) {
-      left = middle + 1;
-    } else {
-      right = middle;
-    }
+  if (!targetSpan) {
+    if (!fallbackParagraph) return false;
+    insertTextRuns(xmlDoc, fallbackParagraph, null, text, null, author, formatHints, insertOffset, generateRedlines);
+    return true;
   }
-  return left;
-}
-function lowerBound(values, target) {
-  let left = 0;
-  let right = values.length;
-  while (left < right) {
-    const middle = left + right >> 1;
-    if (values[middle] < target) {
-      left = middle + 1;
-    } else {
-      right = middle;
-    }
+  const parent = targetSpan.runElement.parentNode;
+  if (!parent) {
+    if (!fallbackParagraph) return false;
+    insertTextRuns(xmlDoc, fallbackParagraph, null, text, targetSpan.rPr, author, formatHints, insertOffset, generateRedlines);
+    return true;
   }
-  return left;
-}
-function forEachOverlappingSpan(spanIndex, startPos, endPos, callback) {
-  if (endPos <= startPos || spanIndex.spans.length === 0) {
-    return;
+  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;
   }
-  let index = upperBound(spanIndex.ends, startPos);
-  while (index < spanIndex.spans.length) {
-    const span = spanIndex.spans[index];
-    if (span.charStart >= endPos) {
-      break;
+  const referenceNode = pos <= targetSpan.charStart ? targetSpan.runElement : targetSpan.runElement.nextSibling;
+  insertTextRuns(xmlDoc, parent, referenceNode, text, targetSpan.rPr, author, formatHints, insertOffset, generateRedlines);
+  return true;
+}
+function insertTextRuns(xmlDoc, parent, referenceNode, text, baseRPr, author, formatHints, insertOffset, generateRedlines) {
+  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);
+      parent.insertBefore(insWrapper, referenceNode);
+    } else {
+      parent.insertBefore(insRun, referenceNode);
     }
-    callback(span);
-    index++;
+    return;
   }
-}
-function findContainingSpan(spanIndex, pos) {
-  if (spanIndex.spans.length === 0) return null;
-  const index = upperBound(spanIndex.starts, pos) - 1;
-  if (index < 0) return null;
-  const span = spanIndex.spans[index];
-  return pos >= span.charStart && pos < span.charEnd ? span : null;
-}
-function findFirstSpanEndingAt(spanIndex, pos) {
-  const index = lowerBound(spanIndex.ends, pos);
-  if (index < spanIndex.spans.length && spanIndex.ends[index] === pos) {
-    return spanIndex.spans[index];
+  const runs = createFormattedRuns(xmlDoc, text, baseRPr, applicableHints, insertOffset, author, generateRedlines);
+  if (generateRedlines) {
+    const insWrapper = createTrackChange(xmlDoc, "ins", null, author);
+    runs.forEach((run) => insWrapper.appendChild(run));
+    parent.insertBefore(insWrapper, referenceNode);
+  } else {
+    runs.forEach((run) => parent.insertBefore(run, referenceNode));
   }
-  return null;
 }
-function findLastSpanEndingBeforeOrAt(spanIndex, pos) {
-  const index = upperBound(spanIndex.ends, pos) - 1;
-  if (index >= 0) {
-    return spanIndex.spans[index];
+
+// engine/surgical-mode.js
+function applySurgicalMode(xmlDoc, originalText, modifiedText, serializer, author, formatHints, generateRedlines = true, targetParagraph = null) {
+  const allParagraphs = targetParagraph ? [targetParagraph] : getDocumentParagraphs(xmlDoc);
+  const { fullText, textSpans } = buildSurgicalTextSpans(allParagraphs);
+  const diffs = computeWordDiffs(fullText, modifiedText);
+  const spanIndex = buildSpanIndex(textSpans);
+  let originalPos = 0;
+  let newPos = 0;
+  let hasChanges = false;
+  for (const [op, text] of diffs) {
+    if (op === 0) {
+      const len = text.length;
+      const startPos = originalPos;
+      const endPos = originalPos + len;
+      forEachOverlappingSpan(spanIndex, startPos, endPos, (span) => {
+        const overlapStartOriginal = Math.max(span.charStart, startPos);
+        const overlapEndOriginal = Math.min(span.charEnd, endPos);
+        const segmentLen = overlapEndOriginal - overlapStartOriginal;
+        const relativeOffset = overlapStartOriginal - startPos;
+        const overlapStartNew = newPos + relativeOffset;
+        const overlapEndNew = overlapStartNew + segmentLen;
+        const applicableHints = getApplicableFormatHints(formatHints, overlapStartNew, overlapEndNew);
+        if (reconcileFormattingForTextSpan(xmlDoc, span, overlapStartOriginal, overlapEndOriginal, applicableHints, author, generateRedlines)) {
+          hasChanges = true;
+        }
+      });
+      originalPos += len;
+      newPos += len;
+    } else if (op === -1) {
+      if (processDelete(xmlDoc, spanIndex, originalPos, originalPos + text.length, author, generateRedlines)) {
+        hasChanges = true;
+      }
+      originalPos += text.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)) {
+          hasChanges = true;
+        }
+      }
+      newPos += text.length;
+    }
   }
-  return null;
+  return withOoxmlSourceType({ oxml: serializer.serializeToString(xmlDoc), hasChanges });
 }
 
 // engine/reconstruction-mapper.js
@@ -5206,6 +5477,7 @@ function buildReconstructionMapping(xmlDoc, modifiedText) {
     const escapedToken = tokenString.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
     processedModifiedText = processedModifiedText.replace(new RegExp(escapedToken, "g"), char);
   });
+  processedModifiedText = preserveReferencePlaceholders(originalFullText, processedModifiedText, referenceMap);
   const containerFragments = /* @__PURE__ */ new Map();
   uniqueContainers.forEach((container) => {
     containerFragments.set(container, xmlDoc.createDocumentFragment());
@@ -5256,6 +5528,25 @@ function buildReconstructionMapping(xmlDoc, modifiedText) {
     isParagraphStart: (index) => paragraphStarts.has(index)
   };
 }
+function preserveReferencePlaceholders(originalFullText, modifiedText, referenceMap) {
+  let result = modifiedText;
+  for (const referenceChar of referenceMap.keys()) {
+    if (result.includes(referenceChar)) continue;
+    const originalIndex = originalFullText.indexOf(referenceChar);
+    if (originalIndex < 0) continue;
+    const prefix = originalFullText.slice(0, originalIndex);
+    const suffix = originalFullText.slice(originalIndex + referenceChar.length);
+    if (prefix && result.startsWith(prefix)) {
+      result = `${result.slice(0, prefix.length)}${referenceChar}${result.slice(prefix.length)}`;
+      continue;
+    }
+    if (suffix && result.endsWith(suffix)) {
+      const insertAt = result.length - suffix.length;
+      result = `${result.slice(0, insertAt)}${referenceChar}${result.slice(insertAt)}`;
+    }
+  }
+  return result;
+}
 function processChildNode(child, originalFullText, propertyMap, sentinelMap, referenceMap, tokenToCharMap, nextCharCode) {
   if (child.nodeName === "w:r") {
     return processRunForReconstruction(child, originalFullText, propertyMap, sentinelMap, referenceMap, tokenToCharMap, nextCharCode);
@@ -5360,7 +5651,7 @@ function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, author, fo
     isParagraphStart
   } = context;
   const createNewParagraph = (pPr) => {
-    const newParagraph = xmlDoc.createElement("w:p");
+    const newParagraph = createWordElement(xmlDoc, "w:p");
     if (pPr) newParagraph.appendChild(pPr.cloneNode(true));
     return newParagraph;
   };
@@ -5372,6 +5663,7 @@ function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, author, fo
   }
   let currentOriginalIndex = 0;
   let currentInsertOffset = 0;
+  const emittedCommentMarkers = /* @__PURE__ */ new WeakSet();
   for (const [op, text] of diffs) {
     if (op === 0 || op === -1) {
       const type = op === 0 ? "equal" : "delete";
@@ -5381,7 +5673,7 @@ function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, author, fo
         const properties = getRunProperties(chunkStart);
         const chunkLength = getPropertySpanLength(chunkStart, text.length - offset);
         const chunk = text.substring(offset, offset + chunkLength);
-        appendTextToCurrent(
+        const appendResult = appendTextToCurrent(
           xmlDoc,
           chunk,
           type,
@@ -5398,8 +5690,10 @@ function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, author, fo
           author,
           formatHints,
           currentInsertOffset,
-          generateRedlines
+          generateRedlines,
+          emittedCommentMarkers
         );
+        currentParagraph = appendResult.currentParagraph;
         if (op === 0) {
           currentInsertOffset += chunkLength;
         }
@@ -5410,7 +5704,7 @@ function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, author, fo
     }
     if (op === 1) {
       const properties = currentOriginalIndex > 0 && !isParagraphStart(currentOriginalIndex) ? getRunProperties(currentOriginalIndex - 1) : getRunProperties(currentOriginalIndex);
-      appendTextToCurrent(
+      const appendResult = appendTextToCurrent(
         xmlDoc,
         text,
         "insert",
@@ -5427,8 +5721,10 @@ function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, author, fo
         author,
         formatHints,
         currentInsertOffset,
-        generateRedlines
+        generateRedlines,
+        emittedCommentMarkers
       );
+      currentParagraph = appendResult.currentParagraph;
       currentInsertOffset += text.length;
     }
   }
@@ -5454,17 +5750,18 @@ function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, author, fo
   });
   return { oxml: serializer.serializeToString(xmlDoc), hasChanges: true };
 }
-function appendTextToCurrent(xmlDoc, text, type, rPr, wrapper, baseIndex, currentParagraphRef, containerFragments, sentinelMapByStart, referenceMap, replacementContainers, getParagraphInfo, createNewParagraph, author, formatHints = [], insertOffset = 0, generateRedlines = 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()) {
   let localBaseIndex = baseIndex;
   let localInsertOffset = insertOffset;
   let localParagraph = currentParagraphRef;
   const parts = text.split(/([\n\uFFFC]|[\uE000-\uF8FF])/);
   parts.forEach((part) => {
     const sentinelsAtOffset = sentinelMapByStart.get(localBaseIndex) || [];
-    const commentMarkers = sentinelsAtOffset.filter((sentinel) => sentinel.isCommentMarker);
+    const commentMarkers = sentinelsAtOffset.filter((sentinel) => sentinel.isCommentMarker && !emittedCommentMarkers.has(sentinel.node));
     commentMarkers.forEach((marker) => {
+      emittedCommentMarkers.add(marker.node);
       if (marker.node.nodeName === "w:commentReference") {
-        const run = xmlDoc.createElement("w:r");
+        const run = createWordElement(xmlDoc, "w:r");
         run.appendChild(marker.node.cloneNode(true));
         localParagraph.appendChild(run);
       } else {
@@ -5472,14 +5769,17 @@ function appendTextToCurrent(xmlDoc, text, type, rPr, wrapper, baseIndex, curren
       }
     });
     if (part === "\n") {
-      if (type !== "delete") {
-        const info = getParagraphInfo(localBaseIndex);
-        const nextParagraph = createNewParagraph(info.pPr);
-        const fragment = containerFragments.get(info.container);
-        if (fragment) {
-          fragment.appendChild(nextParagraph);
-          localParagraph = nextParagraph;
-        }
+      const info = getParagraphInfo(localBaseIndex + 1);
+      const nextParagraph = createNewParagraph(info.pPr);
+      if (generateRedlines && type === "insert") {
+        markParagraphMarkInserted(xmlDoc, nextParagraph, author);
+      } else if (generateRedlines && type === "delete") {
+        markParagraphMarkDeleted(xmlDoc, nextParagraph, author);
+      }
+      const fragment = containerFragments.get(info.container);
+      if (fragment) {
+        fragment.appendChild(nextParagraph);
+        localParagraph = nextParagraph;
       }
       localBaseIndex++;
       if (type !== "delete") localInsertOffset++;
@@ -5507,7 +5807,7 @@ function appendTextToCurrent(xmlDoc, text, type, rPr, wrapper, baseIndex, curren
         const refNode = referenceMap.get(part);
         if (refNode) {
           const clone = refNode.cloneNode(true);
-          const run = xmlDoc.createElement("w:r");
+          const run = createWordElement(xmlDoc, "w:r");
           if (rPr) run.appendChild(rPr.cloneNode(true));
           run.appendChild(clone);
           localParagraph.appendChild(run);
@@ -5525,9 +5825,9 @@ function appendTextToCurrent(xmlDoc, text, type, rPr, wrapper, baseIndex, curren
       localParagraph.appendChild(wrapperClone);
     }
     if (type === "delete") {
-      const run = xmlDoc.createElement("w:r");
+      const run = createWordElement(xmlDoc, "w:r");
       if (rPr) run.appendChild(rPr.cloneNode(true));
-      const delText = xmlDoc.createElement("w:delText");
+      const delText = createWordElement(xmlDoc, "w:delText");
       delText.setAttribute("xml:space", "preserve");
       delText.textContent = part;
       run.appendChild(delText);
@@ -5551,16 +5851,17 @@ function appendTextToCurrent(xmlDoc, text, type, rPr, wrapper, baseIndex, curren
     }
     localBaseIndex += part.length;
   });
+  return { currentParagraph: localParagraph };
 }
 
 // engine/reconstruction-mode.js
 function applyReconstructionMode(xmlDoc, originalText, modifiedText, serializer, author, formatHints, generateRedlines = true) {
   const mapping = buildReconstructionMapping(xmlDoc, modifiedText);
   if (mapping.paragraphs.length === 0) {
-    return { oxml: serializer.serializeToString(xmlDoc), hasChanges: false };
+    return withOoxmlSourceType({ oxml: serializer.serializeToString(xmlDoc), hasChanges: false });
   }
   const diffs = computeWordDiffs(mapping.originalFullText, mapping.processedModifiedText);
-  return applyReconstructionDiffs(
+  return withOoxmlSourceType(applyReconstructionDiffs(
     xmlDoc,
     diffs,
     mapping,
@@ -5568,15 +5869,15 @@ function applyReconstructionMode(xmlDoc, originalText, modifiedText, serializer,
     author,
     formatHints,
     generateRedlines
-  );
+  ));
 }
 
 // engine/table-mode.js
 function noChanges(serializer, xmlDoc) {
-  return { oxml: serializer.serializeToString(xmlDoc), hasChanges: false };
+  return withOoxmlSourceType({ oxml: serializer.serializeToString(xmlDoc), hasChanges: false });
 }
 function applyTableReconciliation(xmlDoc, modifiedText, serializer, parser, author, generateRedlines = true) {
-  const tableNodes = getElementsByTag(xmlDoc, "w:tbl");
+  const tableNodes = getElementsByTagNSOrTag(xmlDoc, NS_W, "tbl");
   const newTableData = parseTable(modifiedText);
   const hasNewContent = newTableData.rows.length > 0 || newTableData.headers.length > 0;
   if (tableNodes.length === 0 || !hasNewContent) {
@@ -5598,14 +5899,14 @@ function applyTableReconciliation(xmlDoc, modifiedText, serializer, parser, auth
     error("[OxmlEngine] Failed to parse reconciled table OOXML:", parseError.textContent);
     return noChanges(serializer, xmlDoc);
   }
-  const newTableNode = getFirstElementByTag(reconciledDoc, "w:tbl");
+  const newTableNode = getFirstElementByTagNSOrTag(reconciledDoc, NS_W, "tbl");
   if (!newTableNode) {
     error("[OxmlEngine] No table found in reconciled OOXML");
     return noChanges(serializer, xmlDoc);
   }
   const importedTable = xmlDoc.importNode(newTableNode, true);
   targetTable.parentNode.replaceChild(importedTable, targetTable);
-  return { oxml: serializer.serializeToString(xmlDoc), hasChanges: true };
+  return withOoxmlSourceType({ oxml: serializer.serializeToString(xmlDoc), hasChanges: true });
 }
 function applyTextToTableTransformation(xmlDoc, modifiedText, serializer, parser, author, generateRedlines) {
   const tableData = parseTable(modifiedText);
@@ -5651,23 +5952,24 @@ function applyTextToTableTransformation(xmlDoc, modifiedText, serializer, parser
   }
   const importedTable = workingDoc.importNode(newTableElement, true);
   if (generateRedlines) {
-    const date = getRevisionTimestamp();
     paragraphs.forEach((p) => {
+      markParagraphMarkDeleted(workingDoc, p, author);
       const runs = getElementsByTagNS(p, NS_W, "r");
       runs.forEach((run) => {
         const textNodes = getElementsByTagNS(run, NS_W, "t");
         textNodes.forEach((t) => {
           const text = t.textContent || "";
           if (text.trim()) {
-            const delText = workingDoc.createElementNS(NS_W, "w:delText");
+            const delText = createWordElement(workingDoc, "w:delText");
             delText.textContent = text;
             t.parentNode.replaceChild(delText, t);
           }
         });
-        const del = workingDoc.createElementNS(NS_W, "w:del");
-        del.setAttribute("w:id", String(getNextRevisionId()));
-        del.setAttribute("w:author", author);
-        del.setAttribute("w:date", date);
+        const del = createWordElement(workingDoc, "w:del");
+        const metadata = createRevisionMetadata(author);
+        del.setAttribute("w:id", String(metadata.id));
+        del.setAttribute("w:author", metadata.author);
+        del.setAttribute("w:date", metadata.date);
         run.parentNode.insertBefore(del, run);
         del.appendChild(run);
       });
@@ -5680,7 +5982,405 @@ function applyTextToTableTransformation(xmlDoc, modifiedText, serializer, parser
     parent.removeChild(firstParagraph);
   }
   log("[OxmlEngine] Text-to-table transformation complete");
-  return { oxml: serializer.serializeToString(workingDoc), hasChanges: true };
+  return withOoxmlSourceType({ oxml: serializer.serializeToString(workingDoc), hasChanges: true });
+}
+
+// services/revision-comment-management.js
+function getAttributeByLocalName(node, localName) {
+  if (!node || !node.attributes) return "";
+  for (const attr of Array.from(node.attributes)) {
+    if ((attr.localName || "").toLowerCase() === localName.toLowerCase()) {
+      return String(attr.value || "");
+    }
+  }
+  return String(
+    node.getAttribute?.(`w:${localName}`) || node.getAttribute?.(localName) || ""
+  );
+}
+function normalizeAuthor(author) {
+  return typeof author === "string" ? author.trim().toLowerCase() : "";
+}
+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 getWordElementsByLocalName(xmlDoc, localName) {
+  return Array.from(xmlDoc.getElementsByTagNameNS(NS_W, localName));
+}
+function resolveAuthorFilter(options = {}) {
+  if (options?.allAuthors === true) {
+    return { valid: true, allAuthors: true, normalizedAuthor: "" };
+  }
+  const normalizedAuthor = normalizeAuthor(options?.author);
+  if (!normalizedAuthor) {
+    return {
+      valid: false,
+      allAuthors: false,
+      normalizedAuthor: "",
+      warning: "No author provided. Pass { author } or set { allAuthors: true }."
+    };
+  }
+  return { valid: true, allAuthors: false, normalizedAuthor };
+}
+function authorMatchesNode(node, filter) {
+  if (filter.allAuthors) return true;
+  const nodeAuthor = normalizeAuthor(getAttributeByLocalName(node, "author"));
+  return !!nodeAuthor && nodeAuthor === filter.normalizedAuthor;
+}
+function parseXmlWithWarnings(oxml, parseFailurePrefix) {
+  const parser = createParser();
+  const xmlDoc = parser.parseFromString(oxml, "application/xml");
+  const parseError = getXmlParseError(xmlDoc);
+  if (parseError) {
+    return {
+      xmlDoc: null,
+      serializer: null,
+      warning: `${parseFailurePrefix}: ${parseError.textContent || "parse error"}`
+    };
+  }
+  return { xmlDoc, serializer: createSerializer(), warning: null };
+}
+function removeNode(node) {
+  if (node?.parentNode) {
+    node.parentNode.removeChild(node);
+    return true;
+  }
+  return false;
+}
+function unwrapNode(node) {
+  const parent = node?.parentNode;
+  if (!parent) return false;
+  while (node.firstChild) {
+    parent.insertBefore(node.firstChild, node);
+  }
+  parent.removeChild(node);
+  return true;
+}
+function isTableRowRevisionMarker(node) {
+  const parent = node?.parentNode;
+  return isWordElement5(parent, "trPr") && isWordElement5(parent?.parentNode, "tr");
+}
+function isParagraphMarkRevisionMarker(node) {
+  const rPr = node?.parentNode;
+  const pPr = rPr?.parentNode;
+  const paragraph = pPr?.parentNode;
+  return isWordElement5(rPr, "rPr") && isWordElement5(pPr, "pPr") && isWordElement5(paragraph, "p");
+}
+function getContainingParagraphMarkRevision(node) {
+  return isParagraphMarkRevisionMarker(node) ? node.parentNode.parentNode.parentNode : null;
+}
+function getNextWordParagraph(paragraph) {
+  let cursor = paragraph?.nextSibling || null;
+  while (cursor) {
+    if (isWordElement5(cursor, "p")) return cursor;
+    cursor = cursor.nextSibling;
+  }
+  return null;
+}
+function mergeParagraphIntoNextAndRemove(paragraph) {
+  if (!paragraph?.parentNode) return false;
+  const nextParagraph = getNextWordParagraph(paragraph);
+  if (!nextParagraph) {
+    return removeNode(paragraph);
+  }
+  const childrenToMove = Array.from(paragraph.childNodes || []).filter((child) => !isWordElement5(child, "pPr"));
+  const insertionPoint = nextParagraph.firstChild || null;
+  for (const child of childrenToMove) {
+    nextParagraph.insertBefore(child, insertionPoint);
+  }
+  return removeNode(paragraph);
+}
+function acceptTrackedChangesInOoxml(oxml, options = {}) {
+  const warnings = [];
+  const filter = resolveAuthorFilter(options);
+  if (!filter.valid) {
+    return { oxml, hasChanges: false, acceptedCount: 0, warnings: [filter.warning] };
+  }
+  const parseResult = parseXmlWithWarnings(oxml, "Failed to parse OOXML");
+  if (!parseResult.xmlDoc) {
+    return { oxml, hasChanges: false, acceptedCount: 0, warnings: [parseResult.warning] };
+  }
+  const { xmlDoc, serializer } = parseResult;
+  let acceptedCount = 0;
+  for (const insNode of getWordElementsByLocalName(xmlDoc, "ins")) {
+    if (!insNode.parentNode || !authorMatchesNode(insNode, filter)) continue;
+    if (isParagraphMarkRevisionMarker(insNode)) {
+      if (removeNode(insNode)) acceptedCount += 1;
+      continue;
+    }
+    if (isTableRowRevisionMarker(insNode)) {
+      if (removeNode(insNode)) acceptedCount += 1;
+      continue;
+    }
+    if (unwrapNode(insNode)) acceptedCount += 1;
+  }
+  for (const delNode of getWordElementsByLocalName(xmlDoc, "del")) {
+    if (!delNode.parentNode || !authorMatchesNode(delNode, filter)) continue;
+    const paragraphMark = getContainingParagraphMarkRevision(delNode);
+    if (paragraphMark) {
+      if (mergeParagraphIntoNextAndRemove(paragraphMark)) acceptedCount += 1;
+      continue;
+    }
+    if (isTableRowRevisionMarker(delNode)) {
+      const rowNode = delNode.parentNode?.parentNode;
+      if (removeNode(rowNode)) acceptedCount += 1;
+      continue;
+    }
+    if (removeNode(delNode)) acceptedCount += 1;
+  }
+  for (const moveFromNode of getWordElementsByLocalName(xmlDoc, "moveFrom")) {
+    if (!moveFromNode.parentNode || !authorMatchesNode(moveFromNode, filter)) continue;
+    if (removeNode(moveFromNode)) acceptedCount += 1;
+  }
+  for (const moveToNode of getWordElementsByLocalName(xmlDoc, "moveTo")) {
+    if (!moveToNode.parentNode || !authorMatchesNode(moveToNode, filter)) continue;
+    if (unwrapNode(moveToNode)) acceptedCount += 1;
+  }
+  acceptedCount += removeMoveRangeMarkers(xmlDoc, filter);
+  const changeTags = ["rPrChange", "pPrChange", "tblPrChange", "trPrChange", "tcPrChange"];
+  for (const localName of changeTags) {
+    for (const changeNode of getWordElementsByLocalName(xmlDoc, localName)) {
+      if (!changeNode.parentNode || !authorMatchesNode(changeNode, filter)) continue;
+      if (removeNode(changeNode)) acceptedCount += 1;
+    }
+  }
+  return {
+    oxml: serializer.serializeToString(xmlDoc),
+    hasChanges: acceptedCount > 0,
+    acceptedCount,
+    warnings
+  };
+}
+function convertDeletionTextNodes(xmlDoc, delNode) {
+  for (const delTextNode of Array.from(delNode.getElementsByTagNameNS(NS_W, "delText"))) {
+    const normalText = createWordElement(xmlDoc, "w:t");
+    const spaceValue = delTextNode.getAttribute("xml:space");
+    if (spaceValue) {
+      normalText.setAttribute("xml:space", spaceValue);
+    }
+    while (delTextNode.firstChild) {
+      normalText.appendChild(delTextNode.firstChild);
+    }
+    delTextNode.parentNode?.replaceChild(normalText, delTextNode);
+  }
+}
+function rejectPropertyChangeNode(changeNode, localName) {
+  const parent = changeNode?.parentNode;
+  if (!parent) return false;
+  const baseLocalName = localName.endsWith("Change") ? localName.slice(0, -"Change".length) : "";
+  if (!baseLocalName || String(parent.localName || "").toLowerCase() !== baseLocalName.toLowerCase() || parent.namespaceURI !== NS_W) {
+    return removeNode(changeNode);
+  }
+  const historicalNode = Array.from(changeNode.childNodes || []).find(
+    (child) => child.nodeType === 1 && child.namespaceURI === NS_W && String(child.localName || "").toLowerCase() === baseLocalName.toLowerCase()
+  );
+  if (!historicalNode) {
+    return removeNode(changeNode);
+  }
+  const toAppend = Array.from(historicalNode.childNodes || []);
+  while (parent.firstChild) {
+    parent.removeChild(parent.firstChild);
+  }
+  for (const node of toAppend) {
+    const clone = xmlDocImportNode(parent.ownerDocument, node);
+    parent.appendChild(clone);
+  }
+  return true;
+}
+function xmlDocImportNode(xmlDoc, node) {
+  if (xmlDoc && typeof xmlDoc.importNode === "function") {
+    return xmlDoc.importNode(node, true);
+  }
+  return node.cloneNode(true);
+}
+function collectMoveRangeStartIds(xmlDoc, localName, filter) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const node of getWordElementsByLocalName(xmlDoc, localName)) {
+    if (!authorMatchesNode(node, filter)) continue;
+    const id = getAttributeByLocalName(node, "id");
+    if (id) ids.add(id);
+  }
+  return ids;
+}
+function removeMoveRangeMarkers(xmlDoc, filter) {
+  let removed = 0;
+  const moveFromIds = collectMoveRangeStartIds(xmlDoc, "moveFromRangeStart", filter);
+  const moveToIds = collectMoveRangeStartIds(xmlDoc, "moveToRangeStart", filter);
+  const markerSpecs = [
+    ["moveFromRangeStart", moveFromIds, true],
+    ["moveFromRangeEnd", moveFromIds, false],
+    ["moveToRangeStart", moveToIds, true],
+    ["moveToRangeEnd", moveToIds, false]
+  ];
+  for (const [localName, ids, isStart] of markerSpecs) {
+    for (const node of getWordElementsByLocalName(xmlDoc, localName)) {
+      if (!node.parentNode) continue;
+      const id = getAttributeByLocalName(node, "id");
+      if (!id) continue;
+      if (filter.allAuthors || ids.has(id) || isStart && authorMatchesNode(node, filter)) {
+        if (removeNode(node)) removed += 1;
+      }
+    }
+  }
+  return removed;
+}
+function rejectTrackedChangesInOoxml(oxml, options = {}) {
+  const warnings = [];
+  const filter = resolveAuthorFilter(options);
+  if (!filter.valid) {
+    return { oxml, hasChanges: false, rejectedCount: 0, warnings: [filter.warning] };
+  }
+  const parseResult = parseXmlWithWarnings(oxml, "Failed to parse OOXML");
+  if (!parseResult.xmlDoc) {
+    return { oxml, hasChanges: false, rejectedCount: 0, warnings: [parseResult.warning] };
+  }
+  const { xmlDoc, serializer } = parseResult;
+  let rejectedCount = 0;
+  for (const insNode of getWordElementsByLocalName(xmlDoc, "ins")) {
+    if (!insNode.parentNode || !authorMatchesNode(insNode, filter)) continue;
+    const paragraphMark = getContainingParagraphMarkRevision(insNode);
+    if (paragraphMark) {
+      if (mergeParagraphIntoNextAndRemove(paragraphMark)) rejectedCount += 1;
+      continue;
+    }
+    if (isTableRowRevisionMarker(insNode)) {
+      const rowNode = insNode.parentNode?.parentNode;
+      if (removeNode(rowNode)) rejectedCount += 1;
+      continue;
+    }
+    if (removeNode(insNode)) rejectedCount += 1;
+  }
+  for (const delNode of getWordElementsByLocalName(xmlDoc, "del")) {
+    if (!delNode.parentNode || !authorMatchesNode(delNode, filter)) continue;
+    if (isParagraphMarkRevisionMarker(delNode)) {
+      if (removeNode(delNode)) rejectedCount += 1;
+      continue;
+    }
+    if (isTableRowRevisionMarker(delNode)) {
+      if (removeNode(delNode)) rejectedCount += 1;
+      continue;
+    }
+    convertDeletionTextNodes(xmlDoc, delNode);
+    if (unwrapNode(delNode)) rejectedCount += 1;
+  }
+  for (const moveFromNode of getWordElementsByLocalName(xmlDoc, "moveFrom")) {
+    if (!moveFromNode.parentNode || !authorMatchesNode(moveFromNode, filter)) continue;
+    convertDeletionTextNodes(xmlDoc, moveFromNode);
+    if (unwrapNode(moveFromNode)) rejectedCount += 1;
+  }
+  for (const moveToNode of getWordElementsByLocalName(xmlDoc, "moveTo")) {
+    if (!moveToNode.parentNode || !authorMatchesNode(moveToNode, filter)) continue;
+    if (removeNode(moveToNode)) rejectedCount += 1;
+  }
+  rejectedCount += removeMoveRangeMarkers(xmlDoc, filter);
+  const changeTags = ["rPrChange", "pPrChange", "tblPrChange", "trPrChange", "tcPrChange"];
+  for (const localName of changeTags) {
+    for (const changeNode of getWordElementsByLocalName(xmlDoc, localName)) {
+      if (!changeNode.parentNode || !authorMatchesNode(changeNode, filter)) continue;
+      if (rejectPropertyChangeNode(changeNode, localName)) rejectedCount += 1;
+    }
+  }
+  return {
+    oxml: serializer.serializeToString(xmlDoc),
+    hasChanges: rejectedCount > 0,
+    rejectedCount,
+    warnings
+  };
+}
+function collectCommentTargetIds(xmlDoc, filter) {
+  const targetIds = /* @__PURE__ */ new Set();
+  const commentNodes = getWordElementsByLocalName(xmlDoc, "comment");
+  for (const commentNode of commentNodes) {
+    if (!authorMatchesNode(commentNode, filter)) continue;
+    const id = getAttributeByLocalName(commentNode, "id");
+    if (id) targetIds.add(id);
+  }
+  return { targetIds, commentNodes };
+}
+function removeCommentNodesById(commentNodes, targetIds) {
+  let removed = 0;
+  for (const commentNode of commentNodes) {
+    const id = getAttributeByLocalName(commentNode, "id");
+    if (!id || !targetIds.has(id)) continue;
+    if (removeNode(commentNode)) removed += 1;
+  }
+  return removed;
+}
+function runIsOnlyCommentReference(runNode) {
+  if (!isWordElement5(runNode, "r")) return false;
+  const meaningfulChildren = Array.from(runNode.childNodes || []).filter((child) => {
+    if (child.nodeType === 3) return String(child.nodeValue || "").trim().length > 0;
+    if (child.nodeType !== 1) return false;
+    if (child.namespaceURI !== NS_W) return true;
+    const local = String(child.localName || "").toLowerCase();
+    return local !== "rpr" && local !== "commentreference";
+  });
+  return meaningfulChildren.length === 0;
+}
+function removeCommentAnchors(xmlDoc, targetIds) {
+  let removed = 0;
+  const anchorTags = ["commentRangeStart", "commentRangeEnd", "commentReference"];
+  for (const localName of anchorTags) {
+    for (const node of getWordElementsByLocalName(xmlDoc, localName)) {
+      if (!node.parentNode) continue;
+      const id = getAttributeByLocalName(node, "id");
+      if (!id || !targetIds.has(id)) continue;
+      if (localName === "commentReference" && runIsOnlyCommentReference(node.parentNode)) {
+        if (removeNode(node.parentNode)) {
+          removed += 1;
+        }
+        continue;
+      }
+      if (removeNode(node)) {
+        removed += 1;
+      }
+    }
+  }
+  return removed;
+}
+function deleteCommentsByAuthorInOoxml(oxml, options = {}) {
+  const warnings = [];
+  const filter = resolveAuthorFilter(options);
+  if (!filter.valid) {
+    return {
+      oxml,
+      hasChanges: false,
+      commentsRemoved: 0,
+      referencesRemoved: 0,
+      warnings: [filter.warning]
+    };
+  }
+  const parseResult = parseXmlWithWarnings(oxml, "Failed to parse OOXML");
+  if (!parseResult.xmlDoc) {
+    return {
+      oxml,
+      hasChanges: false,
+      commentsRemoved: 0,
+      referencesRemoved: 0,
+      warnings: [parseResult.warning]
+    };
+  }
+  const { xmlDoc, serializer } = parseResult;
+  const { targetIds, commentNodes } = collectCommentTargetIds(xmlDoc, filter);
+  if (filter.allAuthors) {
+    for (const localName of ["commentRangeStart", "commentRangeEnd", "commentReference"]) {
+      for (const node of getWordElementsByLocalName(xmlDoc, localName)) {
+        const id = getAttributeByLocalName(node, "id");
+        if (id) targetIds.add(id);
+      }
+    }
+  }
+  const commentsRemoved = removeCommentNodesById(commentNodes, targetIds);
+  const referencesRemoved = removeCommentAnchors(xmlDoc, targetIds);
+  return {
+    oxml: serializer.serializeToString(xmlDoc),
+    hasChanges: commentsRemoved > 0 || referencesRemoved > 0,
+    commentsRemoved,
+    referencesRemoved,
+    warnings
+  };
 }
 
 // engine/oxml-engine.js
@@ -5689,18 +6389,70 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
   const author = options.author || getDefaultAuthor();
   const parser = createParser();
   const serializer = createSerializer();
-  const noChanges2 = () => ({ oxml, hasChanges: false });
+  const finalize = (result) => {
+    const withStatus = { ...result };
+    if (!withStatus.status) {
+      withStatus.status = withStatus.hasChanges ? "ok" : "no-op";
+    }
+    return withOoxmlSourceType(withStatus);
+  };
+  const noChanges2 = () => finalize({ oxml, hasChanges: false });
   let xmlDoc;
   try {
     xmlDoc = parser.parseFromString(oxml, "text/xml");
   } catch (e) {
     error("[OxmlEngine] Failed to parse OXML:", e);
-    return noChanges2();
+    return finalize({
+      oxml,
+      hasChanges: false,
+      status: "error",
+      error: { code: "PARSE_ERROR", message: "Could not parse OOXML input." }
+    });
   }
   const parseError = getXmlParseError(xmlDoc);
   if (parseError) {
     error("[OxmlEngine] XML parse error:", parseError.textContent);
-    return noChanges2();
+    return finalize({
+      oxml,
+      hasChanges: false,
+      status: "error",
+      error: { code: "PARSE_ERROR", message: parseError.textContent || "Could not parse OOXML input." }
+    });
+  }
+  seedRevisionIdsFromDocument(xmlDoc);
+  if (containsTrackedChanges(xmlDoc)) {
+    const existingRevisionsPolicy = options.existingRevisions || "reject-input";
+    if (existingRevisionsPolicy === "accept-all-first") {
+      log("[OxmlEngine] Existing revisions detected; accepting all input revisions before redlining");
+      const accepted = acceptTrackedChangesInOoxml(oxml, { allAuthors: true });
+      oxml = accepted.oxml;
+      xmlDoc = parser.parseFromString(oxml, "text/xml");
+      const acceptedParseError = getXmlParseError(xmlDoc);
+      if (acceptedParseError) {
+        error("[OxmlEngine] XML parse error after accepting existing revisions:", acceptedParseError.textContent);
+        return finalize({
+          oxml,
+          hasChanges: false,
+          status: "error",
+          error: {
+            code: "PARSE_ERROR",
+            message: "Could not parse OOXML after accepting existing revisions."
+          }
+        });
+      }
+      seedRevisionIdsFromDocument(xmlDoc);
+    } else {
+      log("[OxmlEngine] Existing revisions detected; rejecting input per existingRevisions policy");
+      return finalize({
+        oxml,
+        hasChanges: false,
+        status: "error",
+        error: {
+          code: "EXISTING_REVISIONS",
+          message: 'Input OOXML contains existing tracked changes. Pass existingRevisions: "accept-all-first" to normalize before redlining.'
+        }
+      });
+    }
   }
   const initialTableCellContext = detectTableCellContext(xmlDoc, originalText, options);
   if (initialTableCellContext.hasTableWrapper && initialTableCellContext.targetParagraph && !options._isolatedTableCell) {
@@ -5717,6 +6469,19 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
   const hasFormatHints = formatHints.length > 0;
   const { existingFormatHints, textSpans, paragraphs } = extractFormattingFromOoxml(xmlDoc);
   const hasExistingFormatting = existingFormatHints.length > 0;
+  const visibleText = textSpans.map((span) => textSpanVisibleText(span)).join("");
+  if (hasTextChanges && typeof originalText === "string" && originalText.trim() && !originalText.includes("\n") && !visibleText.includes(originalText.trim()) && !visibleText.replace(/[\t\n\u2011]/g, "").includes(originalText.trim().replace(/[\t\n\u2011]/g, "")) && !normalizeTargetText(visibleText).includes(normalizeTargetText(originalText))) {
+    log("[OxmlEngine] Target text not found in OOXML");
+    return finalize({
+      oxml,
+      hasChanges: false,
+      status: "error",
+      error: {
+        code: "TARGET_NOT_FOUND",
+        message: "Original text was not found in the supplied OOXML."
+      }
+    });
+  }
   let paragraphInfos = null;
   const getParagraphInfos = () => {
     if (!paragraphInfos) {
@@ -5780,12 +6545,12 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
       generateRedlines
     );
     if (tableCellCtx.hasTableWrapper && targetParagraph) {
-      return {
+      return finalize({
         oxml: serializeParagraphOnly(xmlDoc, targetParagraph, serializer),
         hasChanges: removalResult.hasChanges
-      };
+      });
     }
-    return removalResult;
+    return finalize(removalResult);
   }
   if (!hasTextChanges && hasFormatHints) {
     log(`[OxmlEngine] Format-only change detected: ${formatHints.length} format hints`);
@@ -5799,14 +6564,14 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
       log("[OxmlEngine] Table cell context: applying formatting to target paragraph only");
       const formatResult = applyFormatOnlyWithOoxmlFallback(precomputedFormatContext);
       log("[OxmlEngine] Stripping table wrapper for table cell paragraph (format-only)");
-      return {
+      return finalize({
         oxml: serializeParagraphOnly(xmlDoc, tableCellCtx.targetParagraph, serializer),
         hasChanges: formatResult.hasChanges
-      };
+      });
     }
-    return applyFormatOnlyWithOoxmlFallback(precomputedFormatContext);
+    return finalize(applyFormatOnlyWithOoxmlFallback(precomputedFormatContext));
   }
-  const tables = getElementsByTag(xmlDoc, "w:tbl");
+  const tables = getElementsByTagNSOrTag(xmlDoc, NS_W, "tbl");
   const hasTables = tables.length > 0;
   const isMarkdownTable = /^\|.+\|/.test(cleanModifiedText.trim()) && cleanModifiedText.includes("\n");
   const isTargetList = isListTargetLoose(cleanModifiedText);
@@ -5814,10 +6579,10 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
   log(`[OxmlEngine] Mode: ${hasTables ? "SURGICAL" : "RECONSTRUCTION"}, formatHints: ${formatHints.length}, isMarkdownTable: ${isMarkdownTable}, isTargetList: ${isTargetList}, isTableCellParagraph: ${tableCellContext.isTableCellParagraph}`);
   if (isMarkdownTable && !hasTables) {
     log("[OxmlEngine] Text-to-table transformation: generating new table from Markdown");
-    return applyTextToTableTransformation(xmlDoc, cleanModifiedText, serializer, parser, author, generateRedlines);
+    return finalize(applyTextToTableTransformation(xmlDoc, cleanModifiedText, serializer, parser, author, generateRedlines));
   }
   if (hasTables && isMarkdownTable) {
-    return applyTableReconciliation(xmlDoc, cleanModifiedText, serializer, parser, author, generateRedlines);
+    return finalize(applyTableReconciliation(xmlDoc, cleanModifiedText, serializer, parser, author, generateRedlines));
   }
   if (hasTables) {
     const surgicalTarget = tableCellContext.hasTableWrapper && tableCellContext.targetParagraph ? tableCellContext.targetParagraph : null;
@@ -5836,9 +6601,9 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
     );
     if (tableCellContext.hasTableWrapper && result.hasChanges && tableCellContext.targetParagraph) {
       log("[OxmlEngine] Stripping table wrapper for table cell paragraph (surgical mode)");
-      return { oxml: serializeParagraphOnly(xmlDoc, tableCellContext.targetParagraph, serializer), hasChanges: true };
+      return finalize({ oxml: serializeParagraphOnly(xmlDoc, tableCellContext.targetParagraph, serializer), hasChanges: true });
     }
-    return result;
+    return finalize(result);
   }
   if (isTargetList) {
     log("[OxmlEngine] \u{1F3AF} Using reconciliation pipeline for list generation");
@@ -5851,11 +6616,22 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
         numberingXml: result.numberingXml
       });
       log(`[OxmlEngine] \u2705 Wrapped OOXML length: ${wrapped.length}`);
-      return { oxml: wrapped, hasChanges: true };
+      return finalize({ oxml: wrapped, hasChanges: true });
     }
     return noChanges2();
   }
-  return applyReconstructionMode(xmlDoc, originalText, cleanModifiedText, serializer, author, formatHints, generateRedlines);
+  return finalize(applyReconstructionMode(xmlDoc, originalText, cleanModifiedText, serializer, author, formatHints, generateRedlines));
+}
+function normalizeTargetText(text) {
+  return String(text || "").replace(/[\t\n\u2011]/g, " ").replace(/\s+/g, " ").trim();
+}
+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";
+  return node?.textContent || "";
 }
 function sanitizeAiResponse(text) {
   let cleaned = text;
@@ -6684,7 +7460,7 @@ function clearSingleLineListFallbackExplicitSequence(sequenceState, numberingKey
   if (!numberingKey) return;
   sequenceState.explicitByNumberingKey.delete(String(numberingKey));
 }
-function getDirectWordChild(element, localName) {
+function getDirectWordChild2(element, localName) {
   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
@@ -6701,7 +7477,7 @@ function enforceListBindingOnParagraphNodes(nodes, options = {}) {
   for (const paragraph of paragraphs) {
     const ownerDoc = paragraph.ownerDocument;
     if (!ownerDoc) continue;
-    let pPr = getDirectWordChild(paragraph, "pPr");
+    let pPr = getDirectWordChild2(paragraph, "pPr");
     if (!pPr) {
       pPr = ownerDoc.createElementNS(
         "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
@@ -6710,14 +7486,14 @@ function enforceListBindingOnParagraphNodes(nodes, options = {}) {
       paragraph.insertBefore(pPr, paragraph.firstChild);
     }
     if (clearParagraphPropertyChanges) {
-      const pPrChange = getDirectWordChild(pPr, "pPrChange");
+      const pPrChange = getDirectWordChild2(pPr, "pPrChange");
       if (pPrChange) pPr.removeChild(pPrChange);
     }
     if (removeListPropertyNode) {
-      const listPr = getDirectWordChild(pPr, "listPr");
+      const listPr = getDirectWordChild2(pPr, "listPr");
       if (listPr) pPr.removeChild(listPr);
     }
-    let numPr = getDirectWordChild(pPr, "numPr");
+    let numPr = getDirectWordChild2(pPr, "numPr");
     if (!numPr) {
       numPr = ownerDoc.createElementNS(
         "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
@@ -6725,7 +7501,7 @@ function enforceListBindingOnParagraphNodes(nodes, options = {}) {
       );
       pPr.appendChild(numPr);
     }
-    let ilvlEl = getDirectWordChild(numPr, "ilvl");
+    let ilvlEl = getDirectWordChild2(numPr, "ilvl");
     if (!ilvlEl) {
       ilvlEl = ownerDoc.createElementNS(
         "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
@@ -6734,7 +7510,7 @@ function enforceListBindingOnParagraphNodes(nodes, options = {}) {
       numPr.appendChild(ilvlEl);
     }
     ilvlEl.setAttribute("w:val", String(ilvl));
-    let numIdEl = getDirectWordChild(numPr, "numId");
+    let numIdEl = getDirectWordChild2(numPr, "numId");
     if (!numIdEl) {
       numIdEl = ownerDoc.createElementNS(
         "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
@@ -7392,7 +8168,7 @@ function getWordParagraphs(doc) {
   if (namespaced.length > 0) return namespaced;
   return Array.from(doc.getElementsByTagNameNS("*", "p")).filter((node) => node?.localName === "p");
 }
-function getDirectWordChild2(node, localName) {
+function getDirectWordChild3(node, localName) {
   const children = Array.from(node?.childNodes || []);
   for (const child of children) {
     if (child?.nodeType !== 1) continue;
@@ -7439,7 +8215,7 @@ function readRunText(run) {
   return text;
 }
 function getRunFormatting(run) {
-  const rPr = getDirectWordChild2(run, "rPr");
+  const rPr = getDirectWordChild3(run, "rPr");
   if (!rPr) return { bold: false, italic: false };
   const rStyle = getWordDescendants(rPr, "rStyle")[0] || null;
   const rStyleValue = getWordAttribute(rStyle, ["w:val", "val"]).toLowerCase();
@@ -7455,6 +8231,7 @@ function collectParagraphSegments(paragraph) {
   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 (!text) continue;
     segments.push({
@@ -7485,7 +8262,7 @@ function wrapRunMarkdown(text, format) {
   return `${leading}${wrapped}${trailing}`;
 }
 function parseHeadingLevel(paragraph) {
-  const pPr = getDirectWordChild2(paragraph, "pPr");
+  const pPr = getDirectWordChild3(paragraph, "pPr");
   if (!pPr) return null;
   const pStyle = getWordDescendants(pPr, "pStyle")[0] || null;
   const styleVal = getWordAttribute(pStyle, ["w:val", "val"]);
@@ -7505,7 +8282,7 @@ function parseHeadingLevel(paragraph) {
   return null;
 }
 function parseListInfo(paragraph) {
-  const pPr = getDirectWordChild2(paragraph, "pPr");
+  const pPr = getDirectWordChild3(paragraph, "pPr");
   if (!pPr) return null;
   const numPr = getWordDescendants(pPr, "numPr")[0] || null;
   if (!numPr) return null;
@@ -7626,11 +8403,11 @@ function findTextInParagraphIndex(paragraphIndex, searchText) {
   };
 }
 function cloneRunWithText(xmlDoc, rPr, newText) {
-  const newRun = xmlDoc.createElementNS(NS_W, "w:r");
+  const newRun = createWordElement(xmlDoc, "w:r");
   if (rPr) {
     newRun.appendChild(rPr.cloneNode(true));
   }
-  const newTextNode = xmlDoc.createElementNS(NS_W, "w:t");
+  const newTextNode = createWordElement(xmlDoc, "w:t");
   newTextNode.setAttribute("xml:space", "preserve");
   newTextNode.textContent = newText;
   newRun.appendChild(newTextNode);
@@ -7642,12 +8419,12 @@ function injectMarkersIntoParagraph(xmlDoc, paragraph, textToFind, commentId, pa
   if (!location.found || !location.startRun) {
     return false;
   }
-  const startMarker = xmlDoc.createElementNS(NS_W, "w:commentRangeStart");
+  const startMarker = createWordElement(xmlDoc, "w:commentRangeStart");
   startMarker.setAttribute("w:id", String(commentId));
-  const endMarker = xmlDoc.createElementNS(NS_W, "w:commentRangeEnd");
+  const endMarker = createWordElement(xmlDoc, "w:commentRangeEnd");
   endMarker.setAttribute("w:id", String(commentId));
-  const referenceRun = xmlDoc.createElementNS(NS_W, "w:r");
-  const reference = xmlDoc.createElementNS(NS_W, "w:commentReference");
+  const referenceRun = createWordElement(xmlDoc, "w:r");
+  const reference = createWordElement(xmlDoc, "w:commentReference");
   reference.setAttribute("w:id", String(commentId));
   referenceRun.appendChild(reference);
   if (location.startRun === location.endRun) {
@@ -8009,13 +8786,13 @@ function injectHighlightIntoRPr(doc, rPr, color = "yellow", options = {}) {
   const author = options?.author || getDefaultAuthor();
   let rPrElement = rPr;
   if (!rPrElement) {
-    rPrElement = doc.createElementNS(NS_W7, "w:rPr");
+    rPrElement = createWordElement(doc, "w:rPr");
   } else {
     rPrElement = rPr.cloneNode(true);
   }
   let previousRPrState = null;
   if (generateRedlines) {
-    previousRPrState = doc.createElementNS(NS_W7, "w:rPr");
+    previousRPrState = createWordElement(doc, "w:rPr");
     Array.from(rPrElement.childNodes).forEach((child) => {
       if (child.nodeName !== "w:rPrChange") {
         previousRPrState.appendChild(child.cloneNode(true));
@@ -8024,14 +8801,15 @@ function injectHighlightIntoRPr(doc, rPr, color = "yellow", options = {}) {
   }
   const existingHighlight = rPrElement.getElementsByTagNameNS(NS_W7, "highlight");
   Array.from(existingHighlight).forEach((el) => el.remove());
-  const highlightEl = doc.createElementNS(NS_W7, "w:highlight");
+  const highlightEl = createWordElement(doc, "w:highlight");
   highlightEl.setAttributeNS(NS_W7, "w:val", ooxmlColor);
   rPrElement.appendChild(highlightEl);
   if (generateRedlines && previousRPrState) {
-    const rPrChange = doc.createElementNS(NS_W7, "w:rPrChange");
-    rPrChange.setAttributeNS(NS_W7, "w:id", Math.floor(Math.random() * 9999999).toString());
-    rPrChange.setAttributeNS(NS_W7, "w:author", author);
-    rPrChange.setAttributeNS(NS_W7, "w:date", (/* @__PURE__ */ new Date()).toISOString());
+    const rPrChange = createWordElement(doc, "w:rPrChange");
+    const metadata = createRevisionMetadata(author);
+    rPrChange.setAttribute("w:id", String(metadata.id));
+    rPrChange.setAttribute("w:author", metadata.author);
+    rPrChange.setAttribute("w:date", metadata.date);
     rPrChange.appendChild(previousRPrState);
     const existingChange = rPrElement.getElementsByTagNameNS(NS_W7, "rPrChange");
     Array.from(existingChange).forEach((el) => el.remove());
@@ -8067,7 +8845,7 @@ function applyHighlightToOoxml(ooxmlString, targetText, color = "yellow", option
       const prefixRun = run.cloneNode(true);
       const tNodes = prefixRun.getElementsByTagNameNS(NS_W7, "t");
       Array.from(tNodes).forEach((t) => t.remove());
-      const newT = doc.createElementNS(NS_W7, "w:t");
+      const newT = createWordElement(doc, "w:t");
       newT.setAttribute("xml:space", "preserve");
       newT.textContent = prefixText;
       prefixRun.appendChild(newT);
@@ -8077,7 +8855,7 @@ function applyHighlightToOoxml(ooxmlString, targetText, color = "yellow", option
       const matchRun = run.cloneNode(true);
       const tNodes = matchRun.getElementsByTagNameNS(NS_W7, "t");
       Array.from(tNodes).forEach((t) => t.remove());
-      const newT = doc.createElementNS(NS_W7, "w:t");
+      const newT = createWordElement(doc, "w:t");
       newT.setAttribute("xml:space", "preserve");
       newT.textContent = matchText;
       matchRun.appendChild(newT);
@@ -8095,7 +8873,7 @@ function applyHighlightToOoxml(ooxmlString, targetText, color = "yellow", option
       const suffixRun = run.cloneNode(true);
       const tNodes = suffixRun.getElementsByTagNameNS(NS_W7, "t");
       Array.from(tNodes).forEach((t) => t.remove());
-      const newT = doc.createElementNS(NS_W7, "w:t");
+      const newT = createWordElement(doc, "w:t");
       newT.setAttribute("xml:space", "preserve");
       newT.textContent = suffixText;
       suffixRun.appendChild(newT);
@@ -8572,7 +9350,7 @@ async function applyRedlineToOxml2(oxml, originalText, modifiedText, options = {
   const result = await applyRedlineToOxml(oxml, originalText, modifiedText, options);
   if (result?.useNativeApi && typeof result?.oxml !== "string") {
     const existingWarnings = Array.isArray(result?.warnings) ? result.warnings : [];
-    return {
+    return withOoxmlSourceType({
       ...result,
       oxml,
       hasChanges: false,
@@ -8580,7 +9358,7 @@ async function applyRedlineToOxml2(oxml, originalText, modifiedText, options = {
         ...existingWarnings,
         "Standalone mode cannot execute native Word API fallback for this operation."
       ]
-    };
+    });
   }
   return result;
 }
@@ -8636,14 +9414,14 @@ async function applyRedlineToOxmlWithListFallback(oxml, originalText, modifiedTe
         numberingXml: fallbackResult2.numberingXml
       });
       const fallbackWarnings2 = Array.isArray(fallbackResult2?.warnings) ? fallbackResult2.warnings : [];
-      return {
+      return withOoxmlSourceType({
         oxml: wrappedOxml2,
         hasChanges: true,
         warnings: fallbackWarnings2,
         listStructuralFallbackApplied: true,
         listStructuralFallbackKey: fallbackResult2.listStructuralFallbackKey || null,
         listStructuralFallbackNumberingXml: fallbackResult2.numberingXml || null
-      };
+      });
     }
     preflightFallbackWarnings = Array.isArray(fallbackResult2?.warnings) ? fallbackResult2.warnings : [];
   }
@@ -8694,7 +9472,7 @@ async function applyRedlineToOxmlWithListFallback(oxml, originalText, modifiedTe
   });
   const existingWarnings = Array.isArray(baseResult?.warnings) ? baseResult.warnings : [];
   const fallbackWarnings = Array.isArray(fallbackResult?.warnings) ? fallbackResult.warnings : [];
-  return {
+  return withOoxmlSourceType({
     ...baseResult,
     oxml: wrappedOxml,
     hasChanges: true,
@@ -8702,7 +9480,7 @@ async function applyRedlineToOxmlWithListFallback(oxml, originalText, modifiedTe
     listStructuralFallbackApplied: true,
     listStructuralFallbackKey: fallbackResult.listStructuralFallbackKey || null,
     listStructuralFallbackNumberingXml: fallbackResult.numberingXml || null
-  };
+  });
 }
 export {
   ContainerKind,
@@ -8714,6 +9492,7 @@ export {
   RoutePlanKind,
   RunKind,
   WORD_MAIN_NS,
+  acceptTrackedChangesInOoxml,
   applyFormattingRemovalToOoxml,
   applyHighlightToOoxml,
   applyRedlineToOxml2 as applyRedlineToOxml,
@@ -8729,7 +9508,9 @@ export {
   collectContiguousListParagraphBlock,
   configureLogger,
   configureXmlProvider,
+  containsTrackedChanges,
   createDynamicNumberingIdState,
+  deleteCommentsByAuthorInOoxml,
   enforceListBindingOnParagraphNodes,
   ensureCommentsArtifactsInZip,
   ensureNumberingArtifactsInZip,
@@ -8775,6 +9556,7 @@ export {
   preprocessMarkdown,
   reconcileMarkdownTableOoxml,
   recordSingleLineListFallbackExplicitSequence,
+  rejectTrackedChangesInOoxml,
   remapNumberingPayloadForDocument,
   removeFormattingFromRPr,
   reserveNextNumberingId,