@ansonlai/docx-redline-js 0.5.1 → 0.5.3

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

@@ -1,4 +1,4 @@
-// @ansonlai/docx-redline-js v0.5.1 — https://github.com/AnsonLai/docx-redline-js
+// @ansonlai/docx-redline-js v0.5.3 — https://github.com/AnsonLai/docx-redline-js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -2634,6 +2634,17 @@ function computeWordDiffs(originalText, newText, options = {}) {
   }
   return decodeBmpDiffs(charDiffs, wordArray);
 }
+function computeInsertionOnlyDiffs(originalText, newText) {
+  if (originalText === newText) return [[0, originalText]];
+  if (!originalText) return [[1, newText]];
+  let originalIndex = 0;
+  for (let modifiedIndex = 0; modifiedIndex < newText.length && originalIndex < originalText.length; modifiedIndex++) {
+    if (newText[modifiedIndex] === originalText[originalIndex]) originalIndex++;
+  }
+  if (originalIndex !== originalText.length) return null;
+  const diffs = createDiffEngine().diff_main(originalText, newText);
+  return diffs.some(([op]) => op === -1) ? null : diffs;
+}
 function computeWordLevelDiffOps(originalText, newText, options = {}) {
   if (originalText === newText) {
     return [{
@@ -6149,7 +6160,15 @@ function processDelete(xmlDoc, spanIndex, startPos, endPos, author, generateRedl
       if (delWrapper && record.deletedPieces.length > 0) {
         delWrapper.appendChild(createRunFromPieces(xmlDoc, record.deletedPieces, record.rPr));
       }
-      insertRunPiecesBefore(xmlDoc, parent, runElement, record.afterPieces, record.rPr);
+      const afterRun = insertRunPiecesBefore(xmlDoc, parent, runElement, record.afterPieces, record.rPr);
+      if (record.globalEnd === endPos && !isWordElement(parent, "ins")) {
+        if (!spanIndex.replacementInsertionAnchors) spanIndex.replacementInsertionAnchors = /* @__PURE__ */ new Map();
+        spanIndex.replacementInsertionAnchors.set(endPos, {
+          parent,
+          referenceNode: afterRun || runElement.nextSibling,
+          rPr: record.rPr
+        });
+      }
       parent.removeChild(runElement);
       changed = true;
     }
@@ -6186,6 +6205,23 @@ function processInsert(xmlDoc, spanIndex, pos, text, author, formatHints = [], i
       revisionMetadata
     );
   }
+  const replacementAnchor = spanIndex.replacementInsertionAnchors?.get(pos) || null;
+  if (replacementAnchor && !affinity && isConnected(replacementAnchor.parent) && (!replacementAnchor.referenceNode || replacementAnchor.referenceNode.parentNode === replacementAnchor.parent)) {
+    spanIndex.replacementInsertionAnchors.delete(pos);
+    insertTextRuns(
+      xmlDoc,
+      replacementAnchor.parent,
+      replacementAnchor.referenceNode,
+      text,
+      replacementAnchor.rPr,
+      author,
+      formatHints,
+      insertOffset,
+      generateRedlines,
+      revisionMetadata
+    );
+    return true;
+  }
   if (!affinity) {
     let targetSpan = findContainingSpan(spanIndex, pos);
     if (!targetSpan && pos > 0) {
@@ -6208,6 +6244,7 @@ function processInsert(xmlDoc, spanIndex, pos, text, author, formatHints = [], i
       insertTextRuns(xmlDoc, fallbackParagraph, null, text, targetSpan.rPr, author, formatHints, insertOffset, generateRedlines, revisionMetadata);
       return true;
     }
+    const generateNestedRevision = !(generateRedlines && existingRevisions === "slice-cross-author" && isSameAuthorInsertion(parent2, author));
     if (generateRedlines && existingRevisions === "slice-cross-author" && isForeignInsertion(parent2, author)) {
       return spliceInsertionAtCarrierOffset(
         xmlDoc,
@@ -6229,13 +6266,13 @@ function processInsert(xmlDoc, spanIndex, pos, text, author, formatHints = [], i
       const beforePieces = sliceRunPieces(xmlDoc, pieces, 0, localInsertPos, false);
       const afterPieces = sliceRunPieces(xmlDoc, pieces, localInsertPos, getRunTextLength(pieces), false);
       insertRunPiecesBefore(xmlDoc, parent2, targetSpan.runElement, beforePieces, targetSpan.rPr);
-      insertTextRuns(xmlDoc, parent2, targetSpan.runElement, text, targetSpan.rPr, author, formatHints, insertOffset, generateRedlines, revisionMetadata);
+      insertTextRuns(xmlDoc, parent2, targetSpan.runElement, text, targetSpan.rPr, author, formatHints, insertOffset, generateNestedRevision, revisionMetadata);
       insertRunPiecesBefore(xmlDoc, parent2, targetSpan.runElement, afterPieces, targetSpan.rPr);
       parent2.removeChild(targetSpan.runElement);
       return true;
     }
     const referenceNode2 = pos <= targetSpan.charStart ? targetSpan.runElement : targetSpan.runElement.nextSibling;
-    insertTextRuns(xmlDoc, parent2, referenceNode2, text, targetSpan.rPr, author, formatHints, insertOffset, generateRedlines, revisionMetadata);
+    insertTextRuns(xmlDoc, parent2, referenceNode2, text, targetSpan.rPr, author, formatHints, insertOffset, generateNestedRevision, revisionMetadata);
     return true;
   }
   const boundary = describeInsertionBoundary(spanIndex, pos, fallbackParagraph);
@@ -6443,6 +6480,11 @@ function isForeignInsertion(node, author) {
   const carrierAuthor = node.getAttribute("w:author") || node.getAttributeNS?.(NS_W, "author") || "";
   return carrierAuthor.trim().toLowerCase() !== String(author || "").trim().toLowerCase();
 }
+function isSameAuthorInsertion(node, author) {
+  if (!isWordElement(node, "ins")) return false;
+  const carrierAuthor = node.getAttribute("w:author") || node.getAttributeNS?.(NS_W, "author") || "";
+  return carrierAuthor.trim().toLowerCase() === String(author || "").trim().toLowerCase();
+}
 function nextElementSibling(node) {
   let sibling = node?.nextSibling || null;
   while (sibling && sibling.nodeType !== 1) sibling = sibling.nextSibling;
@@ -6541,68 +6583,119 @@ function applySurgicalMode(xmlDoc, originalText, modifiedText, serializer, autho
   void originalText;
   const allParagraphs = targetParagraph ? [targetParagraph] : getDocumentParagraphs(xmlDoc);
   const { fullText, textSpans } = buildSurgicalTextSpans(allParagraphs);
-  const diffs = computeWordDiffs(fullText, modifiedText, diffOptions);
+  const insertionOnlyDiffs = options.existingRevisions === "slice-cross-author" ? computeInsertionOnlyDiffs(fullText, modifiedText) : null;
+  const diffs = insertionOnlyDiffs || computeWordDiffs(fullText, modifiedText, diffOptions);
   const spanIndex = buildSpanIndex(textSpans);
   const pairReplacements = options.pairReplacements === true;
   const warnings = [];
   let originalPos = 0;
   let newPos = 0;
   let hasChanges = false;
-  for (let i = 0; i < diffs.length; i++) {
-    const [op, text] = diffs[i];
-    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)) {
+  const insertionOperations = insertionOnlyDiffs ? collectInsertionOperations(insertionOnlyDiffs) : [];
+  if (insertionOperations.length > 1 && formatHints.length === 0) {
+    for (const operation of insertionOperations.slice().reverse()) {
+      const liveSpans = buildSurgicalTextSpans(allParagraphs).textSpans;
+      const liveSpanIndex = buildSpanIndex(liveSpans);
+      const textWithoutNewlines = operation.text.replace(/\n/g, " ");
+      if (textWithoutNewlines.length === 0) continue;
+      const insertResult = processInsert(
+        xmlDoc,
+        liveSpanIndex,
+        operation.originalPos,
+        textWithoutNewlines,
+        author,
+        formatHints,
+        operation.newPos,
+        generateRedlines,
+        allParagraphs[0] || null,
+        null,
+        options?.insertionAffinity || null,
+        options?.existingRevisions || "merge-same-author"
+      );
+      if (insertResult && typeof insertResult === "object" && insertResult.error) {
+        return withOoxmlSourceType({
+          oxml: serializer.serializeToString(xmlDoc),
+          hasChanges: false,
+          status: "error",
+          error: insertResult.error
+        });
+      }
+      if (insertResult === true) hasChanges = true;
+    }
+  } else {
+    for (let i = 0; i < diffs.length; i++) {
+      const [op, text] = diffs[i];
+      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) {
+        const hasNextInsert = i + 1 < diffs.length && diffs[i + 1][0] === 1;
+        let paired = false;
+        let delMetadata = null;
+        let insMetadata = null;
+        if (pairReplacements && generateRedlines && hasNextInsert) {
+          const nextText = diffs[i + 1][1];
+          const textWithoutNewlines = nextText.replace(/\n/g, " ");
+          if (textWithoutNewlines.length > 0) {
+            const checkResult = checkSafeAdjacencyForPairing(
+              spanIndex,
+              originalPos,
+              originalPos + text.length,
+              options?.existingRevisions === "slice-cross-author"
+            );
+            if (checkResult.safe) {
+              const event = createReplacementRevisionEvent(author, xmlDoc);
+              delMetadata = { id: event.deletionId, author: event.author, date: event.date };
+              insMetadata = { id: event.insertionId, author: event.author, date: event.date };
+              paired = true;
+            } else if (checkResult.structuralBoundary) {
+              warnings.push("PAIRING_SKIPPED_STRUCTURAL_BOUNDARY");
+            }
+          }
+        }
+        if (processDelete(xmlDoc, spanIndex, originalPos, originalPos + text.length, author, generateRedlines, delMetadata)) {
           hasChanges = true;
         }
-      });
-      originalPos += len;
-      newPos += len;
-    } else if (op === -1) {
-      const hasNextInsert = i + 1 < diffs.length && diffs[i + 1][0] === 1;
-      let paired = false;
-      let delMetadata = null;
-      let insMetadata = null;
-      if (pairReplacements && generateRedlines && hasNextInsert) {
-        const nextText = diffs[i + 1][1];
-        const textWithoutNewlines = nextText.replace(/\n/g, " ");
-        if (textWithoutNewlines.trim().length > 0) {
-          const checkResult = checkSafeAdjacencyForPairing(
-            spanIndex,
-            originalPos,
-            originalPos + text.length,
-            options?.existingRevisions === "slice-cross-author"
-          );
-          if (checkResult.safe) {
-            const event = createReplacementRevisionEvent(author, xmlDoc);
-            delMetadata = { id: event.deletionId, author: event.author, date: event.date };
-            insMetadata = { id: event.insertionId, author: event.author, date: event.date };
-            paired = true;
-          } else if (checkResult.structuralBoundary) {
-            warnings.push("PAIRING_SKIPPED_STRUCTURAL_BOUNDARY");
+        originalPos += text.length;
+        if (paired) {
+          i++;
+          const [, nextText] = diffs[i];
+          const textWithoutNewlines = nextText.replace(/\n/g, " ");
+          if (textWithoutNewlines.length > 0) {
+            const insertResult = processInsert(xmlDoc, spanIndex, originalPos, textWithoutNewlines, author, formatHints, newPos, generateRedlines, allParagraphs[0] || null, insMetadata, options?.insertionAffinity || null, options?.existingRevisions || "merge-same-author");
+            if (insertResult && typeof insertResult === "object" && insertResult.error) {
+              return withOoxmlSourceType({
+                oxml: serializer.serializeToString(xmlDoc),
+                hasChanges: false,
+                status: "error",
+                error: insertResult.error
+              });
+            }
+            if (insertResult === true) {
+              hasChanges = true;
+            }
           }
+          newPos += nextText.length;
         }
-      }
-      if (processDelete(xmlDoc, spanIndex, originalPos, originalPos + text.length, author, generateRedlines, delMetadata)) {
-        hasChanges = true;
-      }
-      originalPos += text.length;
-      if (paired) {
-        i++;
-        const [, nextText] = diffs[i];
-        const textWithoutNewlines = nextText.replace(/\n/g, " ");
-        if (textWithoutNewlines.trim().length > 0) {
-          const insertResult = processInsert(xmlDoc, spanIndex, originalPos, textWithoutNewlines, author, formatHints, newPos, generateRedlines, allParagraphs[0] || null, insMetadata, options?.insertionAffinity || null, options?.existingRevisions || "merge-same-author");
+      } else if (op === 1) {
+        const textWithoutNewlines = text.replace(/\n/g, " ");
+        if (textWithoutNewlines.length > 0) {
+          const insertResult = processInsert(xmlDoc, spanIndex, originalPos, textWithoutNewlines, author, formatHints, newPos, generateRedlines, allParagraphs[0] || null, null, options?.insertionAffinity || null, options?.existingRevisions || "merge-same-author");
           if (insertResult && typeof insertResult === "object" && insertResult.error) {
             return withOoxmlSourceType({
               oxml: serializer.serializeToString(xmlDoc),
@@ -6615,33 +6708,63 @@ function applySurgicalMode(xmlDoc, originalText, modifiedText, serializer, autho
             hasChanges = true;
           }
         }
-        newPos += nextText.length;
-      }
-    } else if (op === 1) {
-      const textWithoutNewlines = text.replace(/\n/g, " ");
-      if (textWithoutNewlines.trim().length > 0) {
-        const insertResult = processInsert(xmlDoc, spanIndex, originalPos, textWithoutNewlines, author, formatHints, newPos, generateRedlines, allParagraphs[0] || null, null, options?.insertionAffinity || null, options?.existingRevisions || "merge-same-author");
-        if (insertResult && typeof insertResult === "object" && insertResult.error) {
-          return withOoxmlSourceType({
-            oxml: serializer.serializeToString(xmlDoc),
-            hasChanges: false,
-            status: "error",
-            error: insertResult.error
-          });
-        }
-        if (insertResult === true) {
-          hasChanges = true;
-        }
+        newPos += text.length;
       }
-      newPos += text.length;
     }
   }
+  const actualText = allParagraphs.map((paragraph) => extractCanonicalParagraphText(paragraph)).join("\n");
+  const expectedText = String(modifiedText).replace(/\r\n/g, "\n");
+  if (options.existingRevisions === "slice-cross-author" && actualText !== expectedText) {
+    const mismatchOffset = firstMismatchOffset(expectedText, actualText);
+    return withOoxmlSourceType({
+      oxml: serializer.serializeToString(xmlDoc),
+      hasChanges: false,
+      status: "error",
+      error: {
+        code: "PATCH_ROUNDTRIP_MISMATCH",
+        message: "Generated OOXML accepted-view text does not match the requested modified text; the mutation was rejected.",
+        mismatchOffset,
+        expectedExcerpt: excerptAt(expectedText, mismatchOffset),
+        actualExcerpt: excerptAt(actualText, mismatchOffset)
+      },
+      ...warnings.length > 0 ? { warnings: [...new Set(warnings)] } : {}
+    });
+  }
   return withOoxmlSourceType({
     oxml: serializer.serializeToString(xmlDoc),
     hasChanges,
     ...warnings.length > 0 ? { warnings: [...new Set(warnings)] } : {}
   });
 }
+function firstMismatchOffset(expected, actual) {
+  const limit = Math.min(expected.length, actual.length);
+  for (let index = 0; index < limit; index++) {
+    if (expected[index] !== actual[index]) return index;
+  }
+  return limit;
+}
+function excerptAt(text, offset, radius = 40) {
+  const start = Math.max(0, offset - radius);
+  const end = Math.min(text.length, offset + radius);
+  return text.slice(start, end);
+}
+function collectInsertionOperations(diffs) {
+  const operations = [];
+  let originalPos = 0;
+  let newPos = 0;
+  for (const [op, text] of diffs) {
+    if (op === 0) {
+      originalPos += text.length;
+      newPos += text.length;
+    } else if (op === -1) {
+      originalPos += text.length;
+    } else if (op === 1) {
+      operations.push({ originalPos, newPos, text });
+      newPos += text.length;
+    }
+  }
+  return operations;
+}
 
 // engine/reconstruction-mapper.js
 var import_diff_match_patch2 = __toESM(require_diff_match_patch(), 1);
@@ -7544,8 +7667,8 @@ function resolveAuthorFilter(options = {}) {
   if (options?.allAuthors === true) {
     return { valid: true, allAuthors: true, normalizedAuthor: "" };
   }
-  const normalizedAuthor = normalizeAuthor(options?.author);
-  if (!normalizedAuthor) {
+  const normalizedAuthor2 = normalizeAuthor(options?.author);
+  if (!normalizedAuthor2) {
     return {
       valid: false,
       allAuthors: false,
@@ -7553,7 +7676,7 @@ function resolveAuthorFilter(options = {}) {
       warning: "No author provided. Pass { author } or set { allAuthors: true }."
     };
   }
-  return { valid: true, allAuthors: false, normalizedAuthor };
+  return { valid: true, allAuthors: false, normalizedAuthor: normalizedAuthor2 };
 }
 function authorMatchesNode(node, filter) {
   if (filter.allAuthors) return true;
@@ -8005,6 +8128,133 @@ function recordRouteSelection(options, route, context = {}) {
   }));
 }
 
+// core/paragraph-revision-safety.js
+var NON_CONTENT_CHILDREN = /* @__PURE__ */ new Set([
+  "pPr",
+  "bookmarkStart",
+  "bookmarkEnd",
+  "commentRangeStart",
+  "commentRangeEnd",
+  "commentReference",
+  "customXmlInsRangeStart",
+  "customXmlInsRangeEnd",
+  "customXmlDelRangeStart",
+  "customXmlDelRangeEnd",
+  "moveFromRangeStart",
+  "moveFromRangeEnd",
+  "moveToRangeStart",
+  "moveToRangeEnd",
+  "permStart",
+  "permEnd",
+  "proofErr"
+]);
+function localNameOf2(node) {
+  return String(node?.localName || node?.nodeName || "").replace(/^.*:/, "");
+}
+function directElementChildren(node) {
+  return Array.from(node?.childNodes || []).filter((child) => child.nodeType === 1);
+}
+function directChild(node, localName2) {
+  return directElementChildren(node).find((child) => localNameOf2(child) === localName2) || null;
+}
+function wordAttribute2(node, localName2) {
+  return node?.getAttribute?.(`w:${localName2}`) || node?.getAttribute?.(localName2) || "";
+}
+function normalizedAuthor(author) {
+  return String(author || "").trim().toLowerCase();
+}
+function isAnchorOnlyRun(node) {
+  if (localNameOf2(node) !== "r") return false;
+  return directElementChildren(node).every((child) => [
+    "rPr",
+    "commentReference",
+    "bookmarkStart",
+    "bookmarkEnd",
+    "commentRangeStart",
+    "commentRangeEnd",
+    "proofErr"
+  ].includes(localNameOf2(child)));
+}
+function isNonContentChild(node) {
+  return NON_CONTENT_CHILDREN.has(localNameOf2(node)) || isAnchorOnlyRun(node);
+}
+function isWhollyDeletedContentNode(node) {
+  if (localNameOf2(node) === "del") return true;
+  if (!["customXml", "smartTag", "sdt", "sdtContent"].includes(localNameOf2(node))) return false;
+  const contentChildren = directElementChildren(node).filter((child) => !isNonContentChild(child) && localNameOf2(child) !== "sdtPr");
+  return contentChildren.every(isWhollyDeletedContentNode);
+}
+function paragraphMarkDeletion(paragraph) {
+  const pPr = directChild(paragraph, "pPr");
+  const rPr = directChild(pPr, "rPr");
+  return directChild(rPr, "del");
+}
+function hasVisibleInsertionContent(insertion) {
+  for (const node of Array.from(insertion?.getElementsByTagName?.("*") || [])) {
+    const localName2 = localNameOf2(node);
+    if (!["t", "tab", "br", "cr", "noBreakHyphen", "softHyphen"].includes(localName2)) continue;
+    let ancestor = node.parentNode;
+    let hidden = false;
+    while (ancestor && ancestor !== insertion) {
+      const ancestorName = localNameOf2(ancestor);
+      if (ancestorName === "del" || ancestorName === "moveFrom") {
+        hidden = true;
+        break;
+      }
+      ancestor = ancestor.parentNode;
+    }
+    if (hidden) continue;
+    if (localName2 !== "t" || (node.textContent || "").length > 0) return true;
+  }
+  return false;
+}
+function inspectForeignDeletedParagraphTarget(paragraph, mutationAuthor) {
+  const markDeletion = paragraphMarkDeletion(paragraph);
+  if (!markDeletion) {
+    return {
+      matches: false,
+      hasParagraphMarkDeletion: false,
+      foreignParagraphMarkDeletion: false,
+      allContentDeleted: false,
+      ownerAuthor: null,
+      markDeletion: null
+    };
+  }
+  const ownerAuthor = wordAttribute2(markDeletion, "author") || null;
+  const foreignParagraphMarkDeletion = !ownerAuthor || normalizedAuthor(ownerAuthor) !== normalizedAuthor(mutationAuthor);
+  const contentChildren = directElementChildren(paragraph).filter((child) => !isNonContentChild(child));
+  const allContentDeleted = contentChildren.every(isWhollyDeletedContentNode);
+  return {
+    matches: foreignParagraphMarkDeletion && allContentDeleted,
+    hasParagraphMarkDeletion: true,
+    foreignParagraphMarkDeletion,
+    allContentDeleted,
+    ownerAuthor,
+    markDeletion
+  };
+}
+function findForeignDeletedParagraphResurrections(root) {
+  const paragraphs = localNameOf2(root) === "p" ? [root] : Array.from(root?.getElementsByTagName?.("*") || []).filter((node) => localNameOf2(node) === "p");
+  const matches = [];
+  for (const paragraph of paragraphs) {
+    const markDeletion = paragraphMarkDeletion(paragraph);
+    if (!markDeletion) continue;
+    const ownerAuthor = wordAttribute2(markDeletion, "author") || null;
+    const contentChildren = directElementChildren(paragraph).filter((child) => !isNonContentChild(child));
+    const foreignInsertions = contentChildren.filter((child) => {
+      if (localNameOf2(child) !== "ins" || !hasVisibleInsertionContent(child)) return false;
+      return normalizedAuthor(wordAttribute2(child, "author")) !== normalizedAuthor(ownerAuthor);
+    });
+    const onlyDeletedContentAndForeignInsertions = contentChildren.every((child) => {
+      return isWhollyDeletedContentNode(child) || foreignInsertions.includes(child);
+    });
+    if (foreignInsertions.length > 0 && onlyDeletedContentAndForeignInsertions) {
+      matches.push({ paragraph, markDeletion, ownerAuthor, foreignInsertions });
+    }
+  }
+  return matches;
+}
+
 // engine/oxml-engine.js
 function getCommentIdsInOoxml(node) {
   const ids = /* @__PURE__ */ new Set();
@@ -8085,6 +8335,23 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
   }
   const revisionIdAllocator = options?._revisionIdAllocator instanceof RevisionIdAllocator ? options._revisionIdAllocator : new RevisionIdAllocator();
   seedRevisionIdsFromDocument(xmlDoc, revisionIdAllocator);
+  const inputParagraphs = xmlDoc.documentElement && String(xmlDoc.documentElement.localName || "").toLowerCase() === "p" ? [xmlDoc.documentElement] : getDocumentParagraphs(xmlDoc);
+  if (inputParagraphs.length === 1 && modifiedText.length > 0) {
+    const resurrectionTarget = inspectForeignDeletedParagraphTarget(inputParagraphs[0], author);
+    if (resurrectionTarget.matches) {
+      const ownerAuthor = resurrectionTarget.ownerAuthor || "unattributed";
+      return finalize({
+        oxml: inputOoxml,
+        hasChanges: false,
+        status: "error",
+        error: {
+          code: "FOREIGN_PARAGRAPH_MARK_DELETION",
+          message: `Refusing to add visible text to a paragraph whose paragraph mark is deleted by another author (${ownerAuthor}). Use explicit paragraph restoration when supported.`,
+          ownerAuthor
+        }
+      });
+    }
+  }
   if (containsTrackedChanges(xmlDoc)) {
     if (existingRevisionsPolicy === "merge-same-author" || existingRevisionsPolicy === "slice-cross-author") {
       const authors = getTrackedChangeAuthors(xmlDoc);
@@ -8243,7 +8510,7 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
     }
   }
   const { cleanText: cleanModifiedText, formatHints } = preprocessMarkdown(sanitizedText);
-  const hasTextChanges = cleanModifiedText.trim() !== originalText.trim();
+  const hasTextChanges = existingRevisionsPolicy === "slice-cross-author" ? cleanModifiedText !== originalText : cleanModifiedText.trim() !== originalText.trim();
   const hasFormatHints = formatHints.length > 0;
   const { existingFormatHints, textSpans, paragraphs } = extractFormattingFromOoxml(xmlDoc);
   const hasExistingFormatting = existingFormatHints.length > 0;
@@ -8396,6 +8663,9 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
         {},
         options
       );
+      if (result.status === "error" && result.error?.code === "PATCH_ROUNDTRIP_MISMATCH") {
+        return finalize({ ...result, oxml: inputOoxml, hasChanges: false });
+      }
       if (tableCellContext.hasTableWrapper && result.hasChanges && tableCellContext.targetParagraph) {
         log("[OxmlEngine] Stripping table wrapper for table cell paragraph (surgical mode)");
         return finalize({ oxml: serializeParagraphOnly(xmlDoc, tableCellContext.targetParagraph, serializer), hasChanges: true });
@@ -8788,6 +9058,23 @@ function resolveTargetParagraph(xmlDoc, options = {}) {
     }
     return { paragraph: byId, resolvedBy: "paragraph_id" };
   }
+  if (descriptor?.fingerprint && !cleanTargetText && !parsedRef) {
+    let fingerprintCandidates = (paragraphMetadataIndex?.entries || []).filter((candidate) => candidate.fingerprint === descriptor.fingerprint);
+    if (typeof descriptor.inTable === "boolean") {
+      fingerprintCandidates = fingerprintCandidates.filter((candidate) => candidate.inTable === descriptor.inTable);
+    }
+    if (fingerprintCandidates.length === 1) {
+      return { paragraph: fingerprintCandidates[0].paragraph, resolvedBy: "fingerprint" };
+    }
+    if (fingerprintCandidates.length > 1) {
+      throw createTargetError(
+        "AMBIGUOUS_TARGET",
+        "Target fingerprint matched multiple paragraphs; provide paragraphId or index.",
+        fingerprintCandidates.map(serializeTargetCandidate)
+      );
+    }
+    throw createTargetError("TARGET_NOT_FOUND", `Target fingerprint not found: "${descriptor.fingerprint}".`);
+  }
   let candidates = [];
   if (cleanTargetText) {
     const unfilteredCandidates = findStrictTargetCandidates(xmlDoc, cleanTargetText, paragraphMetadataIndex);
@@ -9816,20 +10103,20 @@ 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 localNameOf2(node) {
+function localNameOf3(node) {
   return String(node?.localName || node?.nodeName || "").replace(/^.*:/, "");
 }
 function elementsByLocalName(root, name) {
-  return Array.from(root.getElementsByTagName("*")).filter((el) => localNameOf2(el) === name);
+  return Array.from(root.getElementsByTagName("*")).filter((el) => localNameOf3(el) === name);
 }
-function wordAttribute2(node, 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 localNameOf2(node.parentNode) === "rPr";
+  return localNameOf3(node.parentNode) === "rPr";
 }
 function parseOoxmlForValidation(oxml) {
   const attempt = (xml) => {
@@ -9866,14 +10153,14 @@ function validateRedlineOoxml(oxml) {
   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 && localNameOf2(el) === "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) => localNameOf2(child) === "sectPr" ? index : -1).filter((index) => index >= 0);
+    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) {
@@ -9881,16 +10168,16 @@ function validateRedlineOoxml(oxml) {
     }
   }
   for (const revision of revisions) {
-    const nested = Array.from(revision.getElementsByTagName("*")).filter((el) => el !== revision && ["ins", "del"].includes(localNameOf2(el)));
+    const nested = Array.from(revision.getElementsByTagName("*")).filter((el) => el !== revision && ["ins", "del"].includes(localNameOf3(el)));
     const invalidNested = nested.find((candidate) => {
-      if (localNameOf2(revision) !== "ins" || localNameOf2(candidate) !== "del") return true;
+      if (localNameOf3(revision) !== "ins" || localNameOf3(candidate) !== "del") return true;
       return candidate.parentNode !== revision;
     });
     if (invalidNested) {
       addIssue(
         "NESTED_REVISION",
         "error",
-        `<${revision.nodeName}> (w:id="${wordAttribute2(revision, "id")}") contains invalid nested <${invalidNested.nodeName}>.`
+        `<${revision.nodeName}> (w:id="${wordAttribute3(revision, "id")}") contains invalid nested <${invalidNested.nodeName}>.`
       );
     }
   }
@@ -9900,15 +10187,15 @@ function validateRedlineOoxml(oxml) {
       addIssue(
         "DEL_CONTAINS_T",
         "error",
-        `<w:del> (w:id="${wordAttribute2(del, "id")}") contains <w:t>; deleted text must use <w:delText>.`
+        `<w:del> (w:id="${wordAttribute3(del, "id")}") contains <w:t>; deleted text must use <w:delText>.`
       );
     }
   }
   for (const revision of revisions) {
     const missing = [];
-    if (!wordAttribute2(revision, "id")) missing.push("w:id");
-    if (!wordAttribute2(revision, "author")) missing.push("w:author");
-    if (!REVISION_DATE_PATTERN.test(wordAttribute2(revision, "date"))) missing.push("w:date");
+    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",
@@ -9919,8 +10206,8 @@ function validateRedlineOoxml(oxml) {
   }
   const seenIds = /* @__PURE__ */ new Set();
   for (const node of Array.from(doc.getElementsByTagName("*"))) {
-    if (!REVISION_ID_ELEMENTS.has(localNameOf2(node))) continue;
-    const id = wordAttribute2(node, "id");
+    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.`);
@@ -9948,10 +10235,18 @@ function validateRedlineOoxml(oxml) {
       addIssue(
         "EMPTY_REVISION_WRAPPER",
         "warning",
-        `<${revision.nodeName}> (w:id="${wordAttribute2(revision, "id")}") wraps no content.`
+        `<${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 };
 }