@ansonlai/docx-redline-js 0.8.2 → 0.8.4

package/dist/docx-redline.bundle.js

@@ -1,4 +1,4 @@
-// @ansonlai/docx-redline-js standalone bundle v0.8.2 — https://github.com/AnsonLai/docx-redline-js
+// @ansonlai/docx-redline-js standalone bundle v0.8.4 — https://github.com/AnsonLai/docx-redline-js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -9733,7 +9733,14 @@ function buildRunXmlWithHints(item, formatHints, options = {}) {
 function buildSimpleRun(text2, rPrXml) {
   if (!text2) return "";
   const rPr = rPrXml || "";
-  return `<w:r>${rPr}<w:t xml:space="preserve">${escapeXml(text2)}</w:t></w:r>`;
+  return `<w:r>${rPr}${buildRunContent(text2, "w:t")}</w:r>`;
+}
+function buildRunContent(text2, textTag) {
+  return String(text2).split(/(\r\n|[\n\r\v\t])/).map((part) => {
+    if (part === "	") return "<w:tab/>";
+    if (part === "\n" || part === "\r" || part === "\r\n" || part === "\v") return "<w:br/>";
+    return part ? `<${textTag} xml:space="preserve">${escapeXml(part)}</${textTag}>` : "";
+  }).join("");
 }
 function buildDeletionXml(item, options = {}) {
   const metadata = createRevisionMetadata(
@@ -9746,7 +9753,7 @@ function buildDeletionXml(item, options = {}) {
   if (font) {
     rPr = applyFont(rPr, font);
   }
-  return `<w:del w:id="${metadata.id}" w:author="${escapeXml(metadata.author)}" w:date="${metadata.date}"><w:r>${rPr}<w:delText xml:space="preserve">${escapeXml(item.text)}</w:delText></w:r></w:del>`;
+  return `<w:del w:id="${metadata.id}" w:author="${escapeXml(metadata.author)}" w:date="${metadata.date}"><w:r>${rPr}${buildRunContent(item.text, "w:delText")}</w:r></w:del>`;
 }
 function buildInsertionXml(item, formatHints, options = {}) {
   const metadata = createRevisionMetadata(
@@ -10087,7 +10094,7 @@ function generateTableOoxml(tableData, options = {}) {
     revisionIdAllocator = null,
     trackAsBlock = false
   } = options;
-  const tableInsertMeta = generateRedlines && trackAsBlock ? createRevisionMetadata(author, revisionIdAllocator) : null;
+  const trackRows = generateRedlines && trackAsBlock;
   const numCols = tableData.headers?.length || (tableData.rows?.[0]?.length || 1);
   const tblPr = `
         <w:tblPr>
@@ -10115,14 +10122,16 @@ function generateTableOoxml(tableData, options = {}) {
       const cellText = row[c] || "";
       const { cleanText, formatHints } = preprocessMarkdown(cellText);
       const runModel = [{
-        kind: generateRedlines && !trackAsBlock ? RunKind.INSERTION : RunKind.TEXT,
+        kind: generateRedlines ? RunKind.INSERTION : RunKind.TEXT,
         text: cleanText,
         rPrXml: isHeaderRow ? "<w:rPr><w:b/></w:rPr>" : "",
         author,
         startOffset: 0,
         endOffset: cleanText.length
       }];
-      const runsOoxml = serializeToOoxml(runModel, null, formatHints, {
+      const cellMarkMeta = trackRows ? createRevisionMetadata(author, revisionIdAllocator) : null;
+      const cellPPr = cellMarkMeta ? `<w:pPr><w:rPr><w:ins w:id="${cellMarkMeta.id}" w:author="${escapeXml(cellMarkMeta.author)}" w:date="${cellMarkMeta.date}"/></w:rPr></w:pPr>` : null;
+      const runsOoxml = serializeToOoxml(runModel, cellPPr, formatHints, {
         author,
         generateRedlines,
         revisionIdAllocator
@@ -10131,13 +10140,11 @@ function generateTableOoxml(tableData, options = {}) {
       cellsXml += `<w:tc>${tcPr}${runsOoxml}</w:tc>`;
     }
     const trPr = isHeaderRow ? "<w:trPr><w:tblHeader/><w:cantSplit/></w:trPr>" : "<w:trPr><w:cantSplit/></w:trPr>";
-    rowsXml += `<w:tr>${trPr}${cellsXml}</w:tr>`;
-  }
-  let tableXml = `<w:tbl>${tblPr}${tblGrid}${rowsXml}</w:tbl>`;
-  if (tableInsertMeta) {
-    tableXml = `<w:ins w:id="${tableInsertMeta.id}" w:author="${escapeXml(tableInsertMeta.author)}" w:date="${tableInsertMeta.date}">${tableXml}</w:ins>`;
+    const rowMeta = trackRows ? createRevisionMetadata(author, revisionIdAllocator) : null;
+    const trackedTrPr = rowMeta ? trPr.replace("</w:trPr>", `<w:ins w:id="${rowMeta.id}" w:author="${escapeXml(rowMeta.author)}" w:date="${rowMeta.date}"/></w:trPr>`) : trPr;
+    rowsXml += `<w:tr>${trackedTrPr}${cellsXml}</w:tr>`;
   }
-  return tableXml;
+  return `<w:tbl>${tblPr}${tblGrid}${rowsXml}</w:tbl>`;
 }
 function diffTablesWithVirtualGrid(oldGrid, newTableData) {
   const operations = [];
@@ -10452,7 +10459,37 @@ async function executeListGeneration(options) {
       }];
     }
   }
-  if (generateRedlines && deletionRuns.length > 0) {
+  const sourceParagraphCount = (originalRunModel || []).filter((run) => run.kind === RunKind.PARAGRAPH_START).length;
+  if (generateRedlines && sourceParagraphCount > 0 && (sourceParagraphCount > 1 || deletionRuns.length === 0)) {
+    let segment = null;
+    const flushSegment = () => {
+      if (!segment) return;
+      results.push(serializeToOoxml(segment, null, [], {
+        author,
+        generateRedlines,
+        revisionIdAllocator
+      }));
+      segment = null;
+    };
+    for (const run of originalRunModel) {
+      if (run.kind === RunKind.PARAGRAPH_START) {
+        flushSegment();
+        segment = [{
+          ...run,
+          pPrElement: null,
+          pPrXml: addParagraphMarkRevision(
+            run.pPrElement || run.pPrXml || null,
+            "del",
+            author,
+            revisionIdAllocator
+          )
+        }];
+      } else if (segment && (run.kind === "text" || run.kind === "run")) {
+        segment.push({ ...run, kind: "deletion", author });
+      }
+    }
+    flushSegment();
+  } else if (generateRedlines && deletionRuns.length > 0) {
     const deletedPPr = addParagraphMarkRevision(sourcePPr, "del", author, revisionIdAllocator);
     const deletedParagraph = serializeToOoxml(deletionRuns, deletedPPr, [], {
       author,
@@ -15031,6 +15068,11 @@ function rejectTrackedChangesInOoxml(oxml, options = {}) {
     }
     if (removeNode(insNode)) rejectedCount += 1;
   }
+  for (const tableNode of getWordElementsByLocalName(xmlDoc, "tbl")) {
+    if (!tableNode.parentNode) continue;
+    const hasRow = Array.from(tableNode.childNodes || []).some((child) => isWordElement5(child, "tr"));
+    if (!hasRow && removeNode(tableNode)) rejectedCount += 1;
+  }
   for (const delNode of getWordElementsByLocalName(xmlDoc, "del")) {
     if (!delNode.parentNode || !authorMatchesNode(delNode, filter)) continue;
     if (isParagraphMarkRevisionMarker(delNode)) {
@@ -15660,7 +15702,7 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
     operationWarnings.push("Input was sanitized; pass sanitizeInput: false to disable.");
   }
   let structuredAnalysis = null;
-  if (options.structuredContent !== false) {
+  if (options.structuredContent !== false && options.literalTextEdit !== true) {
     structuredAnalysis = analyzeStructuredContent(sanitizedText);
     if (!structuredAnalysis.valid) {
       if (options.explicitStructuredContent === true) {
@@ -15679,13 +15721,16 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
     }
   }
   const { cleanText: cleanModifiedText, formatHints } = preprocessMarkdown(sanitizedText);
-  const hasTextChanges = existingRevisionsPolicy === "slice-cross-author" ? cleanModifiedText !== originalText : cleanModifiedText.trim() !== originalText.trim();
-  const hasFormatHints = formatHints.length > 0;
   const { existingFormatHints, textSpans, paragraphs } = extractFormattingFromOoxml(xmlDoc);
+  const hasLiteralTextChanges = existingRevisionsPolicy === "slice-cross-author" ? cleanModifiedText !== originalText : cleanModifiedText.trim() !== originalText.trim();
+  const hasListStructureChange = !hasLiteralTextChanges && options.explicitStructuredContent === true && isListTargetLoose(cleanModifiedText) && !sourceMatchesListShape(paragraphs, cleanModifiedText);
+  const hasTextChanges = hasLiteralTextChanges || hasListStructureChange;
+  const hasFormatHints = formatHints.length > 0;
   const hasExistingFormatting = existingFormatHints.length > 0;
-  const visibleText = textSpans.map((span) => textSpanVisibleText(span)).join("");
+  const { textSpans: targetSpans } = buildTextSpansFromParagraphs(paragraphs);
+  const visibleText = targetSpans.map((span) => textSpanVisibleText(span)).join("");
   const targetFound = originalText.includes("\n") || originalText.includes("\r") ? originalText.split(/\r?\n/).map(normalizeTargetText).filter(Boolean).every((line) => paragraphs.some((paragraph) => {
-    const paragraphText = textSpans.filter((span) => span.paragraph === paragraph).map(textSpanVisibleText).join("");
+    const paragraphText = targetSpans.filter((span) => span.paragraph === paragraph).map(textSpanVisibleText).join("");
     return normalizeTargetText(paragraphText).includes(line);
   })) : visibleText.includes(originalText.trim()) || visibleText.replace(/[\t\n\u2011]/g, "").includes(originalText.trim().replace(/[\t\n\u2011]/g, "")) || normalizeTargetText(visibleText).includes(normalizeTargetText(originalText));
   if (hasTextChanges && typeof originalText === "string" && originalText.trim() && !targetFound) {
@@ -15799,7 +15844,7 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
   const tables = getElementsByTagNSOrTag(xmlDoc, NS_W, "tbl");
   const hasTables = tables.length > 0;
   const isMarkdownTable = /^\|.+\|/.test(cleanModifiedText.trim()) && cleanModifiedText.includes("\n");
-  const isTargetList = isListTargetLoose(cleanModifiedText);
+  const isTargetList = options.literalTextEdit !== true && isListTargetLoose(cleanModifiedText);
   const isStructuredContent = options.structuredContent !== false && structuredAnalysis?.requiresStructuredContent === true;
   const tableCellContext = initialTableCellContext;
   const usesSurgicalTextMode = hasTables || existingRevisionsPolicy === "slice-cross-author";
@@ -15914,6 +15959,10 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
     throw caught;
   }
 }
+function sourceMatchesListShape(paragraphs, listText) {
+  const itemCount = String(listText).split(/\r?\n/).filter((line) => line.trim()).length;
+  return paragraphs.length === itemCount && paragraphs.every((paragraph) => getElementsByTagNSOrTag(paragraph, NS_W, "numPr").length > 0);
+}
 function normalizeTargetText(text2) {
   return String(text2 || "").replace(/[\t\n\u2011]/g, " ").replace(/\s+/g, " ").trim();
 }
@@ -16650,12 +16699,12 @@ function validateParagraphBoundaryMutation(targetParagraph, modifiedText, option
 }
 
 // core/list-targeting.js
-function getFirstDescendantByLocalName(node, localName2) {
-  if (!node || typeof node.getElementsByTagNameNS !== "function") return null;
-  const namespaced = node.getElementsByTagNameNS(WORD_MAIN_NS, localName2);
-  if (namespaced.length > 0) return namespaced[0];
-  const anyNs = node.getElementsByTagNameNS("*", localName2);
-  return anyNs.length > 0 ? anyNs[0] : null;
+function getDirectChildByLocalName(node, localName2) {
+  if (!node) return null;
+  for (const child of Array.from(node.childNodes || [])) {
+    if (child?.nodeType === 1 && child.localName === localName2) return child;
+  }
+  return null;
 }
 function readValAttribute(element) {
   if (!element) return null;
@@ -16772,15 +16821,15 @@ function buildListEntriesForInsertion(parsedItems, normalizedTargetText, anchorL
 }
 function getParagraphListInfo(paragraph) {
   if (!paragraph) return null;
-  const pPr = getFirstDescendantByLocalName(paragraph, "pPr");
+  const pPr = getDirectChildByLocalName(paragraph, "pPr");
   if (!pPr) return null;
-  const numPr = getFirstDescendantByLocalName(pPr, "numPr");
+  const numPr = getDirectChildByLocalName(pPr, "numPr");
   if (!numPr) return null;
-  const numIdEl = getFirstDescendantByLocalName(numPr, "numId");
+  const numIdEl = getDirectChildByLocalName(numPr, "numId");
   if (!numIdEl) return null;
   const numId = readValAttribute(numIdEl);
   if (!numId || numId === "0") return null;
-  const ilvlEl = getFirstDescendantByLocalName(numPr, "ilvl");
+  const ilvlEl = getDirectChildByLocalName(numPr, "ilvl");
   const ilvlRaw = readValAttribute(ilvlEl);
   const ilvl = Number.parseInt(ilvlRaw || "0", 10);
   return {
@@ -17190,8 +17239,13 @@ function enforceListBindingOnParagraphNodes(nodes, options = {}) {
   }
   return updated;
 }
+function parseOxmlFragment(oxml) {
+  const text2 = String(oxml || "");
+  const declared = /xmlns:w\s*=/.test(text2);
+  return parseOoxmlSafe(declared ? text2 : `<w:root xmlns:w="${NS_W}">${text2}</w:root>`, "application/xml").doc;
+}
 function getFirstParagraphFromOxml(oxml) {
-  const doc = parseOoxmlSafe(oxml, "application/xml").doc;
+  const doc = parseOxmlFragment(oxml);
   if (!doc) return null;
   const parseError = getXmlParseError(doc);
   if (parseError) return null;
@@ -17218,17 +17272,17 @@ function setElementVal(element, value) {
   element.setAttribute("w:val", String(value));
 }
 function extractFirstParagraphNumIdFromOxml(oxml) {
-  const doc = parseOoxmlSafe(oxml, "application/xml").doc;
+  const doc = parseOxmlFragment(oxml);
   if (!doc) return null;
   const parseError = getXmlParseError(doc);
   if (parseError) return null;
   const paragraphs = getDocumentParagraphNodes(doc);
-  const firstParagraph = paragraphs[0] || null;
-  if (!firstParagraph) return null;
-  const numIdNodes = Array.from(firstParagraph.getElementsByTagNameNS("*", "numId"));
-  for (const numIdNode of numIdNodes) {
-    const numId = getElementId(numIdNode, ["w:val", "val"]);
-    if (numId != null) return String(numId);
+  for (const paragraph of paragraphs) {
+    const numIdNodes = Array.from(paragraph.getElementsByTagNameNS("*", "numId"));
+    for (const numIdNode of numIdNodes) {
+      const numId = getElementId(numIdNode, ["w:val", "val"]);
+      if (numId != null) return String(numId);
+    }
   }
   return null;
 }
@@ -17378,400 +17432,106 @@ async function executeSingleLineListStructuralFallback(plan, options = {}) {
   };
 }
 
-// core/redline-validation.js
-var REVISION_ID_ELEMENTS = /* @__PURE__ */ new Set(["ins", "del", "rPrChange", "pPrChange"]);
-var REVISION_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}T/;
-function localNameOf3(node) {
-  return String(node?.localName || node?.nodeName || "").replace(/^.*:/, "");
-}
-function elementsByLocalName(root, name) {
-  return Array.from(root.getElementsByTagName("*")).filter((el) => localNameOf3(el) === name);
-}
-function wordAttribute3(node, name) {
-  return node.getAttribute(`w:${name}`) || node.getAttribute(name) || "";
-}
-function xmlSpaceAttribute(node) {
-  return node.getAttribute("xml:space") || node.getAttribute("space") || node.getAttributeNS?.("http://www.w3.org/XML/1998/namespace", "space") || "";
-}
-function isParagraphMarkRevision(node) {
-  return localNameOf3(node.parentNode) === "rPr";
-}
-function parseOoxmlForValidation(oxml) {
-  const attempt = (xml) => {
-    const doc = parseXml(xml);
-    const parseError = doc.getElementsByTagName("parsererror")[0];
-    if (parseError) {
-      throw new Error(parseError.textContent || "XML parse error");
-    }
-    return doc;
-  };
-  try {
-    return { doc: attempt(oxml) };
-  } catch {
-    try {
-      return { doc: attempt(`<w:root xmlns:w="${NS_W}">${oxml}</w:root>`) };
-    } catch (error2) {
-      return { error: error2?.message || "XML parse error" };
-    }
+// services/numbering-helpers.js
+function parseIntegerAttribute(element, names) {
+  if (!element || !Array.isArray(names)) return null;
+  for (const name of names) {
+    const raw = element.getAttribute(name);
+    if (raw == null || raw === "") continue;
+    const parsed = Number.parseInt(String(raw), 10);
+    if (Number.isFinite(parsed)) return parsed;
   }
+  return null;
 }
-function validateRedlineOoxml(oxml) {
-  const issues = [];
-  const addIssue = (code, severity, message) => issues.push({ code, severity, message });
-  const isDomNode = oxml && typeof oxml === "object" && (oxml.nodeType === 9 || oxml.nodeType === 1);
-  if (!isDomNode && (typeof oxml !== "string" || oxml.trim() === "")) {
-    addIssue("PARSE_ERROR", "error", "Input is not non-empty OOXML or a parsed XML DOM.");
-    return { valid: false, issues };
-  }
-  const { doc, error: error2 } = isDomNode ? { doc: oxml.nodeType === 9 ? oxml : oxml.ownerDocument } : parseOoxmlForValidation(oxml);
-  if (!doc) {
-    addIssue("PARSE_ERROR", "error", `OOXML does not parse as XML: ${error2}`);
-    return { valid: false, issues };
-  }
-  const insElements = elementsByLocalName(doc, "ins");
-  const delElements = elementsByLocalName(doc, "del");
-  const revisions = insElements.concat(delElements);
-  for (const paragraph of elementsByLocalName(doc, "p")) {
-    const nested = Array.from(paragraph.getElementsByTagName("*")).find((el) => el !== paragraph && localNameOf3(el) === "p");
-    if (nested) {
-      addIssue("NESTED_PARAGRAPH", "error", `<${paragraph.nodeName}> contains nested <${nested.nodeName}>.`);
-    }
-  }
-  for (const body of elementsByLocalName(doc, "body")) {
-    const children = Array.from(body.childNodes || []).filter((child) => child.nodeType === 1);
-    const sectPrIndexes = children.map((child, index) => localNameOf3(child) === "sectPr" ? index : -1).filter((index) => index >= 0);
-    if (sectPrIndexes.length > 1) {
-      addIssue("MULTIPLE_BODY_SECTPR", "error", "<w:body> contains multiple direct <w:sectPr> elements.");
-    } else if (sectPrIndexes.length === 1 && sectPrIndexes[0] !== children.length - 1) {
-      addIssue("SECTPR_NOT_LAST", "error", "<w:sectPr> is not the last element child of <w:body>.");
-    }
+function nextAvailableId(startId, occupiedIds, maxPreferred = null) {
+  let candidate = Number.isInteger(startId) && startId > 0 ? startId : 1;
+  const occupied = occupiedIds instanceof Set ? occupiedIds : /* @__PURE__ */ new Set();
+  while (occupied.has(candidate)) {
+    candidate += 1;
   }
-  for (const revision of revisions) {
-    const nested = Array.from(revision.getElementsByTagName("*")).filter((el) => el !== revision && ["ins", "del"].includes(localNameOf3(el)));
-    const invalidNested = nested.find((candidate) => {
-      if (localNameOf3(revision) !== "ins" || localNameOf3(candidate) !== "del") return true;
-      return candidate.parentNode !== revision;
-    });
-    if (invalidNested) {
-      addIssue(
-        "NESTED_REVISION",
-        "error",
-        `<${revision.nodeName}> (w:id="${wordAttribute3(revision, "id")}") contains invalid nested <${invalidNested.nodeName}>.`
-      );
+  if (Number.isInteger(maxPreferred) && maxPreferred > 0 && candidate > maxPreferred) {
+    for (let probe = 1; probe <= maxPreferred; probe += 1) {
+      if (!occupied.has(probe)) return probe;
     }
   }
-  for (const del of delElements) {
-    const plainTextNodes = elementsByLocalName(del, "t");
-    if (plainTextNodes.length > 0) {
-      addIssue(
-        "DEL_CONTAINS_T",
-        "error",
-        `<w:del> (w:id="${wordAttribute3(del, "id")}") contains <w:t>; deleted text must use <w:delText>.`
-      );
+  return candidate;
+}
+function createDynamicNumberingIdState(numberingXml, options = {}) {
+  const minId = Number.isInteger(options?.minId) && options.minId > 0 ? options.minId : 1;
+  const maxPreferred = Number.isInteger(options?.maxPreferred) && options.maxPreferred >= minId ? options.maxPreferred : 32767;
+  const usedNumIds = /* @__PURE__ */ new Set();
+  const usedAbstractNumIds = /* @__PURE__ */ new Set();
+  if (String(numberingXml || "").trim()) {
+    try {
+      const numberingDoc = parseOoxml(numberingXml);
+      const abstractNums = Array.from(numberingDoc.getElementsByTagNameNS("*", "abstractNum"));
+      const nums = Array.from(numberingDoc.getElementsByTagNameNS("*", "num"));
+      for (const abstractNum of abstractNums) {
+        const id = parseIntegerAttribute(abstractNum, ["w:abstractNumId", "abstractNumId"]);
+        if (id != null) usedAbstractNumIds.add(id);
+      }
+      for (const num of nums) {
+        const id = parseIntegerAttribute(num, ["w:numId", "numId"]);
+        if (id != null) usedNumIds.add(id);
+      }
+    } catch {
     }
   }
-  for (const revision of revisions) {
-    const missing = [];
-    if (!wordAttribute3(revision, "id")) missing.push("w:id");
-    if (!wordAttribute3(revision, "author")) missing.push("w:author");
-    if (!REVISION_DATE_PATTERN.test(wordAttribute3(revision, "date"))) missing.push("w:date");
-    if (missing.length > 0) {
-      addIssue(
-        "MISSING_REVISION_METADATA",
-        "error",
-        `<${revision.nodeName}> is missing or has malformed ${missing.join(", ")}.`
-      );
-    }
+  const maxUsedNumId = usedNumIds.size > 0 ? Math.max(...usedNumIds) : 0;
+  const maxUsedAbstractNumId = usedAbstractNumIds.size > 0 ? Math.max(...usedAbstractNumIds) : 0;
+  const baseNumId = Math.max(minId, maxUsedNumId + 1);
+  const baseAbstractNumId = Math.max(minId, maxUsedAbstractNumId + 1);
+  return {
+    // Kept so list edits can recognise which existing definition a source list uses and continue it.
+    sourceNumberingXml: String(numberingXml || ""),
+    nextNumId: nextAvailableId(baseNumId, usedNumIds, maxPreferred),
+    nextAbstractNumId: nextAvailableId(baseAbstractNumId, usedAbstractNumIds, maxPreferred),
+    usedNumIds,
+    usedAbstractNumIds,
+    minId,
+    maxPreferred
+  };
+}
+function normalizeNumberingIdState(state) {
+  if (!state || typeof state !== "object") return null;
+  if (!(state.usedNumIds instanceof Set)) state.usedNumIds = /* @__PURE__ */ new Set();
+  if (!(state.usedAbstractNumIds instanceof Set)) state.usedAbstractNumIds = /* @__PURE__ */ new Set();
+  if (!Number.isInteger(state.minId) || state.minId < 1) {
+    state.minId = 1;
   }
-  const seenIds = /* @__PURE__ */ new Set();
-  for (const node of Array.from(doc.getElementsByTagName("*"))) {
-    if (!REVISION_ID_ELEMENTS.has(localNameOf3(node))) continue;
-    const id = wordAttribute3(node, "id");
-    if (!id) continue;
-    if (seenIds.has(id)) {
-      addIssue("DUPLICATE_REVISION_ID", "error", `Revision id ${id} appears more than once.`);
-    }
-    seenIds.add(id);
+  if (!Number.isInteger(state.maxPreferred) || state.maxPreferred < state.minId) {
+    state.maxPreferred = 32767;
   }
-  const textNodes = elementsByLocalName(doc, "t").concat(elementsByLocalName(doc, "delText"));
-  for (const node of textNodes) {
-    const text2 = node.textContent || "";
-    if (/^\s|\s$/.test(text2) && xmlSpaceAttribute(node) !== "preserve") {
-      addIssue(
-        "MISSING_SPACE_PRESERVE",
-        "error",
-        `<${node.nodeName}> has boundary whitespace without xml:space="preserve".`
-      );
-    }
-    if (text2 === "") {
-      addIssue("EMPTY_TEXT_ELEMENT", "warning", `<${node.nodeName}> is empty.`);
-    }
+  if (!Number.isInteger(state.nextNumId) || state.nextNumId < state.minId) {
+    state.nextNumId = state.minId;
   }
-  for (const revision of revisions) {
-    if (isParagraphMarkRevision(revision)) continue;
-    const hasElementChild = Array.from(revision.childNodes || []).some((child) => child.nodeType === 1);
-    if (!hasElementChild) {
-      addIssue(
-        "EMPTY_REVISION_WRAPPER",
-        "warning",
-        `<${revision.nodeName}> (w:id="${wordAttribute3(revision, "id")}") wraps no content.`
-      );
-    }
+  if (!Number.isInteger(state.nextAbstractNumId) || state.nextAbstractNumId < state.minId) {
+    state.nextAbstractNumId = state.minId;
   }
-  for (const resurrection of findForeignDeletedParagraphResurrections(doc)) {
-    const ownerAuthor = resurrection.ownerAuthor || "unattributed";
-    addIssue(
-      "FOREIGN_PARAGRAPH_MARK_DELETION",
-      "warning",
-      `Paragraph deleted by ${ownerAuthor} also contains non-empty insertion content from another author; Accept/Reject lifecycle may not preserve the apparent restoration.`
-    );
+  state.nextNumId = nextAvailableId(state.nextNumId, state.usedNumIds, state.maxPreferred);
+  state.nextAbstractNumId = nextAvailableId(state.nextAbstractNumId, state.usedAbstractNumIds, state.maxPreferred);
+  return state;
+}
+function reserveNextNumberingId(state, kind = "num") {
+  const normalized = normalizeNumberingIdState(state);
+  if (!normalized) return null;
+  const useAbstract = kind === "abstract";
+  const id = useAbstract ? normalized.nextAbstractNumId : normalized.nextNumId;
+  if (!Number.isInteger(id) || id < 1) return null;
+  if (useAbstract) {
+    normalized.usedAbstractNumIds.add(id);
+    normalized.nextAbstractNumId = nextAvailableId(id + 1, normalized.usedAbstractNumIds, normalized.maxPreferred);
+  } else {
+    normalized.usedNumIds.add(id);
+    normalized.nextNumId = nextAvailableId(id + 1, normalized.usedNumIds, normalized.maxPreferred);
   }
-  return { valid: !issues.some((issue) => issue.severity === "error"), issues };
+  return id;
 }
-
-// core/table-targeting.js
-function getDirectWordChildren(element, localName2) {
-  if (!element) return [];
-  return Array.from(element.childNodes || []).filter(
-    (node) => node && node.nodeType === 1 && node.namespaceURI === WORD_MAIN_NS && node.localName === localName2
-  );
-}
-function escapeMarkdownCell(text2) {
-  return String(text2 || "").replace(/\|/g, "\\|").replace(/\r?\n/g, "<br>");
-}
-function extractTableMatrix(tableElement) {
-  const rowElements = getDirectWordChildren(tableElement, "tr");
-  const matrix = rowElements.map((row) => {
-    const cellElements = getDirectWordChildren(row, "tc");
-    return cellElements.map((cell) => {
-      const paragraphs = getDirectWordChildren(cell, "p");
-      if (paragraphs.length === 0) return normalizeWhitespaceForTargeting(getParagraphText(cell));
-      const lines = paragraphs.map((p) => normalizeWhitespaceForTargeting(getParagraphText(p))).filter(Boolean);
-      return lines.join("\n");
-    });
-  });
-  const columnCount = matrix.reduce((max2, row) => Math.max(max2, row.length), 0);
-  matrix.forEach((row) => {
-    while (row.length < columnCount) row.push("");
-  });
-  return { matrix, rowElements, columnCount };
-}
-function tableMatrixToMarkdown(matrix, columnCount) {
-  if (!Array.isArray(matrix) || matrix.length === 0 || columnCount <= 0) return null;
-  const normalized = matrix.map((row) => {
-    const copy = Array.isArray(row) ? row.slice(0, columnCount) : [];
-    while (copy.length < columnCount) copy.push("");
-    return copy;
-  });
-  const header = normalized[0];
-  const separator = new Array(columnCount).fill("---");
-  const bodyRows = normalized.slice(1);
-  const toLine = (row) => `| ${row.map((cell) => escapeMarkdownCell(cell)).join(" | ")} |`;
-  return [toLine(header), toLine(separator), ...bodyRows.map(toLine)].join("\n");
-}
-function isSymmetricLabelRow(rowValues) {
-  if (!Array.isArray(rowValues) || rowValues.length < 2) return false;
-  const normalized = rowValues.map((value) => normalizeWhitespaceForTargeting(value)).filter(Boolean);
-  if (normalized.length < 2) return false;
-  return normalized.every((value) => value === normalized[0]);
-}
-function isLikelyStructuredTableSourceParagraph(text2) {
-  const normalized = String(text2 || "").trim();
-  if (!normalized) return false;
-  if (/^and$/i.test(normalized)) return true;
-  if (/^\[.*\]$/.test(normalized)) return true;
-  if (/^\(.*\)$/.test(normalized)) return true;
-  if (/:\s*$/.test(normalized)) return true;
-  if (normalized.length <= 90 && !/[.!?]$/.test(normalized) && /[:\[\]()]/.test(normalized)) return true;
-  if (/^[\[(]/.test(normalized)) return true;
-  return false;
-}
-function inferTableReplacementParagraphBlock(startParagraph, options = {}) {
-  const maxScan = Number.isInteger(options?.maxScan) && options.maxScan > 0 ? options.maxScan : 10;
-  const paragraphTextGetter = typeof options?.getParagraphText === "function" ? options.getParagraphText : getParagraphText;
-  if (!startParagraph || !startParagraph.parentNode) return null;
-  const block = [startParagraph];
-  let cursor = startParagraph.nextSibling;
-  let scanned = 0;
-  while (cursor && scanned < maxScan) {
-    scanned += 1;
-    const nextCursor = cursor.nextSibling;
-    if (cursor.nodeType !== 1 || cursor.namespaceURI !== WORD_MAIN_NS || cursor.localName !== "p") {
-      cursor = nextCursor;
-      continue;
-    }
-    const text2 = String(paragraphTextGetter(cursor) || "").trim();
-    if (!text2) {
-      if (block.length > 1) break;
-      cursor = nextCursor;
-      continue;
-    }
-    if (!isLikelyStructuredTableSourceParagraph(text2)) break;
-    block.push(cursor);
-    cursor = nextCursor;
-  }
-  return block.length > 1 ? block : null;
-}
-function synthesizeTableMarkdownFromMultilineCellEdit(targetParagraph, modifiedText, options = {}) {
-  const onInfo = typeof options.onInfo === "function" ? options.onInfo : () => {
-  };
-  const onWarn = typeof options.onWarn === "function" ? options.onWarn : () => {
-  };
-  const rawModified = String(modifiedText || "");
-  if (!rawModified.includes("\n")) return null;
-  if (isMarkdownTableText(rawModified)) return null;
-  const lines = rawModified.split(/\r?\n/g).map((line) => line.trim()).filter(Boolean);
-  if (lines.length < 2) return null;
-  const tableElement = options.tableElement || findContainingWordElement(targetParagraph, "tbl");
-  const rowElement = findContainingWordElement(targetParagraph, "tr");
-  const cellElement = findContainingWordElement(targetParagraph, "tc");
-  if (!tableElement || !rowElement || !cellElement) return null;
-  const currentParagraphText = normalizeWhitespaceForTargeting(
-    options.currentParagraphText || getParagraphText(targetParagraph)
-  );
-  const firstLine = normalizeWhitespaceForTargeting(lines[0]);
-  if (currentParagraphText && firstLine && firstLine !== currentParagraphText) {
-    onWarn("[Table] Multiline cell text did not anchor to original cell text; skipping table-row synthesis heuristic.");
-    return null;
-  }
-  const { matrix, rowElements, columnCount } = extractTableMatrix(tableElement);
-  if (matrix.length === 0 || columnCount === 0) return null;
-  const rowIndex = rowElements.indexOf(rowElement);
-  const cellElements = getDirectWordChildren(rowElement, "tc");
-  const colIndex = cellElements.indexOf(cellElement);
-  if (rowIndex < 0 || colIndex < 0 || colIndex >= columnCount) return null;
-  matrix[rowIndex][colIndex] = lines[0];
-  const mirrorAcrossColumns = isSymmetricLabelRow(matrix[rowIndex]);
-  if (mirrorAcrossColumns) {
-    onInfo("[Table] Symmetric row detected; mirroring inserted row values across columns.");
-  }
-  for (let i2 = 1; i2 < lines.length; i2++) {
-    const insertIndex = rowIndex + i2;
-    const extraValue = lines[i2];
-    if (insertIndex < matrix.length && !normalizeWhitespaceForTargeting(matrix[insertIndex][colIndex])) {
-      if (mirrorAcrossColumns) {
-        for (let col = 0; col < columnCount; col++) {
-          if (!normalizeWhitespaceForTargeting(matrix[insertIndex][col])) {
-            matrix[insertIndex][col] = extraValue;
-          }
-        }
-      } else {
-        matrix[insertIndex][colIndex] = extraValue;
-      }
-    } else {
-      const newRow = new Array(columnCount).fill("");
-      if (mirrorAcrossColumns) {
-        for (let col = 0; col < columnCount; col++) newRow[col] = extraValue;
-      } else {
-        newRow[colIndex] = extraValue;
-      }
-      matrix.splice(Math.min(insertIndex, matrix.length), 0, newRow);
-    }
-  }
-  const markdown = tableMatrixToMarkdown(matrix, columnCount);
-  if (!markdown) return null;
-  onInfo("[Table] Synthesized full markdown table from multiline cell edit for table-scope reconciliation.");
-  return markdown;
-}
-
-// services/numbering-helpers.js
-function parseIntegerAttribute(element, names) {
-  if (!element || !Array.isArray(names)) return null;
-  for (const name of names) {
-    const raw = element.getAttribute(name);
-    if (raw == null || raw === "") continue;
-    const parsed = Number.parseInt(String(raw), 10);
-    if (Number.isFinite(parsed)) return parsed;
-  }
-  return null;
-}
-function nextAvailableId(startId, occupiedIds, maxPreferred = null) {
-  let candidate = Number.isInteger(startId) && startId > 0 ? startId : 1;
-  const occupied = occupiedIds instanceof Set ? occupiedIds : /* @__PURE__ */ new Set();
-  while (occupied.has(candidate)) {
-    candidate += 1;
-  }
-  if (Number.isInteger(maxPreferred) && maxPreferred > 0 && candidate > maxPreferred) {
-    for (let probe = 1; probe <= maxPreferred; probe += 1) {
-      if (!occupied.has(probe)) return probe;
-    }
-  }
-  return candidate;
-}
-function createDynamicNumberingIdState(numberingXml, options = {}) {
-  const minId = Number.isInteger(options?.minId) && options.minId > 0 ? options.minId : 1;
-  const maxPreferred = Number.isInteger(options?.maxPreferred) && options.maxPreferred >= minId ? options.maxPreferred : 32767;
-  const usedNumIds = /* @__PURE__ */ new Set();
-  const usedAbstractNumIds = /* @__PURE__ */ new Set();
-  if (String(numberingXml || "").trim()) {
-    try {
-      const numberingDoc = parseOoxml(numberingXml);
-      const abstractNums = Array.from(numberingDoc.getElementsByTagNameNS("*", "abstractNum"));
-      const nums = Array.from(numberingDoc.getElementsByTagNameNS("*", "num"));
-      for (const abstractNum of abstractNums) {
-        const id = parseIntegerAttribute(abstractNum, ["w:abstractNumId", "abstractNumId"]);
-        if (id != null) usedAbstractNumIds.add(id);
-      }
-      for (const num of nums) {
-        const id = parseIntegerAttribute(num, ["w:numId", "numId"]);
-        if (id != null) usedNumIds.add(id);
-      }
-    } catch {
-    }
-  }
-  const maxUsedNumId = usedNumIds.size > 0 ? Math.max(...usedNumIds) : 0;
-  const maxUsedAbstractNumId = usedAbstractNumIds.size > 0 ? Math.max(...usedAbstractNumIds) : 0;
-  const baseNumId = Math.max(minId, maxUsedNumId + 1);
-  const baseAbstractNumId = Math.max(minId, maxUsedAbstractNumId + 1);
-  return {
-    nextNumId: nextAvailableId(baseNumId, usedNumIds, maxPreferred),
-    nextAbstractNumId: nextAvailableId(baseAbstractNumId, usedAbstractNumIds, maxPreferred),
-    usedNumIds,
-    usedAbstractNumIds,
-    minId,
-    maxPreferred
-  };
-}
-function normalizeNumberingIdState(state) {
-  if (!state || typeof state !== "object") return null;
-  if (!(state.usedNumIds instanceof Set)) state.usedNumIds = /* @__PURE__ */ new Set();
-  if (!(state.usedAbstractNumIds instanceof Set)) state.usedAbstractNumIds = /* @__PURE__ */ new Set();
-  if (!Number.isInteger(state.minId) || state.minId < 1) {
-    state.minId = 1;
-  }
-  if (!Number.isInteger(state.maxPreferred) || state.maxPreferred < state.minId) {
-    state.maxPreferred = 32767;
-  }
-  if (!Number.isInteger(state.nextNumId) || state.nextNumId < state.minId) {
-    state.nextNumId = state.minId;
-  }
-  if (!Number.isInteger(state.nextAbstractNumId) || state.nextAbstractNumId < state.minId) {
-    state.nextAbstractNumId = state.minId;
-  }
-  state.nextNumId = nextAvailableId(state.nextNumId, state.usedNumIds, state.maxPreferred);
-  state.nextAbstractNumId = nextAvailableId(state.nextAbstractNumId, state.usedAbstractNumIds, state.maxPreferred);
-  return state;
-}
-function reserveNextNumberingId(state, kind = "num") {
-  const normalized = normalizeNumberingIdState(state);
-  if (!normalized) return null;
-  const useAbstract = kind === "abstract";
-  const id = useAbstract ? normalized.nextAbstractNumId : normalized.nextNumId;
-  if (!Number.isInteger(id) || id < 1) return null;
-  if (useAbstract) {
-    normalized.usedAbstractNumIds.add(id);
-    normalized.nextAbstractNumId = nextAvailableId(id + 1, normalized.usedAbstractNumIds, normalized.maxPreferred);
-  } else {
-    normalized.usedNumIds.add(id);
-    normalized.nextNumId = nextAvailableId(id + 1, normalized.usedNumIds, normalized.maxPreferred);
-  }
-  return id;
-}
-function reserveNextNumberingIdPair(state) {
-  const numId = reserveNextNumberingId(state, "num");
-  const abstractNumId = reserveNextNumberingId(state, "abstract");
-  if (numId == null || abstractNumId == null) return null;
-  return { numId, abstractNumId };
+function reserveNextNumberingIdPair(state) {
+  const numId = reserveNextNumberingId(state, "num");
+  const abstractNumId = reserveNextNumberingId(state, "abstract");
+  if (numId == null || abstractNumId == null) return null;
+  return { numId, abstractNumId };
 }
 function hasXmlParseError(doc) {
   if (!doc || !doc.documentElement) return true;
@@ -17824,134 +17584,507 @@ function overwriteParagraphNumIds(paragraphNodes, targetNumId) {
     }
   }
 }
-function extractFirstParagraphNumId(paragraphNodes) {
-  for (const node of paragraphNodes || []) {
-    const numIdNodes = Array.from(node?.getElementsByTagNameNS?.("*", "numId") || []);
-    for (const numIdNode of numIdNodes) {
-      const numId = getElementId2(numIdNode, ["w:val", "val"]);
-      if (numId != null) return String(numId);
+function extractFirstParagraphNumId(paragraphNodes) {
+  for (const node of paragraphNodes || []) {
+    const numIdNodes = Array.from(node?.getElementsByTagNameNS?.("*", "numId") || []);
+    for (const numIdNode of numIdNodes) {
+      const numId = getElementId2(numIdNode, ["w:val", "val"]);
+      if (numId != null) return String(numId);
+    }
+  }
+  return null;
+}
+function buildExplicitDecimalMultilevelNumberingXml(numId, abstractNumId, startAt) {
+  const safeNumId = String(numId);
+  const safeAbstractNumId = String(abstractNumId);
+  const safeStartAt = Number.isInteger(startAt) && startAt > 0 ? startAt : 1;
+  const levelsXml = Array.from({ length: 9 }, (_, level) => {
+    const lvlText = Array.from({ length: level + 1 }, (_2, i2) => `%${i2 + 1}`).join(".") + ".";
+    const left = 720 * (level + 1);
+    return `
+        <w:lvl w:ilvl="${level}">
+            <w:start w:val="1"/>
+            <w:numFmt w:val="decimal"/>
+            <w:lvlText w:val="${lvlText}"/>
+            <w:lvlJc w:val="left"/>
+            <w:pPr><w:ind w:left="${left}" w:hanging="360"/></w:pPr>
+        </w:lvl>`;
+  }).join("");
+  return `
+<w:numbering xmlns:w="${WORD_MAIN_NS}">
+    <w:abstractNum w:abstractNumId="${safeAbstractNumId}">
+        <w:multiLevelType w:val="multilevel"/>
+        ${levelsXml}
+    </w:abstractNum>
+    <w:num w:numId="${safeNumId}">
+        <w:abstractNumId w:val="${safeAbstractNumId}"/>
+        <w:lvlOverride w:ilvl="0">
+            <w:startOverride w:val="${safeStartAt}"/>
+        </w:lvlOverride>
+    </w:num>
+</w:numbering>`.trim();
+}
+function isTrackedDeletedParagraph(node) {
+  if (!node || node.nodeType !== 1 || node.localName !== "p") return false;
+  const pPr = Array.from(node.childNodes || []).find((child) => isDirectWordChild(child, "pPr"));
+  const rPr = pPr && Array.from(pPr.childNodes || []).find((child) => isDirectWordChild(child, "rPr"));
+  return !!rPr && Array.from(rPr.childNodes || []).some((child) => isDirectWordChild(child, "del"));
+}
+function paragraphNumIdNodes(node) {
+  return Array.from(node?.getElementsByTagNameNS?.("*", "numId") || []).filter((numIdNode) => numIdNode.parentNode?.localName === "numPr");
+}
+function levelFormats(abstractNum) {
+  const formats = /* @__PURE__ */ new Map();
+  for (const lvl of Array.from(abstractNum?.getElementsByTagNameNS?.("*", "lvl") || [])) {
+    const ilvl = getElementId2(lvl, ["w:ilvl", "ilvl"]);
+    const fmt = Array.from(lvl.getElementsByTagNameNS("*", "numFmt"))[0]?.getAttribute("w:val") || null;
+    if (ilvl != null && fmt) formats.set(ilvl, fmt);
+  }
+  return formats;
+}
+function normalizeListFormat(format) {
+  return format === "bullet" || format === "circle" || format === "square" ? "bullet" : format;
+}
+function abstractNumForNumId(numberingDoc, numId) {
+  const num = Array.from(numberingDoc.getElementsByTagNameNS("*", "num")).find((candidate) => getElementId2(candidate, ["w:numId", "numId"]) === numId);
+  const abstractId = num && getElementId2(Array.from(num.getElementsByTagNameNS("*", "abstractNumId"))[0], ["w:val", "val"]);
+  if (abstractId == null) return null;
+  return Array.from(numberingDoc.getElementsByTagNameNS("*", "abstractNum")).find((candidate) => getElementId2(candidate, ["w:abstractNumId", "abstractNumId"]) === abstractId) || null;
+}
+function reuseSourceListNumbering(numberingXml, replacementNodes, sourceParagraphs, numberingIdState) {
+  const sourceXml = numberingIdState?.sourceNumberingXml;
+  if (!numberingXml || !String(sourceXml || "").trim() || !Array.isArray(replacementNodes)) return null;
+  const sourceNumIds = /* @__PURE__ */ new Set();
+  for (const paragraph of sourceParagraphs || []) {
+    for (const numIdNode of paragraphNumIdNodes(paragraph)) {
+      const id = getElementId2(numIdNode, ["w:val", "val"]);
+      if (id != null && id !== 0) sourceNumIds.add(id);
+    }
+  }
+  if (sourceNumIds.size !== 1) return null;
+  const [sourceNumId] = sourceNumIds;
+  const sourceDoc = parseOoxml(sourceXml);
+  const payloadDoc = parseOoxml(numberingXml);
+  if (hasXmlParseError(sourceDoc) || hasXmlParseError(payloadDoc)) return null;
+  const sourceAbstract = abstractNumForNumId(sourceDoc, sourceNumId);
+  if (!sourceAbstract) return null;
+  const sourceFormats = levelFormats(sourceAbstract);
+  const newParagraphNumIds = [];
+  for (const node of replacementNodes) {
+    if (isTrackedDeletedParagraph(node)) continue;
+    for (const numIdNode of paragraphNumIdNodes(node)) {
+      const ilvlNode = Array.from(numIdNode.parentNode.childNodes || []).find((child) => child.localName === "ilvl");
+      newParagraphNumIds.push({
+        numId: getElementId2(numIdNode, ["w:val", "val"]),
+        ilvl: ilvlNode ? getElementId2(ilvlNode, ["w:val", "val"]) ?? 0 : 0
+      });
+    }
+  }
+  if (newParagraphNumIds.length === 0) return null;
+  const payloadFormats = /* @__PURE__ */ new Map();
+  for (const { numId, ilvl } of newParagraphNumIds) {
+    if (numId == null) return null;
+    if (!payloadFormats.has(numId)) {
+      const abstract = abstractNumForNumId(payloadDoc, numId);
+      if (!abstract) return null;
+      payloadFormats.set(numId, levelFormats(abstract));
+    }
+    const generated = payloadFormats.get(numId).get(ilvl);
+    const existing = sourceFormats.get(ilvl);
+    if (!generated || !existing || normalizeListFormat(generated) !== normalizeListFormat(existing)) return null;
+  }
+  const clonedNodes = replacementNodes.map((node) => node?.cloneNode ? node.cloneNode(true) : node);
+  for (const node of clonedNodes) {
+    if (isTrackedDeletedParagraph(node)) continue;
+    for (const numIdNode of paragraphNumIdNodes(node)) setElementVal2(numIdNode, sourceNumId);
+  }
+  return { numId: sourceNumId, replacementNodes: clonedNodes };
+}
+function remapNumberingPayloadForDocument(numberingXml, replacementNodes, numberingIdState) {
+  const numberingDoc = parseOoxml(numberingXml);
+  if (hasXmlParseError(numberingDoc)) {
+    return {
+      numberingXml: String(numberingXml || ""),
+      replacementNodes: Array.isArray(replacementNodes) ? replacementNodes.map((node) => node?.cloneNode ? node.cloneNode(true) : node) : []
+    };
+  }
+  const abstractNumMap = /* @__PURE__ */ new Map();
+  const numIdMap = /* @__PURE__ */ new Map();
+  const abstractNums = Array.from(numberingDoc.getElementsByTagNameNS("*", "abstractNum"));
+  for (const abstractNum of abstractNums) {
+    const oldId = getElementId2(abstractNum, ["w:abstractNumId", "abstractNumId"]);
+    if (oldId == null) continue;
+    const newId = reserveNextNumberingId(numberingIdState, "abstract");
+    if (newId == null) continue;
+    abstractNumMap.set(oldId, newId);
+    setElementId(abstractNum, "w:abstractNumId", newId);
+  }
+  const nums = Array.from(numberingDoc.getElementsByTagNameNS("*", "num"));
+  for (const num of nums) {
+    const oldNumId = getElementId2(num, ["w:numId", "numId"]);
+    if (oldNumId == null) continue;
+    const newNumId = reserveNextNumberingId(numberingIdState, "num");
+    if (newNumId == null) continue;
+    numIdMap.set(oldNumId, newNumId);
+    setElementId(num, "w:numId", newNumId);
+    const abstractNumIdNode = Array.from(num.getElementsByTagNameNS("*", "abstractNumId"))[0] || null;
+    if (abstractNumIdNode) {
+      const oldAbsRef = getElementId2(abstractNumIdNode, ["w:val", "val"]);
+      if (oldAbsRef != null && abstractNumMap.has(oldAbsRef)) {
+        setElementVal2(abstractNumIdNode, abstractNumMap.get(oldAbsRef));
+      }
+    }
+  }
+  const clonedNodes = Array.isArray(replacementNodes) ? replacementNodes.map((node) => node?.cloneNode ? node.cloneNode(true) : node) : [];
+  for (const node of clonedNodes) {
+    if (isTrackedDeletedParagraph(node)) continue;
+    const numIdNodes = Array.from(node?.getElementsByTagNameNS?.("*", "numId") || []);
+    for (const numIdNode of numIdNodes) {
+      const oldNumRef = getElementId2(numIdNode, ["w:val", "val"]);
+      if (oldNumRef != null && numIdMap.has(oldNumRef)) {
+        setElementVal2(numIdNode, numIdMap.get(oldNumRef));
+      }
+    }
+  }
+  return {
+    numberingXml: serializeOoxml(numberingDoc),
+    replacementNodes: clonedNodes
+  };
+}
+function mergeNumberingXmlBySchemaOrder(existingNumberingXml, incomingNumberingXml) {
+  const existingText = String(existingNumberingXml || "");
+  const incomingText = String(incomingNumberingXml || "");
+  if (!incomingText.trim()) return existingText;
+  if (!existingText.trim()) return incomingText;
+  try {
+    const existingDoc = parseOoxml(existingText);
+    const incomingDoc = parseOoxml(incomingText);
+    if (hasXmlParseError(existingDoc) || hasXmlParseError(incomingDoc)) {
+      return existingText;
+    }
+    const existingRoot = existingDoc.documentElement;
+    const incomingRoot = incomingDoc.documentElement;
+    if (!existingRoot || !incomingRoot) return existingText;
+    const existingAbstractIds = new Set(
+      Array.from(existingRoot.childNodes || []).filter((node) => isDirectWordChild(node, "abstractNum")).map((node) => parseIntegerAttribute(node, ["w:abstractNumId", "abstractNumId"])).filter((id) => id != null)
+    );
+    const existingNumIds = new Set(
+      Array.from(existingRoot.childNodes || []).filter((node) => isDirectWordChild(node, "num")).map((node) => parseIntegerAttribute(node, ["w:numId", "numId"])).filter((id) => id != null)
+    );
+    for (const incomingNode of Array.from(incomingRoot.childNodes || [])) {
+      if (!isDirectWordChild(incomingNode, "abstractNum")) continue;
+      const incomingId = parseIntegerAttribute(incomingNode, ["w:abstractNumId", "abstractNumId"]);
+      if (incomingId == null || existingAbstractIds.has(incomingId)) continue;
+      insertNumberingNodeInSchemaOrder(existingRoot, existingDoc.importNode(incomingNode, true), "abstract");
+      existingAbstractIds.add(incomingId);
+    }
+    for (const incomingNode of Array.from(incomingRoot.childNodes || [])) {
+      if (!isDirectWordChild(incomingNode, "num")) continue;
+      const incomingId = parseIntegerAttribute(incomingNode, ["w:numId", "numId"]);
+      if (incomingId == null || existingNumIds.has(incomingId)) continue;
+      insertNumberingNodeInSchemaOrder(existingRoot, existingDoc.importNode(incomingNode, true), "num");
+      existingNumIds.add(incomingId);
+    }
+    return serializeOoxml(existingDoc);
+  } catch {
+    return existingText;
+  }
+}
+
+// core/redline-validation.js
+var REVISION_ID_ELEMENTS = /* @__PURE__ */ new Set(["ins", "del", "rPrChange", "pPrChange"]);
+var REVISION_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}T/;
+function localNameOf3(node) {
+  return String(node?.localName || node?.nodeName || "").replace(/^.*:/, "");
+}
+function elementsByLocalName(root, name) {
+  return Array.from(root.getElementsByTagName("*")).filter((el) => localNameOf3(el) === name);
+}
+function wordAttribute3(node, name) {
+  return node.getAttribute(`w:${name}`) || node.getAttribute(name) || "";
+}
+function xmlSpaceAttribute(node) {
+  return node.getAttribute("xml:space") || node.getAttribute("space") || node.getAttributeNS?.("http://www.w3.org/XML/1998/namespace", "space") || "";
+}
+function isParagraphMarkRevision(node) {
+  return localNameOf3(node.parentNode) === "rPr";
+}
+function parseOoxmlForValidation(oxml) {
+  const attempt = (xml) => {
+    const doc = parseXml(xml);
+    const parseError = doc.getElementsByTagName("parsererror")[0];
+    if (parseError) {
+      throw new Error(parseError.textContent || "XML parse error");
+    }
+    return doc;
+  };
+  try {
+    return { doc: attempt(oxml) };
+  } catch {
+    try {
+      return { doc: attempt(`<w:root xmlns:w="${NS_W}">${oxml}</w:root>`) };
+    } catch (error2) {
+      return { error: error2?.message || "XML parse error" };
+    }
+  }
+}
+function validateRedlineOoxml(oxml) {
+  const issues = [];
+  const addIssue = (code, severity, message) => issues.push({ code, severity, message });
+  const isDomNode = oxml && typeof oxml === "object" && (oxml.nodeType === 9 || oxml.nodeType === 1);
+  if (!isDomNode && (typeof oxml !== "string" || oxml.trim() === "")) {
+    addIssue("PARSE_ERROR", "error", "Input is not non-empty OOXML or a parsed XML DOM.");
+    return { valid: false, issues };
+  }
+  const { doc, error: error2 } = isDomNode ? { doc: oxml.nodeType === 9 ? oxml : oxml.ownerDocument } : parseOoxmlForValidation(oxml);
+  if (!doc) {
+    addIssue("PARSE_ERROR", "error", `OOXML does not parse as XML: ${error2}`);
+    return { valid: false, issues };
+  }
+  const insElements = elementsByLocalName(doc, "ins");
+  const delElements = elementsByLocalName(doc, "del");
+  const revisions = insElements.concat(delElements);
+  for (const paragraph of elementsByLocalName(doc, "p")) {
+    const nested = Array.from(paragraph.getElementsByTagName("*")).find((el) => el !== paragraph && localNameOf3(el) === "p");
+    if (nested) {
+      addIssue("NESTED_PARAGRAPH", "error", `<${paragraph.nodeName}> contains nested <${nested.nodeName}>.`);
+    }
+  }
+  for (const body of elementsByLocalName(doc, "body")) {
+    const children = Array.from(body.childNodes || []).filter((child) => child.nodeType === 1);
+    const sectPrIndexes = children.map((child, index) => localNameOf3(child) === "sectPr" ? index : -1).filter((index) => index >= 0);
+    if (sectPrIndexes.length > 1) {
+      addIssue("MULTIPLE_BODY_SECTPR", "error", "<w:body> contains multiple direct <w:sectPr> elements.");
+    } else if (sectPrIndexes.length === 1 && sectPrIndexes[0] !== children.length - 1) {
+      addIssue("SECTPR_NOT_LAST", "error", "<w:sectPr> is not the last element child of <w:body>.");
+    }
+  }
+  for (const revision of revisions) {
+    const nested = Array.from(revision.getElementsByTagName("*")).filter((el) => el !== revision && ["ins", "del"].includes(localNameOf3(el)));
+    const invalidNested = nested.find((candidate) => {
+      if (localNameOf3(revision) !== "ins" || localNameOf3(candidate) !== "del") return true;
+      return candidate.parentNode !== revision;
+    });
+    if (invalidNested) {
+      addIssue(
+        "NESTED_REVISION",
+        "error",
+        `<${revision.nodeName}> (w:id="${wordAttribute3(revision, "id")}") contains invalid nested <${invalidNested.nodeName}>.`
+      );
+    }
+  }
+  for (const del of delElements) {
+    const plainTextNodes = elementsByLocalName(del, "t");
+    if (plainTextNodes.length > 0) {
+      addIssue(
+        "DEL_CONTAINS_T",
+        "error",
+        `<w:del> (w:id="${wordAttribute3(del, "id")}") contains <w:t>; deleted text must use <w:delText>.`
+      );
+    }
+  }
+  for (const revision of revisions) {
+    const missing = [];
+    if (!wordAttribute3(revision, "id")) missing.push("w:id");
+    if (!wordAttribute3(revision, "author")) missing.push("w:author");
+    if (!REVISION_DATE_PATTERN.test(wordAttribute3(revision, "date"))) missing.push("w:date");
+    if (missing.length > 0) {
+      addIssue(
+        "MISSING_REVISION_METADATA",
+        "error",
+        `<${revision.nodeName}> is missing or has malformed ${missing.join(", ")}.`
+      );
+    }
+  }
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const node of Array.from(doc.getElementsByTagName("*"))) {
+    if (!REVISION_ID_ELEMENTS.has(localNameOf3(node))) continue;
+    const id = wordAttribute3(node, "id");
+    if (!id) continue;
+    if (seenIds.has(id)) {
+      addIssue("DUPLICATE_REVISION_ID", "error", `Revision id ${id} appears more than once.`);
+    }
+    seenIds.add(id);
+  }
+  const textNodes = elementsByLocalName(doc, "t").concat(elementsByLocalName(doc, "delText"));
+  for (const node of textNodes) {
+    const text2 = node.textContent || "";
+    if (/^\s|\s$/.test(text2) && xmlSpaceAttribute(node) !== "preserve") {
+      addIssue(
+        "MISSING_SPACE_PRESERVE",
+        "error",
+        `<${node.nodeName}> has boundary whitespace without xml:space="preserve".`
+      );
+    }
+    if (text2 === "") {
+      addIssue("EMPTY_TEXT_ELEMENT", "warning", `<${node.nodeName}> is empty.`);
+    }
+  }
+  for (const revision of revisions) {
+    if (isParagraphMarkRevision(revision)) continue;
+    const hasElementChild = Array.from(revision.childNodes || []).some((child) => child.nodeType === 1);
+    if (!hasElementChild) {
+      addIssue(
+        "EMPTY_REVISION_WRAPPER",
+        "warning",
+        `<${revision.nodeName}> (w:id="${wordAttribute3(revision, "id")}") wraps no content.`
+      );
+    }
+  }
+  for (const resurrection of findForeignDeletedParagraphResurrections(doc)) {
+    const ownerAuthor = resurrection.ownerAuthor || "unattributed";
+    addIssue(
+      "FOREIGN_PARAGRAPH_MARK_DELETION",
+      "warning",
+      `Paragraph deleted by ${ownerAuthor} also contains non-empty insertion content from another author; Accept/Reject lifecycle may not preserve the apparent restoration.`
+    );
+  }
+  return { valid: !issues.some((issue) => issue.severity === "error"), issues };
+}
+
+// core/table-targeting.js
+function getDirectWordChildren(element, localName2) {
+  if (!element) return [];
+  return Array.from(element.childNodes || []).filter(
+    (node) => node && node.nodeType === 1 && node.namespaceURI === WORD_MAIN_NS && node.localName === localName2
+  );
+}
+function escapeMarkdownCell(text2) {
+  return String(text2 || "").replace(/\|/g, "\\|").replace(/\r?\n/g, "<br>");
+}
+function extractTableMatrix(tableElement) {
+  const rowElements = getDirectWordChildren(tableElement, "tr");
+  const matrix = rowElements.map((row) => {
+    const cellElements = getDirectWordChildren(row, "tc");
+    return cellElements.map((cell) => {
+      const paragraphs = getDirectWordChildren(cell, "p");
+      if (paragraphs.length === 0) return normalizeWhitespaceForTargeting(getParagraphText(cell));
+      const lines = paragraphs.map((p) => normalizeWhitespaceForTargeting(getParagraphText(p))).filter(Boolean);
+      return lines.join("\n");
+    });
+  });
+  const columnCount = matrix.reduce((max2, row) => Math.max(max2, row.length), 0);
+  matrix.forEach((row) => {
+    while (row.length < columnCount) row.push("");
+  });
+  return { matrix, rowElements, columnCount };
+}
+function tableMatrixToMarkdown(matrix, columnCount) {
+  if (!Array.isArray(matrix) || matrix.length === 0 || columnCount <= 0) return null;
+  const normalized = matrix.map((row) => {
+    const copy = Array.isArray(row) ? row.slice(0, columnCount) : [];
+    while (copy.length < columnCount) copy.push("");
+    return copy;
+  });
+  const header = normalized[0];
+  const separator = new Array(columnCount).fill("---");
+  const bodyRows = normalized.slice(1);
+  const toLine = (row) => `| ${row.map((cell) => escapeMarkdownCell(cell)).join(" | ")} |`;
+  return [toLine(header), toLine(separator), ...bodyRows.map(toLine)].join("\n");
+}
+function isSymmetricLabelRow(rowValues) {
+  if (!Array.isArray(rowValues) || rowValues.length < 2) return false;
+  const normalized = rowValues.map((value) => normalizeWhitespaceForTargeting(value)).filter(Boolean);
+  if (normalized.length < 2) return false;
+  return normalized.every((value) => value === normalized[0]);
+}
+function isLikelyStructuredTableSourceParagraph(text2) {
+  const normalized = String(text2 || "").trim();
+  if (!normalized) return false;
+  if (/^and$/i.test(normalized)) return true;
+  if (/^\[.*\]$/.test(normalized)) return true;
+  if (/^\(.*\)$/.test(normalized)) return true;
+  if (/:\s*$/.test(normalized)) return true;
+  if (normalized.length <= 90 && !/[.!?]$/.test(normalized) && /[:\[\]()]/.test(normalized)) return true;
+  if (/^[\[(]/.test(normalized)) return true;
+  return false;
+}
+function inferTableReplacementParagraphBlock(startParagraph, options = {}) {
+  const maxScan = Number.isInteger(options?.maxScan) && options.maxScan > 0 ? options.maxScan : 10;
+  const paragraphTextGetter = typeof options?.getParagraphText === "function" ? options.getParagraphText : getParagraphText;
+  if (!startParagraph || !startParagraph.parentNode) return null;
+  const block = [startParagraph];
+  let cursor = startParagraph.nextSibling;
+  let scanned = 0;
+  while (cursor && scanned < maxScan) {
+    scanned += 1;
+    const nextCursor = cursor.nextSibling;
+    if (cursor.nodeType !== 1 || cursor.namespaceURI !== WORD_MAIN_NS || cursor.localName !== "p") {
+      cursor = nextCursor;
+      continue;
+    }
+    const text2 = String(paragraphTextGetter(cursor) || "").trim();
+    if (!text2) {
+      if (block.length > 1) break;
+      cursor = nextCursor;
+      continue;
     }
+    if (!isLikelyStructuredTableSourceParagraph(text2)) break;
+    block.push(cursor);
+    cursor = nextCursor;
   }
-  return null;
-}
-function buildExplicitDecimalMultilevelNumberingXml(numId, abstractNumId, startAt) {
-  const safeNumId = String(numId);
-  const safeAbstractNumId = String(abstractNumId);
-  const safeStartAt = Number.isInteger(startAt) && startAt > 0 ? startAt : 1;
-  const levelsXml = Array.from({ length: 9 }, (_, level) => {
-    const lvlText = Array.from({ length: level + 1 }, (_2, i2) => `%${i2 + 1}`).join(".") + ".";
-    const left = 720 * (level + 1);
-    return `
-        <w:lvl w:ilvl="${level}">
-            <w:start w:val="1"/>
-            <w:numFmt w:val="decimal"/>
-            <w:lvlText w:val="${lvlText}"/>
-            <w:lvlJc w:val="left"/>
-            <w:pPr><w:ind w:left="${left}" w:hanging="360"/></w:pPr>
-        </w:lvl>`;
-  }).join("");
-  return `
-<w:numbering xmlns:w="${WORD_MAIN_NS}">
-    <w:abstractNum w:abstractNumId="${safeAbstractNumId}">
-        <w:multiLevelType w:val="multilevel"/>
-        ${levelsXml}
-    </w:abstractNum>
-    <w:num w:numId="${safeNumId}">
-        <w:abstractNumId w:val="${safeAbstractNumId}"/>
-        <w:lvlOverride w:ilvl="0">
-            <w:startOverride w:val="${safeStartAt}"/>
-        </w:lvlOverride>
-    </w:num>
-</w:numbering>`.trim();
+  return block.length > 1 ? block : null;
 }
-function remapNumberingPayloadForDocument(numberingXml, replacementNodes, numberingIdState) {
-  const numberingDoc = parseOoxml(numberingXml);
-  if (hasXmlParseError(numberingDoc)) {
-    return {
-      numberingXml: String(numberingXml || ""),
-      replacementNodes: Array.isArray(replacementNodes) ? replacementNodes.map((node) => node?.cloneNode ? node.cloneNode(true) : node) : []
-    };
+function synthesizeTableMarkdownFromMultilineCellEdit(targetParagraph, modifiedText, options = {}) {
+  const onInfo = typeof options.onInfo === "function" ? options.onInfo : () => {
+  };
+  const onWarn = typeof options.onWarn === "function" ? options.onWarn : () => {
+  };
+  const rawModified = String(modifiedText || "");
+  if (!rawModified.includes("\n")) return null;
+  if (isMarkdownTableText(rawModified)) return null;
+  const lines = rawModified.split(/\r?\n/g).map((line) => line.trim()).filter(Boolean);
+  if (lines.length < 2) return null;
+  const tableElement = options.tableElement || findContainingWordElement(targetParagraph, "tbl");
+  const rowElement = findContainingWordElement(targetParagraph, "tr");
+  const cellElement = findContainingWordElement(targetParagraph, "tc");
+  if (!tableElement || !rowElement || !cellElement) return null;
+  const currentParagraphText = normalizeWhitespaceForTargeting(
+    options.currentParagraphText || getParagraphText(targetParagraph)
+  );
+  const firstLine = normalizeWhitespaceForTargeting(lines[0]);
+  if (currentParagraphText && firstLine && firstLine !== currentParagraphText) {
+    onWarn("[Table] Multiline cell text did not anchor to original cell text; skipping table-row synthesis heuristic.");
+    return null;
   }
-  const abstractNumMap = /* @__PURE__ */ new Map();
-  const numIdMap = /* @__PURE__ */ new Map();
-  const abstractNums = Array.from(numberingDoc.getElementsByTagNameNS("*", "abstractNum"));
-  for (const abstractNum of abstractNums) {
-    const oldId = getElementId2(abstractNum, ["w:abstractNumId", "abstractNumId"]);
-    if (oldId == null) continue;
-    const newId = reserveNextNumberingId(numberingIdState, "abstract");
-    if (newId == null) continue;
-    abstractNumMap.set(oldId, newId);
-    setElementId(abstractNum, "w:abstractNumId", newId);
+  const { matrix, rowElements, columnCount } = extractTableMatrix(tableElement);
+  if (matrix.length === 0 || columnCount === 0) return null;
+  const rowIndex = rowElements.indexOf(rowElement);
+  const cellElements = getDirectWordChildren(rowElement, "tc");
+  const colIndex = cellElements.indexOf(cellElement);
+  if (rowIndex < 0 || colIndex < 0 || colIndex >= columnCount) return null;
+  matrix[rowIndex][colIndex] = lines[0];
+  const mirrorAcrossColumns = isSymmetricLabelRow(matrix[rowIndex]);
+  if (mirrorAcrossColumns) {
+    onInfo("[Table] Symmetric row detected; mirroring inserted row values across columns.");
   }
-  const nums = Array.from(numberingDoc.getElementsByTagNameNS("*", "num"));
-  for (const num of nums) {
-    const oldNumId = getElementId2(num, ["w:numId", "numId"]);
-    if (oldNumId == null) continue;
-    const newNumId = reserveNextNumberingId(numberingIdState, "num");
-    if (newNumId == null) continue;
-    numIdMap.set(oldNumId, newNumId);
-    setElementId(num, "w:numId", newNumId);
-    const abstractNumIdNode = Array.from(num.getElementsByTagNameNS("*", "abstractNumId"))[0] || null;
-    if (abstractNumIdNode) {
-      const oldAbsRef = getElementId2(abstractNumIdNode, ["w:val", "val"]);
-      if (oldAbsRef != null && abstractNumMap.has(oldAbsRef)) {
-        setElementVal2(abstractNumIdNode, abstractNumMap.get(oldAbsRef));
+  for (let i2 = 1; i2 < lines.length; i2++) {
+    const insertIndex = rowIndex + i2;
+    const extraValue = lines[i2];
+    if (insertIndex < matrix.length && !normalizeWhitespaceForTargeting(matrix[insertIndex][colIndex])) {
+      if (mirrorAcrossColumns) {
+        for (let col = 0; col < columnCount; col++) {
+          if (!normalizeWhitespaceForTargeting(matrix[insertIndex][col])) {
+            matrix[insertIndex][col] = extraValue;
+          }
+        }
+      } else {
+        matrix[insertIndex][colIndex] = extraValue;
       }
-    }
-  }
-  const clonedNodes = Array.isArray(replacementNodes) ? replacementNodes.map((node) => node?.cloneNode ? node.cloneNode(true) : node) : [];
-  for (const node of clonedNodes) {
-    const numIdNodes = Array.from(node?.getElementsByTagNameNS?.("*", "numId") || []);
-    for (const numIdNode of numIdNodes) {
-      const oldNumRef = getElementId2(numIdNode, ["w:val", "val"]);
-      if (oldNumRef != null && numIdMap.has(oldNumRef)) {
-        setElementVal2(numIdNode, numIdMap.get(oldNumRef));
+    } else {
+      const newRow = new Array(columnCount).fill("");
+      if (mirrorAcrossColumns) {
+        for (let col = 0; col < columnCount; col++) newRow[col] = extraValue;
+      } else {
+        newRow[colIndex] = extraValue;
       }
+      matrix.splice(Math.min(insertIndex, matrix.length), 0, newRow);
     }
   }
-  return {
-    numberingXml: serializeOoxml(numberingDoc),
-    replacementNodes: clonedNodes
-  };
-}
-function mergeNumberingXmlBySchemaOrder(existingNumberingXml, incomingNumberingXml) {
-  const existingText = String(existingNumberingXml || "");
-  const incomingText = String(incomingNumberingXml || "");
-  if (!incomingText.trim()) return existingText;
-  if (!existingText.trim()) return incomingText;
-  try {
-    const existingDoc = parseOoxml(existingText);
-    const incomingDoc = parseOoxml(incomingText);
-    if (hasXmlParseError(existingDoc) || hasXmlParseError(incomingDoc)) {
-      return existingText;
-    }
-    const existingRoot = existingDoc.documentElement;
-    const incomingRoot = incomingDoc.documentElement;
-    if (!existingRoot || !incomingRoot) return existingText;
-    const existingAbstractIds = new Set(
-      Array.from(existingRoot.childNodes || []).filter((node) => isDirectWordChild(node, "abstractNum")).map((node) => parseIntegerAttribute(node, ["w:abstractNumId", "abstractNumId"])).filter((id) => id != null)
-    );
-    const existingNumIds = new Set(
-      Array.from(existingRoot.childNodes || []).filter((node) => isDirectWordChild(node, "num")).map((node) => parseIntegerAttribute(node, ["w:numId", "numId"])).filter((id) => id != null)
-    );
-    for (const incomingNode of Array.from(incomingRoot.childNodes || [])) {
-      if (!isDirectWordChild(incomingNode, "abstractNum")) continue;
-      const incomingId = parseIntegerAttribute(incomingNode, ["w:abstractNumId", "abstractNumId"]);
-      if (incomingId == null || existingAbstractIds.has(incomingId)) continue;
-      insertNumberingNodeInSchemaOrder(existingRoot, existingDoc.importNode(incomingNode, true), "abstract");
-      existingAbstractIds.add(incomingId);
-    }
-    for (const incomingNode of Array.from(incomingRoot.childNodes || [])) {
-      if (!isDirectWordChild(incomingNode, "num")) continue;
-      const incomingId = parseIntegerAttribute(incomingNode, ["w:numId", "numId"]);
-      if (incomingId == null || existingNumIds.has(incomingId)) continue;
-      insertNumberingNodeInSchemaOrder(existingRoot, existingDoc.importNode(incomingNode, true), "num");
-      existingNumIds.add(incomingId);
-    }
-    return serializeOoxml(existingDoc);
-  } catch {
-    return existingText;
-  }
+  const markdown = tableMatrixToMarkdown(matrix, columnCount);
+  if (!markdown) return null;
+  onInfo("[Table] Synthesized full markdown table from multiline cell edit for table-scope reconciliation.");
+  return markdown;
 }
 
 // pipeline/ingestion-export.js
@@ -18721,6 +18854,8 @@ function areRevisionTokensEqual(a, b) {
 var attr2 = (node, name) => node?.getAttribute?.(`w:${name}`) || node?.getAttribute?.(name) || "";
 var descendants = (node, name) => Array.from(node?.getElementsByTagNameNS?.(NS_W, name) || []);
 var first = (node, name) => descendants(node, name)[0] || null;
+var directChild2 = (node, name) => Array.from(node?.childNodes || []).find((child) => child?.nodeType === 1 && child.localName === name && (!child.namespaceURI || child.namespaceURI === NS_W)) || null;
+var currentPPr = (paragraph) => directChild2(paragraph, "pPr");
 function hasAncestor(node, localName2) {
   let cursor = node?.parentNode;
   while (cursor) {
@@ -18736,11 +18871,11 @@ function parseXml2(xml, partName, required = false) {
   return { doc: parsed.doc, warnings: parsed.warnings || [] };
 }
 function paragraphListProperties(paragraph) {
-  const numPr = first(first(paragraph, "pPr"), "numPr");
+  const numPr = directChild2(currentPPr(paragraph), "numPr");
   if (!numPr) return null;
-  const numId = attr2(first(numPr, "numId"), "val");
+  const numId = attr2(directChild2(numPr, "numId"), "val");
   if (!numId || numId === "0") return null;
-  return { numId, level: Number.parseInt(attr2(first(numPr, "ilvl"), "val") || "0", 10) || 0 };
+  return { numId, level: Number.parseInt(attr2(directChild2(numPr, "ilvl"), "val") || "0", 10) || 0 };
 }
 function parseNumbering(numberingDoc) {
   const abstracts = /* @__PURE__ */ new Map();
@@ -18825,11 +18960,11 @@ function createNumberingResolver(numberingDoc) {
   };
 }
 function headingLevel(paragraph) {
-  const pPr = first(paragraph, "pPr");
-  const style = attr2(first(pPr, "pStyle"), "val");
+  const pPr = currentPPr(paragraph);
+  const style = attr2(directChild2(pPr, "pStyle"), "val");
   const match = style.match(/^heading\s*([1-9])$/i);
   if (match) return Math.min(Number(match[1]), 6);
-  const outline = Number.parseInt(attr2(first(pPr, "outlineLvl"), "val"), 10);
+  const outline = Number.parseInt(attr2(directChild2(pPr, "outlineLvl"), "val"), 10);
   return Number.isInteger(outline) ? Math.min(outline + 1, 6) : null;
 }
 function structuralContext(paragraph, text2) {
@@ -19008,7 +19143,7 @@ function inspectDocumentParts(parts, options = {}) {
     const ids = [...new Set([...descendants(paragraph, "commentRangeStart"), ...descendants(paragraph, "commentReference")].map((node) => attr2(node, "id")).filter(Boolean))];
     const authors = revisionAuthors(paragraph);
     const list = resolveNumbering(paragraphListProperties(paragraph));
-    const styleId = attr2(first(first(paragraph, "pPr"), "pStyle"), "val") || null;
+    const styleId = attr2(directChild2(currentPPr(paragraph), "pStyle"), "val") || null;
     const structure = structuralContext(paragraph, text2);
     const index = zeroIndex + 1;
     const provision = list?.label && list.format !== "bullet" ? list.label : null;
@@ -21599,7 +21734,7 @@ function validateDocumentOperation(operation) {
           }
         };
       }
-      if (target.revisionView !== "accepted" || target.captureRef || target.occurrence != null || normalized.captureKey || normalized.targetEndDescriptor || normalized.targetEndRef != null || /\r|\n/.test(target.text || "")) {
+      if (target.revisionView !== "accepted" || target.captureRef || target.occurrence != null || normalized.captureKey || normalized.targetEndDescriptor || normalized.targetEndRef != null) {
         return {
           valid: false,
           error: {
@@ -21621,6 +21756,15 @@ function validateDocumentOperation(operation) {
           }
         };
       }
+      if (replacementValidation.replacements.some((replacement) => /\r|\n/.test(replacement.find))) {
+        return {
+          valid: false,
+          error: {
+            code: "INVALID_OPERATION",
+            message: 'Localized replacements v1 cannot span a line break; use one replacement per line or a full "modified" paragraph.'
+          }
+        };
+      }
       normalized.replacements = replacementValidation.replacements;
     }
   }
@@ -21815,6 +21959,12 @@ function validateDocumentOperation(operation) {
         error: { code: "INVALID_OPERATION", message: 'Format operations require a non-empty "textToFormat" field.' }
       };
     }
+    if (normalized.textOccurrence != null && (!Number.isInteger(normalized.textOccurrence) || normalized.textOccurrence < 1)) {
+      return {
+        valid: false,
+        error: { code: "INVALID_OPERATION", message: "textOccurrence must be a positive integer when provided." }
+      };
+    }
     if (!isRecord(normalized.properties)) {
       return {
         valid: false,
@@ -22271,7 +22421,7 @@ function compileOperationBatch(xmlDoc, operations = [], options = {}) {
     };
     const compiled = { ...sourceOperation };
     const dynamicOccurrence = operation.targetDescriptor?.occurrence != null && !operation.targetDescriptor?.paragraphId && !operation.targetDescriptor?.fingerprint;
-    const compositeTextTarget = typeof operation.targetDescriptor?.text === "string" && /\r|\n/.test(operation.targetDescriptor.text) && !operation.targetEndDescriptor;
+    const compositeTextTarget = typeof operation.targetDescriptor?.text === "string" && /\r|\n/.test(operation.targetDescriptor.text) && !operation.targetEndDescriptor && !(Array.isArray(operation.replacements) && (operation.targetDescriptor.paragraphId || operation.targetDescriptor.fingerprint));
     if (dynamicOccurrence || compositeTextTarget) binding.dynamic = true;
     if (validation.valid && operation.operationKind !== "comment_reply" && operation.operationKind !== "comment_resolve" && !operation.targetDescriptor?.captureRef && !binding.dynamic) {
       try {
@@ -22609,6 +22759,17 @@ function deriveSingleParagraphPlainAdjacencyInsertion(currentParagraphText, modi
   }
   return null;
 }
+function deriveParagraphThenTableAppend(modifiedText) {
+  const lines = String(modifiedText || "").split(/\r?\n/g).map((line) => line.trimEnd()).filter((line) => line.trim().length > 0);
+  if (lines.length < 3) return null;
+  const tableStart = lines.findIndex((line) => line.trim().startsWith("|"));
+  if (tableStart !== 1) return null;
+  const tableLines = lines.slice(1);
+  if (!tableLines.every((line) => line.trim().startsWith("|"))) return null;
+  const separator = tableLines[1].replace(/\s+/g, "");
+  if (!/^\|:?-{3,}:?(\|:?-{3,}:?)+\|?$/.test(separator)) return null;
+  return { paragraphMarkdown: lines[0].trim(), tableText: tableLines.join("\n") };
+}
 
 // services/capture-engine.js
 function createCaptureError(code, message) {
@@ -24394,6 +24555,81 @@ async function applyToParagraphByExactText(documentXml, targetText, modifiedText
       numberingXml: null
     };
   }
+  const tableAppendCandidate = !useTableScope && !hasExplicitRangeScope && !targetListInfo && !containingTable && !targetEndRef ? deriveParagraphThenTableAppend(effectiveModifiedText) : null;
+  const tableAppendParagraph = tableAppendCandidate ? preprocessMarkdown(tableAppendCandidate.paragraphMarkdown) : null;
+  if (tableAppendCandidate && normalizeWhitespaceForTargeting(tableAppendParagraph.cleanText) === normalizeWhitespaceForTargeting(currentParagraphText)) {
+    const tableData = parseTable(tableAppendCandidate.tableText);
+    if (tableData.headers.length > 0 || tableData.rows.length > 0) {
+      onInfo("[Table] Applying retained-paragraph table append heuristic.");
+      const parent2 = targetParagraph.parentNode;
+      if (!parent2) throw new Error("Target paragraph has no parent for table append");
+      const followingNode = targetParagraph.nextSibling;
+      if (tableAppendParagraph.formatHints.length > 0) {
+        const formatted = await applyRedlineToOxml2(
+          serializer.serializeToString(targetParagraph),
+          currentParagraphText || targetText,
+          tableAppendCandidate.paragraphMarkdown,
+          {
+            author,
+            generateRedlines,
+            existingRevisions: options.existingRevisions || "merge-same-author",
+            structuredContent: false,
+            _revisionIdAllocator: revisionIdAllocator
+          }
+        );
+        if (formatted?.status === "error") {
+          return {
+            documentXml,
+            hasChanges: false,
+            numberingXml: null,
+            status: "error",
+            error: formatted.error
+          };
+        }
+        if (formatted?.hasChanges) {
+          if (typeof formatted.oxml !== "string") {
+            throw new Error("Reconciliation engine did not return OOXML for a changed paragraph format");
+          }
+          for (const node of extractReplacementNodes(formatted.oxml).replacementNodes) {
+            const imported = xmlDoc.importNode(node, true);
+            ensureParagraphIdsOnImportedNode(imported, operationSession);
+            options?._mutationLiveNodes?.push(parent2.insertBefore(imported, targetParagraph));
+          }
+          options?._mutationRemovedNodes?.push(targetParagraph);
+          parent2.removeChild(targetParagraph);
+        }
+      }
+      const tableOoxml = generateTableOoxml(tableData, {
+        generateRedlines,
+        author,
+        revisionIdAllocator,
+        trackAsBlock: true
+      });
+      for (const node of extractReplacementNodes(tableOoxml).replacementNodes) {
+        options?._mutationLiveNodes?.push(parent2.insertBefore(xmlDoc.importNode(node, true), followingNode));
+      }
+      const endsContainer = !followingNode || followingNode.nodeType === 1 && followingNode.namespaceURI === NS_W9 && followingNode.localName === "sectPr";
+      if (endsContainer) {
+        const trailing = createWordElement(xmlDoc, "w:p");
+        const trailingPPr = clonePropertiesWithoutRevisionHistory(getDirectWordChild4(targetParagraph, "pPr"));
+        if (trailingPPr) {
+          for (const child of Array.from(trailingPPr.childNodes)) {
+            if (child.nodeType === 1 && ["sectPr", "numPr"].includes(child.localName)) trailingPPr.removeChild(child);
+          }
+          trailing.appendChild(trailingPPr);
+        }
+        if (generateRedlines) markParagraphMarkInserted(xmlDoc, trailing, author);
+        ensureParagraphIdsOnImportedNode(trailing, operationSession);
+        options?._mutationLiveNodes?.push(parent2.insertBefore(trailing, followingNode));
+      }
+      normalizeBodySectionOrder(xmlDoc);
+      return {
+        documentXml: completedDocumentXml(xmlDoc, serializer, documentXml, operationSession),
+        hasChanges: true,
+        numberingXml: null
+      };
+    }
+  }
   const plainAdjacencyInsertionCandidate = !bypassSingleParagraphHeuristics && !useTableScope && !hasExplicitRangeScope && !targetListInfo ? deriveSingleParagraphPlainAdjacencyInsertion(currentParagraphText, effectiveModifiedText) : null;
   if (plainAdjacencyInsertionCandidate) {
     onInfo(
@@ -24409,7 +24645,9 @@ async function applyToParagraphByExactText(documentXml, targetText, modifiedText
         paragraphText,
         generateRedlines ? createRevisionMetadata(author, xmlDoc) : null,
         author,
-        { generateRedlines }
+        // A wholly inserted paragraph must track its own paragraph mark; otherwise Word's
+        // Reject All removes the text but leaves an empty paragraph behind.
+        { generateRedlines, trackParagraphMark: true }
       );
       const imported = xmlDoc.importNode(plainParagraph, true);
       ensureParagraphIdsOnImportedNode(imported, operationSession);
@@ -24517,6 +24755,7 @@ async function applyToParagraphByExactText(documentXml, targetText, modifiedText
     explicitStructuredContent: options.explicitStructuredContent === true,
     pairReplacements: options.pairReplacements === true,
     insertionAffinity: options.insertionAffinity || null,
+    literalTextEdit: options.literalTextEdit === true,
     _revisionIdAllocator: revisionIdAllocator,
     _isolatedTableCell: useTableScope
   });
@@ -24540,6 +24779,14 @@ async function applyToParagraphByExactText(documentXml, targetText, modifiedText
   const extracted = extractReplacementNodes(result.oxml);
   let replacementNodes = removeListPackagingSentinel(extracted.replacementNodes, result.warnings);
   let numberingXml = extracted.numberingXml;
+  if (numberingXml && runtimeContext?.numberingIdState && !useTableScope) {
+    const sourceParagraphs = useListScope ? listScopeEdit.paragraphs : explicitRangeParagraphs || [targetParagraph];
+    const continued = reuseSourceListNumbering(numberingXml, replacementNodes, sourceParagraphs, runtimeContext.numberingIdState);
+    if (continued) {
+      replacementNodes = continued.replacementNodes;
+      numberingXml = null;
+    }
+  }
   if (numberingXml && runtimeContext?.numberingIdState) {
     const normalizedNumbering = remapNumberingPayloadForDocument(numberingXml, replacementNodes, runtimeContext.numberingIdState);
     replacementNodes = normalizedNumbering.replacementNodes;
@@ -24796,7 +25043,8 @@ async function applyFormattingToParagraphByExactText(documentXml, targetText, te
     spanRanges.push({ ...entry, start, end });
   }
   const targetDescriptor = options.targetDescriptor;
-  const occurrence = targetDescriptor?.occurrence ?? null;
+  const explicitTextOccurrence = Number.isInteger(options.textOccurrence) && options.textOccurrence > 0 ? options.textOccurrence : null;
+  const occurrence = explicitTextOccurrence ?? targetDescriptor?.occurrence ?? null;
   let matchStart = -1;
   if (occurrence != null && occurrence > 0) {
     let count = 0;
@@ -24814,6 +25062,17 @@ async function applyFormattingToParagraphByExactText(documentXml, targetText, te
   } else {
     matchStart = fullParaText.indexOf(textToFormat);
   }
+  if (matchStart === -1 && explicitTextOccurrence != null && fullParaText.includes(textToFormat)) {
+    return {
+      documentXml,
+      hasChanges: false,
+      status: "error",
+      error: {
+        code: "PATCH_SOURCE_NOT_FOUND",
+        message: `Occurrence ${explicitTextOccurrence} of text to format was not found in target paragraph: "${textToFormat}".`
+      }
+    };
+  }
   if (matchStart === -1) {
     return {
       documentXml,
@@ -25096,9 +25355,11 @@ async function applyOperationToDocumentXml(documentXml, op, author, runtimeConte
     ...operation.existingRevisions ? { existingRevisions: operation.existingRevisions } : {},
     structuredContent: typeof operation.structuredContent === "boolean" ? operation.structuredContent : options.structuredContent !== false,
     explicitStructuredContent: operation.structuredContent === true,
+    ...operation._localizedReplacementCompilation && operation.structuredContent !== true ? { literalTextEdit: true } : {},
     pairReplacements: typeof operation.pairReplacements === "boolean" ? operation.pairReplacements : options.pairReplacements !== false,
     ...operation.insertionAffinity ? { insertionAffinity: operation.insertionAffinity } : {},
     ...operation.formattingRevisionPolicy ? { formattingRevisionPolicy: operation.formattingRevisionPolicy } : {},
+    ...operation.operationKind === "format" && Number.isInteger(operation.textOccurrence) ? { textOccurrence: operation.textOccurrence } : {},
     targetDescriptor: operation.targetDescriptor,
     targetEndDescriptor: operation.targetEndDescriptor,
     _compiledSourceId: operation._compiledSourceId || null,
@@ -25722,6 +25983,9 @@ async function applyOperationsToDocumentXml(documentXml, operations, author, run
   const scheduled = dependencyPlan.scheduled;
   const atomic = options.atomic === true;
   const continueOnError = options.continueOnError !== false;
+  if (runtimeContext && typeof runtimeContext === "object" && !runtimeContext.numberingIdState && typeof runtimeContext.numberingXml === "string" && runtimeContext.numberingXml.trim()) {
+    runtimeContext.numberingIdState = createDynamicNumberingIdState(runtimeContext.numberingXml);
+  }
   const context = cloneBatchRuntimeContext(runtimeContext);
   if (!(context.targetRefSnapshot instanceof Map)) {
     context.targetRefSnapshot = session.initialTargetReferenceSnapshot;
@@ -28147,8 +28411,32 @@ function openDocx(input) {
 }
 
 // index.js
+function remapGeneratedNumberingForSource(result, options) {
+  const sourceNumbering = typeof options?.numberingXml === "string" && options.numberingXml.trim() ? options.numberingXml : null;
+  const state = options?.numberingIdState && typeof options.numberingIdState === "object" ? options.numberingIdState : sourceNumbering ? createDynamicNumberingIdState(sourceNumbering) : null;
+  if (!state || !result?.hasChanges || typeof result.oxml !== "string" || !result.oxml.includes("/word/numbering.xml")) {
+    return result;
+  }
+  const pkgDoc = parseOoxml(result.oxml);
+  const parts = Array.from(pkgDoc.getElementsByTagNameNS("*", "part"));
+  const payloadOf = (name) => {
+    const part = parts.find((candidate) => (candidate.getAttribute("pkg:name") || candidate.getAttribute("name")) === name);
+    const xmlData = part?.getElementsByTagNameNS("*", "xmlData")[0];
+    return xmlData ? Array.from(xmlData.childNodes).find((node) => node.nodeType === 1) || null : null;
+  };
+  const numberingNode = payloadOf("/word/numbering.xml");
+  const body = payloadOf("/word/document.xml")?.getElementsByTagNameNS("*", "body")[0];
+  if (!numberingNode || !body) return result;
+  const bodyNodes = Array.from(body.childNodes).filter((node) => node.nodeType === 1 && node.localName !== "sectPr");
+  const remapped = remapNumberingPayloadForDocument(serializeOoxml(numberingNode), bodyNodes, state);
+  const newNumbering = pkgDoc.importNode(parseOoxml(remapped.numberingXml).documentElement, true);
+  numberingNode.parentNode.replaceChild(newNumbering, numberingNode);
+  bodyNodes.forEach((node, index) => body.replaceChild(remapped.replacementNodes[index], node));
+  return { ...result, oxml: serializeOoxml(pkgDoc) };
+}
 async function applyRedlineToOxml3(oxml, originalText, modifiedText, options = {}) {
-  const result = await applyRedlineToOxml(oxml, originalText, modifiedText, options);
+  const rawResult = await applyRedlineToOxml(oxml, originalText, modifiedText, options);
+  const result = remapGeneratedNumberingForSource(rawResult, options);
   if (result?.useNativeApi && typeof result?.oxml !== "string") {
     const existingWarnings = Array.isArray(result?.warnings) ? result.warnings : [];
     return withOoxmlSourceType({