@adeu/core 1.6.8 → 1.7.1

package/dist/index.cjs

@@ -36,6 +36,7 @@ __export(index_exports, {
   RedlineEngine: () => RedlineEngine,
   apply_edits_to_markdown: () => apply_edits_to_markdown,
   create_unified_diff: () => create_unified_diff,
+  create_word_patch_diff: () => create_word_patch_diff,
   extractTextFromBuffer: () => extractTextFromBuffer,
   extract_outline: () => extract_outline,
   finalize_document: () => finalize_document,
@@ -78,7 +79,38 @@ function parseXml(xmlString) {
   return new import_xmldom.DOMParser().parseFromString(xmlString, "text/xml");
 }
 function serializeXml(node) {
-  return new import_xmldom.XMLSerializer().serializeToString(node);
+  let xml = new import_xmldom.XMLSerializer().serializeToString(node);
+  const rootTagRegex = /<([a-zA-Z0-9_:]+)(\s+[^>]+?)(>|\/>)/;
+  const match = rootTagRegex.exec(xml);
+  if (match && !match[1].startsWith("?")) {
+    const index = match.index;
+    const textBefore = xml.substring(0, index);
+    const isRoot = !textBefore.includes("<") || textBefore.trim().startsWith("<?xml") && (textBefore.match(/</g) || []).length === 1;
+    if (isRoot) {
+      const fullTag = match[0];
+      const elemStart = `<${match[1]}`;
+      const attrsStr = match[2];
+      const tagEnd = match[3];
+      const attrRegex = /([a-zA-Z0-9_:]+)\s*=\s*(["'])(.*?)\2/g;
+      const attrs = [];
+      let m;
+      while ((m = attrRegex.exec(attrsStr)) !== null) {
+        attrs.push(m[0].trim());
+      }
+      attrs.sort((a, b) => {
+        const aName = a.split("=")[0].trim();
+        const bName = b.split("=")[0].trim();
+        const aIsXmlns = aName.startsWith("xmlns");
+        const bIsXmlns = bName.startsWith("xmlns");
+        if (aIsXmlns && !bIsXmlns) return -1;
+        if (!aIsXmlns && bIsXmlns) return 1;
+        return aName < bName ? -1 : aName > bName ? 1 : 0;
+      });
+      const newTag = attrs.length > 0 ? `${elemStart} ${attrs.join(" ")}${tagEnd}` : `${elemStart}${tagEnd}`;
+      xml = xml.substring(0, index) + newTag + xml.substring(index + fullTag.length);
+    }
+  }
+  return xml;
 }
 
 // src/docx/bridge.ts
@@ -106,12 +138,16 @@ var Part = class {
   contentType;
   rels = /* @__PURE__ */ new Map();
   _element;
+  package;
   addRelationship(id, type, target, isExternal = false) {
     this.rels.set(id, new Relationship(id, type, target, isExternal));
     if (this.partname.endsWith(".rels")) {
       const doc = this._element.ownerDocument;
       if (doc) {
-        const relEl = doc.createElementNS("http://schemas.openxmlformats.org/package/2006/relationships", "Relationship");
+        const relEl = doc.createElementNS(
+          "http://schemas.openxmlformats.org/package/2006/relationships",
+          "Relationship"
+        );
         relEl.setAttribute("Id", id);
         relEl.setAttribute("Type", type);
         relEl.setAttribute("Target", target);
@@ -130,7 +166,9 @@ var DocxPackage = class {
   mainDocumentPart;
   getPartByPath(path) {
     const searchPath = path.startsWith("/") ? path.substring(1) : path;
-    return this.parts.find((p) => p.partname === searchPath || p.partname === "/" + searchPath);
+    return this.parts.find(
+      (p) => p.partname === searchPath || p.partname === "/" + searchPath
+    );
   }
   nextPartname(pattern) {
     let i = 1;
@@ -142,7 +180,13 @@ var DocxPackage = class {
   }
   addPart(partname, contentType, xmlString) {
     const doc = parseXml(xmlString);
-    const part = new Part(partname, xmlString, doc.documentElement, contentType);
+    const part = new Part(
+      partname,
+      xmlString,
+      doc.documentElement,
+      contentType
+    );
+    part.package = this;
     this.parts.push(part);
     const ctPart = this.getPartByPath("[Content_Types].xml");
     if (ctPart) {
@@ -164,7 +208,11 @@ var DocxPackage = class {
     if (!relsPart) {
       const xml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"></Relationships>`;
-      relsPart = this.addPart(relsPath, "application/vnd.openxmlformats-package.relationships+xml", xml);
+      relsPart = this.addPart(
+        relsPath,
+        "application/vnd.openxmlformats-package.relationships+xml",
+        xml
+      );
     }
     return relsPart;
   }
@@ -176,7 +224,9 @@ var DocumentObject = class _DocumentObject {
   }
   pkg;
   part;
-  settings = { oddAndEvenPagesHeaderFooter: false };
+  settings = {
+    oddAndEvenPagesHeaderFooter: false
+  };
   // Simplification for the TS port: sections hold header/footer refs
   sections = [];
   get element() {
@@ -203,6 +253,7 @@ var DocumentObject = class _DocumentObject {
         const doc = parseXml(text);
         const cType = contentTypes["/" + path] || "application/xml";
         const part = new Part("/" + path, text, doc.documentElement, cType);
+        part.package = pkg;
         pkg.parts.push(part);
       }
     }
@@ -218,7 +269,10 @@ var DocumentObject = class _DocumentObject {
         const type = rel.getAttribute("Type");
         const targetMode = rel.getAttribute("TargetMode");
         if (rId && target && type) {
-          mainPart.rels.set(rId, new Relationship(rId, type, target, targetMode === "External"));
+          mainPart.rels.set(
+            rId,
+            new Relationship(rId, type, target, targetMode === "External")
+          );
         }
       }
     }
@@ -784,7 +838,14 @@ function _get_style_cache(part) {
     const is_default = s.getAttribute("w:default") === "1" || s.getAttribute("w:default") === "true";
     if (s_type === "paragraph" && is_default) default_pstyle = s_id;
     const name_el = findChild(s, "w:name");
-    const name = name_el ? name_el.getAttribute("w:val") : s_id;
+    let name = name_el ? name_el.getAttribute("w:val") : s_id;
+    if (name && typeof name === "string") {
+      if (name.toLowerCase().startsWith("heading")) {
+        name = name.replace(/^heading/i, "Heading");
+      } else if (name.toLowerCase() === "title") {
+        name = "Title";
+      }
+    }
     const based_on_el = findChild(s, "w:basedOn");
     const based_on = based_on_el ? based_on_el.getAttribute("w:val") : null;
     let outline_lvl = null;
@@ -809,7 +870,8 @@ function _get_style_cache(part) {
   }
   const resolve_style = (s_id, visited) => {
     if (cache[s_id]) return cache[s_id];
-    if (visited.has(s_id) || !raw_styles[s_id]) return { name: s_id, outline_level: null, bold: false };
+    if (visited.has(s_id) || !raw_styles[s_id])
+      return { name: s_id, outline_level: null, bold: false };
     visited.add(s_id);
     const raw = raw_styles[s_id];
     const based_on_id = raw.based_on;
@@ -836,7 +898,9 @@ function _detect_heading_level_from_name(name) {
 }
 function is_native_heading(paragraph, style_cache, default_pstyle) {
   if (!style_cache) {
-    [style_cache, default_pstyle] = _get_style_cache(paragraph._parent.part || paragraph._parent);
+    [style_cache, default_pstyle] = _get_style_cache(
+      paragraph._parent.part || paragraph._parent
+    );
   }
   const pPr = findChild(paragraph._element, QN_W_PPR);
   if (pPr) {
@@ -858,7 +922,10 @@ function is_native_heading(paragraph, style_cache, default_pstyle) {
   if (style_info && style_info.outline_level !== null && style_info.outline_level >= 0 && style_info.outline_level <= 8) {
     return true;
   }
-  const style_name = style_info ? style_info.name : null;
+  let style_name = style_info ? style_info.name : style_id;
+  if (style_name && typeof style_name === "string" && style_name.toLowerCase().startsWith("heading")) {
+    style_name = style_name.replace(/^heading/i, "Heading");
+  }
   if (style_name?.startsWith("Heading")) return true;
   if (style_name === "Title") return true;
   if (style_name && style_name !== "Normal") {
@@ -868,7 +935,9 @@ function is_native_heading(paragraph, style_cache, default_pstyle) {
 }
 function get_paragraph_prefix(paragraph, style_cache, default_pstyle) {
   if (!style_cache) {
-    [style_cache, default_pstyle] = _get_style_cache(paragraph._parent.part || paragraph._parent);
+    [style_cache, default_pstyle] = _get_style_cache(
+      paragraph._parent.part || paragraph._parent
+    );
   }
   const pPr = findChild(paragraph._element, QN_W_PPR);
   if (pPr) {
@@ -890,7 +959,10 @@ function get_paragraph_prefix(paragraph, style_cache, default_pstyle) {
   if (style_info && style_info.outline_level !== null && style_info.outline_level >= 0 && style_info.outline_level <= 8) {
     return "#".repeat(style_info.outline_level + 1) + " ";
   }
-  const style_name = style_info ? style_info.name : null;
+  let style_name = style_info ? style_info.name : style_id;
+  if (style_name && typeof style_name === "string" && style_name.toLowerCase().startsWith("heading")) {
+    style_name = style_name.replace(/^heading/i, "Heading");
+  }
   if (style_name?.startsWith("Heading")) {
     const match = style_name.replace("Heading", "").trim();
     if (/^\d+$/.test(match)) return "#".repeat(parseInt(match, 10)) + " ";
@@ -957,9 +1029,11 @@ function get_run_style_markers(run, is_heading = null) {
   let is_italic = false;
   if (rPr) {
     const b = findChild(rPr, QN_W_B);
-    if (b && b.getAttribute(QN_W_VAL) !== "0" && b.getAttribute(QN_W_VAL) !== "false") is_bold = true;
+    if (b && b.getAttribute(QN_W_VAL) !== "0" && b.getAttribute(QN_W_VAL) !== "false")
+      is_bold = true;
     const i = findChild(rPr, QN_W_I);
-    if (i && i.getAttribute(QN_W_VAL) !== "0" && i.getAttribute(QN_W_VAL) !== "false") is_italic = true;
+    if (i && i.getAttribute(QN_W_VAL) !== "0" && i.getAttribute(QN_W_VAL) !== "false")
+      is_italic = true;
   }
   if (is_heading === null) {
     const parent = run._parent;
@@ -1004,7 +1078,8 @@ function* iter_block_items(parent) {
     const tag = parent.note_type === "fn" ? "w:footnote" : "w:endnote";
     const notes = findAllDescendants(parent_elm, tag);
     for (const child of notes) {
-      if (child.getAttribute("w:type") === "separator" || child.getAttribute("w:type") === "continuationSeparator") continue;
+      if (child.getAttribute("w:type") === "separator" || child.getAttribute("w:type") === "continuationSeparator")
+        continue;
       yield new FootnoteItem(child, parent, parent.note_type);
     }
     return;
@@ -1020,7 +1095,15 @@ function* iter_block_items(parent) {
   }
 }
 function* iter_document_parts(doc) {
+  const headers = doc.pkg.parts.filter(
+    (p) => p.contentType === "application/vnd.openxmlformats-officedocument.wordprocessingml.header+xml"
+  );
+  for (const h of headers) yield h;
   yield doc;
+  const footers = doc.pkg.parts.filter(
+    (p) => p.contentType === "application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml"
+  );
+  for (const f of footers) yield f;
   const fnPart = doc.pkg.getPartByPath("word/footnotes.xml");
   const enPart = doc.pkg.getPartByPath("word/endnotes.xml");
   if (fnPart) yield new NotesPart(fnPart, "fn");
@@ -1034,7 +1117,8 @@ function _is_page_instr(instr) {
 function _get_part(parent) {
   if (!parent) return null;
   if (parent.part) return parent.part;
-  if (parent.pkg && parent.pkg.mainDocumentPart) return parent.pkg.mainDocumentPart;
+  if (parent.pkg && parent.pkg.mainDocumentPart)
+    return parent.pkg.mainDocumentPart;
   if (parent._parent) return _get_part(parent._parent);
   return null;
 }
@@ -1049,7 +1133,12 @@ function* iter_paragraph_content(paragraph) {
       const rPrChange = findChild(rPr, QN_W_RPRCHANGE);
       if (rPrChange) {
         c_id = rPrChange.getAttribute(QN_W_ID);
-        yield { type: "fmt_start", id: c_id, author: rPrChange.getAttribute(QN_W_AUTHOR) || void 0, date: rPrChange.getAttribute(QN_W_DATE) || void 0 };
+        yield {
+          type: "fmt_start",
+          id: c_id,
+          author: rPrChange.getAttribute(QN_W_AUTHOR) || void 0,
+          date: rPrChange.getAttribute(QN_W_DATE) || void 0
+        };
       }
     }
     for (let i = 0; i < r_element.childNodes.length; i++) {
@@ -1074,12 +1163,14 @@ function* iter_paragraph_content(paragraph) {
           if (_is_page_instr(current_instr)) hide_result = true;
           else {
             const parts = current_instr.trim().split(/\s+/);
-            if (parts.length > 1 && parts[0] === "REF") yield { type: "xref_start", id: parts[1] };
+            if (parts.length > 1 && parts[0] === "REF")
+              yield { type: "xref_start", id: parts[1] };
           }
         } else if (fld_type === "end") {
           if (!hide_result) {
             const parts = current_instr.trim().split(/\s+/);
-            if (parts.length > 1 && parts[0] === "REF") yield { type: "xref_end", id: parts[1] };
+            if (parts.length > 1 && parts[0] === "REF")
+              yield { type: "xref_end", id: parts[1] };
           }
           in_complex_field = false;
           current_instr = "";
@@ -1100,16 +1191,28 @@ function* iter_paragraph_content(paragraph) {
       if (tag === QN_W_R) yield* process_run_element(child);
       else if (tag === QN_W_INS) {
         const i_id = child.getAttribute(QN_W_ID);
-        yield { type: "ins_start", id: i_id, author: child.getAttribute(QN_W_AUTHOR) || void 0, date: child.getAttribute(QN_W_DATE) || void 0 };
+        yield {
+          type: "ins_start",
+          id: i_id,
+          author: child.getAttribute(QN_W_AUTHOR) || void 0,
+          date: child.getAttribute(QN_W_DATE) || void 0
+        };
         yield* traverse_node(child);
         yield { type: "ins_end", id: i_id };
       } else if (tag === QN_W_DEL) {
         const d_id = child.getAttribute(QN_W_ID);
-        yield { type: "del_start", id: d_id, author: child.getAttribute(QN_W_AUTHOR) || void 0, date: child.getAttribute(QN_W_DATE) || void 0 };
+        yield {
+          type: "del_start",
+          id: d_id,
+          author: child.getAttribute(QN_W_AUTHOR) || void 0,
+          date: child.getAttribute(QN_W_DATE) || void 0
+        };
         yield* traverse_node(child);
         yield { type: "del_end", id: d_id };
-      } else if (tag === QN_W_COMMENTRANGESTART) yield { type: "start", id: child.getAttribute(QN_W_ID) };
-      else if (tag === QN_W_COMMENTRANGEEND) yield { type: "end", id: child.getAttribute(QN_W_ID) };
+      } else if (tag === QN_W_COMMENTRANGESTART)
+        yield { type: "start", id: child.getAttribute(QN_W_ID) };
+      else if (tag === QN_W_COMMENTRANGEEND)
+        yield { type: "end", id: child.getAttribute(QN_W_ID) };
       else if (tag === QN_W_HYPERLINK) {
         const rId = child.getAttribute(QN_R_ID) || child.getAttribute("id");
         let url = "";
@@ -1130,7 +1233,8 @@ function* iter_paragraph_content(paragraph) {
         if (target) yield { type: "xref_end", id: target };
       } else if (tag === QN_W_BOOKMARKSTART) {
         const b_name = child.getAttribute(QN_W_NAME);
-        if (b_name && (!b_name.startsWith("_") || b_name.startsWith("_Ref"))) yield { type: "bookmark", id: b_name };
+        if (b_name && (!b_name.startsWith("_") || b_name.startsWith("_Ref")))
+          yield { type: "bookmark", id: b_name };
       } else if (tag === QN_W_SDT || tag === QN_W_SMARTTAG || tag === QN_W_SDTCONTENT) {
         yield* traverse_node(child);
       }
@@ -1942,13 +2046,18 @@ function _words_to_chars(text1, text2) {
 }
 function generate_edits_from_text(original_text, modified_text) {
   const dmp = new import_diff_match_patch.default.diff_match_patch();
-  const [chars1, chars2, token_array] = _words_to_chars(original_text, modified_text);
+  dmp.Diff_Timeout = 2;
+  const [chars1, chars2, token_array] = _words_to_chars(
+    original_text,
+    modified_text
+  );
   const diffs = dmp.diff_main(chars1, chars2, false);
   dmp.diff_cleanupSemantic(diffs);
   for (let i = 0; i < diffs.length; i++) {
     const chars = diffs[i][1];
     let text = "";
-    for (let j = 0; j < chars.length; j++) text += token_array[chars.charCodeAt(j)];
+    for (let j = 0; j < chars.length; j++)
+      text += token_array[chars.charCodeAt(j)];
     diffs[i][1] = text;
   }
   const edits = [];
@@ -1958,7 +2067,13 @@ function generate_edits_from_text(original_text, modified_text) {
     if (op === 0) {
       if (pending_delete) {
         const [idx, del_txt] = pending_delete;
-        edits.push({ type: "modify", target_text: del_txt, new_text: "", comment: "Diff: Text deleted", _match_start_index: idx });
+        edits.push({
+          type: "modify",
+          target_text: del_txt,
+          new_text: "",
+          comment: "Diff: Text deleted",
+          _match_start_index: idx
+        });
         pending_delete = null;
       }
       current_original_index += text.length;
@@ -1968,21 +2083,40 @@ function generate_edits_from_text(original_text, modified_text) {
     } else if (op === 1) {
       if (pending_delete) {
         const [idx, del_txt] = pending_delete;
-        edits.push({ type: "modify", target_text: del_txt, new_text: text, comment: "Diff: Replacement", _match_start_index: idx });
+        edits.push({
+          type: "modify",
+          target_text: del_txt,
+          new_text: text,
+          comment: "Diff: Replacement",
+          _match_start_index: idx
+        });
         pending_delete = null;
       } else {
-        edits.push({ type: "modify", target_text: "", new_text: text, comment: "Diff: Text inserted", _match_start_index: current_original_index });
+        edits.push({
+          type: "modify",
+          target_text: "",
+          new_text: text,
+          comment: "Diff: Text inserted",
+          _match_start_index: current_original_index
+        });
       }
     }
   }
   if (pending_delete) {
     const [idx, del_txt] = pending_delete;
-    edits.push({ type: "modify", target_text: del_txt, new_text: "", comment: "Diff: Text deleted", _match_start_index: idx });
+    edits.push({
+      type: "modify",
+      target_text: del_txt,
+      new_text: "",
+      comment: "Diff: Text deleted",
+      _match_start_index: idx
+    });
   }
   return edits;
 }
 function create_unified_diff(original_text, modified_text, context_lines = 3) {
   const dmp = new import_diff_match_patch.default.diff_match_patch();
+  dmp.Diff_Timeout = 2;
   const a = dmp.diff_linesToChars_(original_text, modified_text);
   const diffs = dmp.diff_main(a.chars1, a.chars2, false);
   dmp.diff_charsToLines_(diffs, a.lineArray);
@@ -2025,159 +2159,614 @@ function create_unified_diff(original_text, modified_text, context_lines = 3) {
   if (output.length === 2) return "";
   return output.join("\n");
 }
-
-// src/engine.ts
-function insertAfter(newNode, refNode) {
-  if (refNode.parentNode) {
-    refNode.parentNode.insertBefore(newNode, refNode.nextSibling);
+function create_word_patch_diff(original_text, modified_text, original_path = "Original", modified_path = "Modified") {
+  const edits = generate_edits_from_text(original_text, modified_text);
+  const output = [
+    `--- ${original_path}`,
+    `+++ ${modified_path}`,
+    ""
+  ];
+  const CONTEXT_SIZE = 40;
+  for (const edit of edits) {
+    const raw_start = edit._match_start_index || 0;
+    const raw_target = edit.target_text || "";
+    const raw_new = edit.new_text || "";
+    const [prefix_len, suffix_len] = trim_common_context(raw_target, raw_new);
+    const target_end_in_target = raw_target.length - suffix_len;
+    const new_end_in_new = raw_new.length - suffix_len;
+    const display_target = raw_target.substring(prefix_len, target_end_in_target);
+    const display_new = raw_new.substring(prefix_len, new_end_in_new);
+    const change_start = raw_start + prefix_len;
+    const change_end = change_start + display_target.length;
+    let pre_start = Math.max(0, change_start - CONTEXT_SIZE);
+    let pre_context = original_text.substring(pre_start, change_start);
+    if (pre_start > 0) pre_context = "..." + pre_context;
+    let post_end = Math.min(original_text.length, change_end + CONTEXT_SIZE);
+    let post_context = original_text.substring(change_end, post_end);
+    if (post_end < original_text.length) post_context = post_context + "...";
+    pre_context = pre_context.replace(/\n/g, " ").replace(/\r/g, "");
+    post_context = post_context.replace(/\n/g, " ").replace(/\r/g, "");
+    output.push("@@ Word Patch @@");
+    output.push(` ${pre_context}`);
+    if (display_target) output.push(`- ${display_target}`);
+    if (display_new) output.push(`+ ${display_new}`);
+    output.push(` ${post_context}`);
+    output.push("");
   }
+  return output.join("\n");
 }
-var BatchValidationError = class extends Error {
-  errors;
-  constructor(errors) {
-    super("Batch validation failed:\n" + errors.join("\n"));
-    this.name = "BatchValidationError";
-    this.errors = errors;
+
+// src/markup.ts
+var AMBIGUITY_EXAMPLES_CAP = 5;
+var AMBIGUITY_CONTEXT_CHARS = 50;
+function _should_strip_markers(text, marker) {
+  if (!text.startsWith(marker) || !text.endsWith(marker)) return false;
+  if (text.length < marker.length * 2) return false;
+  const inner = text.substring(marker.length, text.length - marker.length);
+  if (!inner) return false;
+  if (inner.includes(marker)) return false;
+  if (!/[a-zA-Z]/.test(inner)) return false;
+  if (marker === "__" && /^\w+$/.test(inner)) return false;
+  if (marker === "_") {
+    if (inner.includes("_")) return false;
+    if (/^[0-9_]+$/.test(inner)) return false;
   }
-};
-function validate_edit_strings(edits) {
-  const errors = [];
-  for (let i = 0; i < edits.length; i++) {
-    const edit = edits[i];
-    const t_text = edit.target_text || "";
-    const n_text = edit.new_text || "";
-    if (n_text.includes("{++") || n_text.includes("{--") || n_text.includes("{>>") || n_text.includes("{==")) {
-      errors.push(`- Edit ${i + 1} Failed: Do not manually write CriticMarkup tags ({++, {--, {>>, {==) in \`new_text\`. The engine handles redlining automatically. To add a comment, use the \`comment\` parameter.`);
-    }
-    if (t_text.includes("[^") || n_text.includes("[^")) {
-      const t_fns = (t_text.match(/\[\^(?:fn|en)-[^\]]+\]/g) || []).sort();
-      const n_fns = (n_text.match(/\[\^(?:fn|en)-[^\]]+\]/g) || []).sort();
-      if (JSON.stringify(t_fns) !== JSON.stringify(n_fns)) {
-        if (n_fns.length > t_fns.length || n_fns.some((f) => n_fns.filter((x) => x === f).length > t_fns.filter((x) => x === f).length)) {
-          errors.push(`- Edit ${i + 1} Failed: Cannot insert footnote/endnote markers via text replace. Markers like \`[^fn-N]\` are read-only projections. Use Word's References menu.`);
-        } else {
-          errors.push(`- Edit ${i + 1} Failed: Cannot delete footnote/endnote references via text replace. The marker corresponds to a structural XML element.`);
-        }
-      }
-    }
-    if (t_text.includes("](") || n_text.includes("](")) {
-      const t_links = (t_text.match(/\[(?!~)[^\]]+\]\([^)]+\)/g) || []).sort();
-      const n_links = (n_text.match(/\[(?!~)[^\]]+\]\([^)]+\)/g) || []).sort();
-      if (t_links.length !== n_links.length) {
-        if (n_links.length > t_links.length) {
-          errors.push(`- Edit ${i + 1} Failed: Cannot insert hyperlinks via text replace. Use a dedicated structural operation.`);
-        } else {
-          errors.push(`- Edit ${i + 1} Failed: Cannot delete hyperlinks via text replace. The marker corresponds to a structural XML element.`);
-        }
-      } else if (t_links.length > 1 && JSON.stringify(t_links) !== JSON.stringify(n_links)) {
-        errors.push(`- Edit ${i + 1} Failed: Can only edit or retarget one hyperlink per text replacement. Please split into multiple edits.`);
-      }
-    }
-    if (t_text.includes("[~") || n_text.includes("[~")) {
-      const t_xrefs = t_text.match(/\[~[^~]+~\]\(#[^\)]+\)/g) || [];
-      const n_xrefs = n_text.match(/\[~[^~]+~\]\(#[^\)]+\)/g) || [];
-      if (t_xrefs.length !== n_xrefs.length) {
-        if (n_xrefs.length > t_xrefs.length) {
-          errors.push(`- Edit ${i + 1} Failed: Cannot insert cross-references via text replace. Markers are read-only projections.`);
-        } else {
-          errors.push(`- Edit ${i + 1} Failed: Cannot delete cross-references via text replace. The marker corresponds to a structural XML element.`);
-        }
-      } else {
-        if (JSON.stringify(t_xrefs) !== JSON.stringify(n_xrefs)) {
-          errors.push(`- Edit ${i + 1} Failed: Modifying or retargeting cross-reference markers is disallowed to prevent dependency corruption.`);
-        }
-      }
+  return true;
+}
+function _strip_balanced_markers(text) {
+  let prefix_markup = "";
+  let suffix_markup = "";
+  let clean_text = text;
+  const markers = ["**", "__", "_", "*"];
+  for (const marker of markers) {
+    if (_should_strip_markers(clean_text, marker)) {
+      prefix_markup += marker;
+      suffix_markup = marker + suffix_markup;
+      clean_text = clean_text.substring(
+        marker.length,
+        clean_text.length - marker.length
+      );
+      break;
     }
-    if (t_text.includes("{#") || n_text.includes("{#")) {
-      const t_anchors = t_text.match(/\{#[^\}]+\}/g) || [];
-      const n_anchors = n_text.match(/\{#[^\}]+\}/g) || [];
-      for (const a of n_anchors) {
-        if (n_anchors.filter((x) => x === a).length > t_anchors.filter((x) => x === a).length) {
-          errors.push(`- Edit ${i + 1} Failed: Cannot modify or insert internal anchor markers (\`{#...}\`). These represent structural XML bookmarks.`);
-          break;
-        }
+  }
+  return [prefix_markup, clean_text, suffix_markup];
+}
+function _replace_smart_quotes(text) {
+  return text.replace(/“/g, '"').replace(/”/g, '"').replace(/‘/g, "'").replace(/’/g, "'");
+}
+function _find_safe_boundaries(text, start, end) {
+  let new_start = start;
+  let new_end = end;
+  const expand_if_unbalanced = (marker) => {
+    const current_match = text.substring(new_start, new_end);
+    const count = (current_match.match(new RegExp(marker.replace(/\*/g, "\\*"), "g")) || []).length;
+    if (count % 2 !== 0) {
+      const suffix = text.substring(new_end);
+      if (suffix.startsWith(marker)) {
+        new_end += marker.length;
+        return;
       }
-    }
-    if (edit.type === "modify" && n_text) {
-      const lines = n_text.split("\n");
-      for (const line of lines) {
-        const stripped = line.trimStart();
-        if (stripped.startsWith("#######")) {
-          const level = stripped.length - stripped.replace(/^#+/, "").length;
-          if (stripped.substring(level).startsWith(" ") || stripped.substring(level) === "") {
-            errors.push(`- Edit ${i + 1} Failed: Heading level ${level} is not supported (maximum is 6).`);
-            break;
-          }
-        }
+      const prefix = text.substring(0, new_start);
+      if (prefix.endsWith(marker)) {
+        new_start -= marker.length;
+        return;
       }
     }
-    if (t_text.includes("READONLY_BOUNDARY_START") || n_text.includes("READONLY_BOUNDARY_START") || t_text.includes("# Document Structure (Read-Only)") || n_text.includes("# Document Structure (Read-Only)")) {
-      errors.push(`- Edit ${i + 1} Failed: Modification targets the read-only boundary (Structural Appendix). This section cannot be edited.`);
-    }
+  };
+  for (let i = 0; i < 2; i++) {
+    expand_if_unbalanced("**");
+    expand_if_unbalanced("__");
+    expand_if_unbalanced("_");
+    expand_if_unbalanced("*");
   }
-  return errors;
+  return [new_start, new_end];
 }
-var RedlineEngine = class {
-  doc;
-  author;
-  timestamp;
-  current_id;
-  mapper;
-  comments_manager;
-  clean_mapper = null;
-  skipped_details = [];
-  constructor(doc, author = "Adeu AI (TS)") {
-    this.doc = doc;
-    this.author = author;
-    this.timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
-    const w16du_ns = "http://schemas.microsoft.com/office/word/2023/wordml/word16du";
-    for (const part of this.doc.pkg.parts) {
-      if (part === this.doc.part || part.contentType.includes("wordprocessingml") && part.contentType.endsWith("+xml")) {
-        if (!part._element.hasAttribute("xmlns:w16du")) {
-          part._element.setAttribute("xmlns:w16du", w16du_ns);
-        }
+function _refine_match_boundaries(text, start, end) {
+  const markers = ["**", "__", "*", "_"];
+  let current_text = text.substring(start, end);
+  let best_start = start;
+  let best_end = end;
+  const countMarker = (str, mk) => (str.match(new RegExp(mk.replace(/\*/g, "\\*"), "g")) || []).length;
+  for (const marker of markers) {
+    if (current_text.startsWith(marker)) {
+      const current_score = countMarker(current_text, marker) % 2;
+      const trimmed_text = current_text.substring(marker.length);
+      const trimmed_score = countMarker(trimmed_text, marker) % 2;
+      if (current_score === 1 && trimmed_score === 0) {
+        best_start += marker.length;
+        current_text = trimmed_text;
       }
     }
-    this.current_id = this._scan_existing_ids();
-    this.mapper = new DocumentMapper(this.doc);
-    this.comments_manager = new CommentsManager(this.doc);
   }
-  _scan_existing_ids() {
-    let maxId = 0;
-    for (const tag of ["w:ins", "w:del"]) {
-      const elements = findAllDescendants(this.doc.element, tag);
-      for (const el of elements) {
-        const val = parseInt(el.getAttribute("w:id") || "0", 10);
-        if (!isNaN(val) && val > maxId) maxId = val;
+  for (const marker of markers) {
+    if (current_text.endsWith(marker)) {
+      const current_score = countMarker(current_text, marker) % 2;
+      const trimmed_text = current_text.substring(
+        0,
+        current_text.length - marker.length
+      );
+      const trimmed_score = countMarker(trimmed_text, marker) % 2;
+      if (current_score === 1 && trimmed_score === 0) {
+        best_end -= marker.length;
+        current_text = trimmed_text;
       }
     }
-    return maxId;
   }
-  accept_all_revisions() {
-    const dels = findAllDescendants(this.doc.element, "w:del");
-    for (const d of dels) {
-      const parent = d.parentNode;
-      if (parent?.tagName === "w:trPr") {
-        const tr = parent.parentNode;
-        tr?.parentNode?.removeChild(tr);
-      } else {
-        parent?.removeChild(d);
-      }
+  return [best_start, best_end];
+}
+function _make_fuzzy_regex(target_text) {
+  target_text = _replace_smart_quotes(target_text);
+  const parts = [];
+  const token_pattern = /(_+)|(\s+)|(['"])|([.,;:\/])/g;
+  const md_noise = "[*_]*";
+  const structural_noise = "(?:\\s*(?:[*+\\->]|\\d+\\.)\\s+|\\s*\\n\\s*)";
+  const start_list_marker = "(?:[ \\t]*(?:[*+\\->]|\\d+\\.)\\s+)?";
+  parts.push(start_list_marker);
+  parts.push(md_noise);
+  let last_idx = 0;
+  let match;
+  const escapeRegExp = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  while ((match = token_pattern.exec(target_text)) !== null) {
+    const literal = target_text.substring(last_idx, match.index);
+    if (literal) {
+      parts.push(escapeRegExp(literal));
+      parts.push(md_noise);
     }
-    const insNodes = findAllDescendants(this.doc.element, "w:ins");
-    for (const i of insNodes) {
-      const parent = i.parentNode;
-      if (parent?.tagName === "w:trPr") {
-        parent.removeChild(i);
+    const g_underscore = match[1];
+    const g_space = match[2];
+    const g_quote = match[3];
+    const g_punct = match[4];
+    if (g_underscore) {
+      parts.push("_+");
+    } else if (g_space) {
+      if (g_space.includes("\n")) {
+        parts.push(`(?:${structural_noise}|\\s+)+`);
       } else {
-        while (i.firstChild) parent?.insertBefore(i.firstChild, i);
-        parent?.removeChild(i);
+        parts.push("\\s+");
       }
+    } else if (g_quote) {
+      if (g_quote === "'") parts.push("[\u2018\u2019']");
+      else parts.push('["\u201C\u201D]');
+    } else if (g_punct) {
+      parts.push(escapeRegExp(g_punct));
     }
+    parts.push(md_noise);
+    last_idx = token_pattern.lastIndex;
   }
-  _getNextId() {
-    this.current_id++;
-    return this.current_id.toString();
+  const remaining = target_text.substring(last_idx);
+  if (remaining) parts.push(escapeRegExp(remaining));
+  return parts.join("");
+}
+function _find_match_in_text(text, target) {
+  if (!target) return [-1, -1];
+  let idx = text.indexOf(target);
+  if (idx !== -1) return _find_safe_boundaries(text, idx, idx + target.length);
+  const norm_text = _replace_smart_quotes(text);
+  const norm_target = _replace_smart_quotes(target);
+  idx = norm_text.indexOf(norm_target);
+  if (idx !== -1)
+    return _find_safe_boundaries(text, idx, idx + norm_target.length);
+  try {
+    const pattern = new RegExp(_make_fuzzy_regex(target));
+    const match = pattern.exec(text);
+    if (match) {
+      const raw_start = match.index;
+      const raw_end = match.index + match[0].length;
+      const [refined_start, refined_end] = _refine_match_boundaries(
+        text,
+        raw_start,
+        raw_end
+      );
+      return _find_safe_boundaries(text, refined_start, refined_end);
+    }
+  } catch (e) {
+  }
+  return [-1, -1];
+}
+function _build_critic_markup(target_text, new_text, comment, edit_index, include_index, highlight_only) {
+  const parts = [];
+  let [prefix_markup, clean_target, suffix_markup] = _strip_balanced_markers(target_text);
+  let clean_new = new_text;
+  if (prefix_markup && new_text) {
+    if (new_text.startsWith(prefix_markup) && new_text.endsWith(suffix_markup)) {
+      const inner_len = prefix_markup.length;
+      clean_new = new_text.length > inner_len * 2 ? new_text.substring(inner_len, new_text.length - inner_len) : new_text;
+    }
+  }
+  parts.push(prefix_markup);
+  if (highlight_only) {
+    parts.push(`{==${clean_target}==}`);
+  } else {
+    const has_target = Boolean(clean_target);
+    const has_new = Boolean(clean_new);
+    if (has_target && !has_new) parts.push(`{--${clean_target}--}`);
+    else if (!has_target && has_new) parts.push(`{++${clean_new}++}`);
+    else if (has_target && has_new)
+      parts.push(`{--${clean_target}--}{++${clean_new}++}`);
+  }
+  parts.push(suffix_markup);
+  const meta_parts = [];
+  if (comment) meta_parts.push(comment);
+  if (include_index) meta_parts.push(`[Edit:${edit_index}]`);
+  if (meta_parts.length > 0) {
+    parts.push(`{>>${meta_parts.join(" ")}<<}`);
+  }
+  return parts.join("");
+}
+function apply_edits_to_markdown(markdown_text, edits, include_index = false, highlight_only = false) {
+  if (!edits || edits.length === 0) return markdown_text;
+  const matched_edits = [];
+  for (let idx = 0; idx < edits.length; idx++) {
+    const edit = edits[idx];
+    const target = edit.target_text || "";
+    if (!target) {
+      continue;
+    }
+    const [start, end] = _find_match_in_text(markdown_text, target);
+    if (start === -1) continue;
+    const actual_matched_text = markdown_text.substring(start, end);
+    matched_edits.push([start, end, actual_matched_text, edit, idx]);
+  }
+  const matched_edits_filtered = [];
+  const occupied_ranges = [];
+  matched_edits.sort((a, b) => a[4] - b[4]);
+  for (const [start, end, actual_text, edit, orig_idx] of matched_edits) {
+    let overlaps = false;
+    for (const [occ_start, occ_end] of occupied_ranges) {
+      if (start < occ_end && end > occ_start) {
+        overlaps = true;
+        break;
+      }
+    }
+    if (!overlaps) {
+      matched_edits_filtered.push([start, end, actual_text, edit, orig_idx]);
+      occupied_ranges.push([start, end]);
+    }
+  }
+  matched_edits_filtered.sort((a, b) => b[0] - a[0]);
+  let result = markdown_text;
+  for (const [
+    start,
+    end,
+    actual_text,
+    edit,
+    orig_idx
+  ] of matched_edits_filtered) {
+    const new_txt = edit.new_text || "";
+    const [prefix_len, suffix_len] = trim_common_context(actual_text, new_txt);
+    const unmodified_prefix = prefix_len > 0 ? actual_text.substring(0, prefix_len) : "";
+    const unmodified_suffix = suffix_len > 0 ? actual_text.substring(actual_text.length - suffix_len) : "";
+    const t_end = actual_text.length - suffix_len;
+    const n_end = new_txt.length - suffix_len;
+    const isolated_target = actual_text.substring(prefix_len, t_end);
+    const isolated_new = new_txt.substring(prefix_len, n_end);
+    const markup = _build_critic_markup(
+      isolated_target,
+      isolated_new,
+      edit.comment,
+      orig_idx,
+      include_index,
+      highlight_only
+    );
+    const full_replacement = unmodified_prefix + markup + unmodified_suffix;
+    result = result.substring(0, start) + full_replacement + result.substring(end);
+  }
+  return result;
+}
+function format_ambiguity_error(edit_index, target_text, haystack, match_positions) {
+  const total = match_positions.length;
+  if (total < 2) {
+    throw new Error(
+      `format_ambiguity_error requires at least 2 matches, got ${total}`
+    );
+  }
+  const shown = match_positions.slice(0, AMBIGUITY_EXAMPLES_CAP);
+  const remaining = total - shown.length;
+  const lines = [
+    `- Edit ${edit_index} Failed: Ambiguous match. Target text appears ${total} times. First ${shown.length} occurrences:`
+  ];
+  for (let i = 0; i < shown.length; i++) {
+    const [start, end] = shown[i];
+    const pre_start = Math.max(0, start - AMBIGUITY_CONTEXT_CHARS);
+    const post_end = Math.min(haystack.length, end + AMBIGUITY_CONTEXT_CHARS);
+    const pre_context = haystack.substring(pre_start, start).replace(/\n/g, " ");
+    const post_context = haystack.substring(end, post_end).replace(/\n/g, " ");
+    let match_text = haystack.substring(start, end).replace(/\n/g, " ");
+    if (match_text.length > 50) {
+      match_text = match_text.substring(0, 25) + "..." + match_text.substring(match_text.length - 20);
+    }
+    const prefix_marker = pre_start > 0 ? "..." : "";
+    const suffix_marker = post_end < haystack.length ? "..." : "";
+    lines.push(
+      `    ${i + 1}. "${prefix_marker}${pre_context}[${match_text}]${post_context}${suffix_marker}"`
+    );
+  }
+  if (remaining > 0) {
+    lines.push(`    ... and ${remaining} more occurrence(s) not shown.`);
+  }
+  lines.push(
+    "  Please provide more surrounding context in your target_text to uniquely identify the location."
+  );
+  return lines.join("\n");
+}
+
+// src/engine.ts
+function getNextElement(el) {
+  let next = el.nextSibling;
+  while (next) {
+    if (next.nodeType === 1) return next;
+    next = next.nextSibling;
+  }
+  return null;
+}
+function getPreviousElement(el) {
+  let prev = el.previousSibling;
+  while (prev) {
+    if (prev.nodeType === 1) return prev;
+    prev = prev.previousSibling;
+  }
+  return null;
+}
+function insertAfter(newNode, refNode) {
+  if (refNode.parentNode) {
+    refNode.parentNode.insertBefore(newNode, refNode.nextSibling);
+  }
+}
+var BatchValidationError = class extends Error {
+  errors;
+  constructor(errors) {
+    super("Batch validation failed:\n" + errors.join("\n"));
+    this.name = "BatchValidationError";
+    this.errors = errors;
+  }
+};
+function validate_edit_strings(edits) {
+  const errors = [];
+  for (let i = 0; i < edits.length; i++) {
+    const edit = edits[i];
+    const t_text = edit.target_text || "";
+    const n_text = edit.new_text || "";
+    if (n_text.includes("{++") || n_text.includes("{--") || n_text.includes("{>>") || n_text.includes("{==")) {
+      errors.push(
+        `- Edit ${i + 1} Failed: Do not manually write CriticMarkup tags ({++, {--, {>>, {==) in \`new_text\`. The engine handles redlining automatically. To add a comment, use the \`comment\` parameter.`
+      );
+    }
+    if (t_text.includes("[^") || n_text.includes("[^")) {
+      const t_fns = (t_text.match(/\[\^(?:fn|en)-[^\]]+\]/g) || []).sort();
+      const n_fns = (n_text.match(/\[\^(?:fn|en)-[^\]]+\]/g) || []).sort();
+      if (JSON.stringify(t_fns) !== JSON.stringify(n_fns)) {
+        if (n_fns.length > t_fns.length || n_fns.some(
+          (f) => n_fns.filter((x) => x === f).length > t_fns.filter((x) => x === f).length
+        )) {
+          errors.push(
+            `- Edit ${i + 1} Failed: Cannot insert footnote/endnote markers via text replace. Markers like \`[^fn-N]\` are read-only projections. Use Word's References menu.`
+          );
+        } else {
+          errors.push(
+            `- Edit ${i + 1} Failed: Cannot delete footnote/endnote references via text replace. The marker corresponds to a structural XML element.`
+          );
+        }
+      }
+    }
+    if (t_text.includes("](") || n_text.includes("](")) {
+      const t_links = (t_text.match(/\[(?!~)[^\]]+\]\([^)]+\)/g) || []).sort();
+      const n_links = (n_text.match(/\[(?!~)[^\]]+\]\([^)]+\)/g) || []).sort();
+      if (t_links.length !== n_links.length) {
+        if (n_links.length > t_links.length) {
+          errors.push(
+            `- Edit ${i + 1} Failed: Cannot insert hyperlinks via text replace. Use a dedicated structural operation.`
+          );
+        } else {
+          errors.push(
+            `- Edit ${i + 1} Failed: Cannot delete hyperlinks via text replace. The marker corresponds to a structural XML element.`
+          );
+        }
+      } else if (t_links.length > 1 && JSON.stringify(t_links) !== JSON.stringify(n_links)) {
+        errors.push(
+          `- Edit ${i + 1} Failed: Can only edit or retarget one hyperlink per text replacement. Please split into multiple edits.`
+        );
+      }
+    }
+    if (t_text.includes("[~") || n_text.includes("[~")) {
+      const t_xrefs = t_text.match(/\[~[^~]+~\]\(#[^\)]+\)/g) || [];
+      const n_xrefs = n_text.match(/\[~[^~]+~\]\(#[^\)]+\)/g) || [];
+      if (t_xrefs.length !== n_xrefs.length) {
+        if (n_xrefs.length > t_xrefs.length) {
+          errors.push(
+            `- Edit ${i + 1} Failed: Cannot insert cross-references via text replace. Markers are read-only projections.`
+          );
+        } else {
+          errors.push(
+            `- Edit ${i + 1} Failed: Cannot delete cross-references via text replace. The marker corresponds to a structural XML element.`
+          );
+        }
+      } else {
+        if (JSON.stringify(t_xrefs) !== JSON.stringify(n_xrefs)) {
+          errors.push(
+            `- Edit ${i + 1} Failed: Modifying or retargeting cross-reference markers is disallowed to prevent dependency corruption.`
+          );
+        }
+      }
+    }
+    if (t_text.includes("{#") || n_text.includes("{#")) {
+      const t_anchors = t_text.match(/\{#[^\}]+\}/g) || [];
+      const n_anchors = n_text.match(/\{#[^\}]+\}/g) || [];
+      for (const a of n_anchors) {
+        if (n_anchors.filter((x) => x === a).length > t_anchors.filter((x) => x === a).length) {
+          errors.push(
+            `- Edit ${i + 1} Failed: Cannot modify or insert internal anchor markers (\`{#...}\`). These represent structural XML bookmarks.`
+          );
+          break;
+        }
+      }
+    }
+    if (edit.type === "modify" && n_text) {
+      const lines = n_text.split(/[\r\n]+/);
+      for (const line of lines) {
+        const stripped = line.trimStart();
+        if (stripped.startsWith("#######")) {
+          const level = stripped.length - stripped.replace(/^#+/, "").length;
+          if (stripped.substring(level).startsWith(" ") || stripped.substring(level) === "") {
+            errors.push(
+              `- Edit ${i + 1} Failed: Heading level ${level} is not supported (maximum is 6).`
+            );
+            break;
+          }
+        }
+      }
+    }
+    if (t_text.includes("READONLY_BOUNDARY_START") || n_text.includes("READONLY_BOUNDARY_START") || t_text.includes("# Document Structure (Read-Only)") || n_text.includes("# Document Structure (Read-Only)")) {
+      errors.push(
+        `- Edit ${i + 1} Failed: Modification targets the read-only boundary (Structural Appendix). This section cannot be edited.`
+      );
+    }
+  }
+  return errors;
+}
+var RedlineEngine = class {
+  doc;
+  author;
+  timestamp;
+  current_id;
+  mapper;
+  comments_manager;
+  clean_mapper = null;
+  skipped_details = [];
+  constructor(doc, author = "Adeu AI (TS)") {
+    this.doc = doc;
+    this.author = author;
+    this.timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+    const w16du_ns = "http://schemas.microsoft.com/office/word/2023/wordml/word16du";
+    for (const part of this.doc.pkg.parts) {
+      if (part === this.doc.part || part.contentType.includes("wordprocessingml") && part.contentType.endsWith("+xml")) {
+        if (!part._element.hasAttribute("xmlns:w16du")) {
+          part._element.setAttribute("xmlns:w16du", w16du_ns);
+        }
+      }
+    }
+    this.current_id = this._scan_existing_ids();
+    this.mapper = new DocumentMapper(this.doc);
+    this.comments_manager = new CommentsManager(this.doc);
+  }
+  _scan_existing_ids() {
+    let maxId = 0;
+    for (const tag of ["w:ins", "w:del"]) {
+      const elements = findAllDescendants(this.doc.element, tag);
+      for (const el of elements) {
+        const val = parseInt(el.getAttribute("w:id") || "0", 10);
+        if (!isNaN(val) && val > maxId) maxId = val;
+      }
+    }
+    return maxId;
+  }
+  accept_all_revisions() {
+    const parts_to_process = [this.doc.element];
+    for (const part of this.doc.pkg.parts) {
+      if (part === this.doc.part) continue;
+      if (part.contentType.includes("wordprocessingml") && part.contentType.endsWith("+xml")) {
+        parts_to_process.push(part._element);
+      }
+    }
+    for (const root_element of parts_to_process) {
+      const insNodes = findAllDescendants(root_element, "w:ins");
+      for (const ins of insNodes) {
+        this._clean_wrapping_comments(ins);
+        const parent = ins.parentNode;
+        if (!parent) continue;
+        if (parent.tagName === "w:trPr") {
+          parent.removeChild(ins);
+          continue;
+        }
+        while (ins.firstChild) {
+          parent.insertBefore(ins.firstChild, ins);
+        }
+        parent.removeChild(ins);
+      }
+      const pNodes = findAllDescendants(root_element, "w:p");
+      for (const p of pNodes) {
+        const pPr = findChild(p, "w:pPr");
+        if (pPr) {
+          const rPr = findChild(pPr, "w:rPr");
+          const delMark = rPr ? findChild(rPr, "w:del") : null;
+          if (rPr && delMark) {
+            let has_content = false;
+            for (const tag of ["w:t", "w:tab", "w:br"]) {
+              for (const child of findAllDescendants(p, tag)) {
+                if (tag === "w:t" && !child.textContent) continue;
+                let is_deleted = false;
+                let curr = child.parentNode;
+                while (curr && curr !== p) {
+                  if (curr.tagName === "w:del") {
+                    is_deleted = true;
+                    break;
+                  }
+                  curr = curr.parentNode;
+                }
+                if (!is_deleted) {
+                  has_content = true;
+                  break;
+                }
+              }
+              if (has_content) {
+                break;
+              }
+            }
+            if (has_content) {
+              rPr.removeChild(delMark);
+            } else {
+              this._clean_wrapping_comments(p);
+              this._delete_comments_in_element(p);
+              if (p.parentNode) {
+                p.parentNode.removeChild(p);
+              }
+            }
+          }
+        }
+      }
+      const delNodes = findAllDescendants(root_element, "w:del");
+      for (const d of delNodes) {
+        this._clean_wrapping_comments(d);
+        this._delete_comments_in_element(d);
+        const parent = d.parentNode;
+        if (parent) {
+          if (parent.tagName === "w:trPr") {
+            const row = parent.parentNode;
+            if (row && row.parentNode) {
+              row.parentNode.removeChild(row);
+            }
+          } else {
+            parent.removeChild(d);
+          }
+        }
+      }
+    }
+    const comment_ids = /* @__PURE__ */ new Set();
+    for (const tag of [
+      "w:commentRangeStart",
+      "w:commentRangeEnd",
+      "w:commentReference"
+    ]) {
+      for (const node of findAllDescendants(this.doc.element, tag)) {
+        const cid = node.getAttribute("w:id");
+        if (cid) comment_ids.add(cid);
+      }
+    }
+    const comments_part = this.doc.pkg.parts.find(
+      (p) => p.contentType === "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml"
+    );
+    if (comments_part) {
+      for (const c of findAllDescendants(comments_part._element, "w:comment")) {
+        const cid = c.getAttribute("w:id");
+        if (cid) comment_ids.add(cid);
+      }
+    }
+    for (const cid of comment_ids) {
+      this.comments_manager.deleteComment(cid);
+    }
+  }
+  _getNextId() {
+    this.current_id++;
+    return this.current_id.toString();
   }
   _create_track_change_tag(tagName, author = "", reuseId = null) {
     const xmlDoc = this.doc.part._element.ownerDocument;
@@ -2189,11 +2778,267 @@ var RedlineEngine = class {
     tag.setAttribute("w16du:dateUtc", this.timestamp);
     return tag;
   }
-  _set_text_content(element, text) {
-    element.textContent = text;
-    if (text.trim() !== text) {
-      element.setAttribute("xml:space", "preserve");
+  _set_text_content(element, text) {
+    element.textContent = text;
+    if (text.trim() !== text) {
+      element.setAttribute("xml:space", "preserve");
+    }
+  }
+  /**
+   * Attaches a comment that wraps a contiguous range within a single paragraph.
+   * start_element and end_element must both be direct children of parent_element
+   * and start_element must come before (or equal) end_element in document order.
+   * Ported from Python `RedlineEngine._attach_comment`.
+   */
+  _attach_comment(parent_element, start_element, end_element, text) {
+    if (!text) return;
+    const comment_id = this.comments_manager.addComment(this.author, text);
+    const xmlDoc = parent_element.ownerDocument;
+    const range_start = xmlDoc.createElement("w:commentRangeStart");
+    range_start.setAttribute("w:id", comment_id);
+    const range_end = xmlDoc.createElement("w:commentRangeEnd");
+    range_end.setAttribute("w:id", comment_id);
+    const ref_run = xmlDoc.createElement("w:r");
+    const rPr = xmlDoc.createElement("w:rPr");
+    const rStyle = xmlDoc.createElement("w:rStyle");
+    rStyle.setAttribute("w:val", "CommentReference");
+    rPr.appendChild(rStyle);
+    ref_run.appendChild(rPr);
+    const ref = xmlDoc.createElement("w:commentReference");
+    ref.setAttribute("w:id", comment_id);
+    ref_run.appendChild(ref);
+    parent_element.insertBefore(range_start, start_element);
+    const after_end = end_element.nextSibling;
+    if (after_end) {
+      parent_element.insertBefore(range_end, after_end);
+      parent_element.insertBefore(ref_run, range_end.nextSibling);
+    } else {
+      parent_element.appendChild(range_end);
+      parent_element.appendChild(ref_run);
+    }
+  }
+  /**
+   * Attaches a comment that spans across two different paragraphs (or other block
+   * containers). start_element lives inside start_p, end_element lives inside end_p,
+   * and the comment is open from start_element through end_element.
+   * Ported from Python `RedlineEngine._attach_comment_spanning`.
+   */
+  _attach_comment_spanning(start_p, start_el, end_p, end_el, text) {
+    if (!text) return;
+    const comment_id = this.comments_manager.addComment(this.author, text);
+    const xmlDocStart = start_p.ownerDocument;
+    const xmlDocEnd = end_p.ownerDocument;
+    const range_start = xmlDocStart.createElement("w:commentRangeStart");
+    range_start.setAttribute("w:id", comment_id);
+    const range_end = xmlDocEnd.createElement("w:commentRangeEnd");
+    range_end.setAttribute("w:id", comment_id);
+    const ref_run = xmlDocEnd.createElement("w:r");
+    const rPr = xmlDocEnd.createElement("w:rPr");
+    const rStyle = xmlDocEnd.createElement("w:rStyle");
+    rStyle.setAttribute("w:val", "CommentReference");
+    rPr.appendChild(rStyle);
+    ref_run.appendChild(rPr);
+    const ref = xmlDocEnd.createElement("w:commentReference");
+    ref.setAttribute("w:id", comment_id);
+    ref_run.appendChild(ref);
+    start_p.insertBefore(range_start, start_el);
+    const after_end = end_el.nextSibling;
+    if (after_end) {
+      end_p.insertBefore(range_end, after_end);
+      end_p.insertBefore(ref_run, range_end.nextSibling);
+    } else {
+      end_p.appendChild(range_end);
+      end_p.appendChild(ref_run);
+    }
+  }
+  /**
+  * Inserts `text` as one or more tracked paragraphs anchored relative to
+  * either an existing run or a paragraph. Returns:
+  *   { first_node, last_p, last_ins, used_block_mode }
+  * where:
+  *   - first_node: the first <w:ins> (for inline mode) OR the first new <w:p>
+  *     (for block mode). The caller uses this for splicing into the DOM and
+  *     for anchoring comments.
+  *   - last_p: the last new <w:p> created, if any. null when entirely inline.
+  *   - last_ins: the last <w:ins> created (inside the last new <w:p>, or the
+  *     sole inline ins). Used as the comment's end anchor.
+  *   - used_block_mode: true when the first line carried a heading/list style
+  *     marker and we created a new paragraph for it (rather than inlining it).
+  *
+  * Multi-paragraph rules (only when text contains '\n'):
+  *   - Each additional line becomes a new <w:p>, inserted after the anchor
+  *     paragraph in document order.
+  *   - Each new <w:p> gets a copy of the anchor paragraph's <w:pPr> (so list
+  *     numbering / indentation are preserved) unless the line itself starts
+  *     with a markdown heading or list marker, which overrides the style.
+  *   - Each new <w:p> carries a tracked paragraph-break marker
+  *     (<w:pPr><w:rPr><w:ins/></w:rPr></w:pPr>) so Word natively tracks the
+  *     paragraph break.
+  *   - Each new <w:p>'s content is wrapped in a <w:ins>, with inline bold/
+  *     italic markdown parsed via _parse_inline_markdown.
+  *
+  * The first line:
+  *   - If it carries a heading / list marker AND we have a paragraph anchor,
+  *     we drop into "block mode": no inline <w:ins>; the first line itself
+  *     becomes the first new <w:p>.
+  *   - Otherwise we emit a single inline <w:ins> for the first line (current
+  *     behaviour) and treat the remaining lines as block extensions.
+  *
+  * Does NOT attach comments; callers handle that.
+  */
+  _track_insert_multiline(text, anchor_run, anchor_paragraph, reuse_id) {
+    if (!text) {
+      return {
+        first_node: null,
+        last_p: null,
+        last_ins: null,
+        used_block_mode: false
+      };
+    }
+    const xmlDoc = this.doc.part._element.ownerDocument;
+    const lines = text.split(/[\r\n]+/);
+    let current_p = null;
+    if (anchor_paragraph !== null) {
+      current_p = anchor_paragraph._element;
+    } else if (anchor_run !== null) {
+      let walker = anchor_run._element;
+      while (walker && walker.tagName !== "w:p") {
+        walker = walker.parentNode;
+      }
+      current_p = walker;
+    }
+    while (lines.length > 1 && lines[lines.length - 1] === "") {
+      lines.pop();
+    }
+    if (lines.length === 0) {
+      return {
+        first_node: null,
+        last_p: null,
+        last_ins: null,
+        used_block_mode: false
+      };
+    }
+    const [first_clean, first_style] = this._parse_markdown_style(lines[0]);
+    const have_paragraph_context = current_p !== null;
+    const block_mode = first_style !== null && have_paragraph_context;
+    let first_node = null;
+    let inline_ins = null;
+    if (!block_mode) {
+      inline_ins = this._build_tracked_ins_for_line(
+        first_clean === lines[0] ? lines[0] : lines[0],
+        anchor_run,
+        reuse_id,
+        xmlDoc
+      );
+      first_node = inline_ins;
+    }
+    const remaining_lines = block_mode ? lines : lines.slice(1);
+    if (remaining_lines.length === 0) {
+      return {
+        first_node,
+        last_p: null,
+        last_ins: inline_ins,
+        used_block_mode: false
+      };
+    }
+    if (!current_p) {
+      return {
+        first_node,
+        last_p: null,
+        last_ins: inline_ins,
+        used_block_mode: false
+      };
+    }
+    const parent_body = current_p.parentNode;
+    if (!parent_body) {
+      return {
+        first_node,
+        last_p: null,
+        last_ins: inline_ins,
+        used_block_mode: false
+      };
+    }
+    const insertAfterEl = (newNode, ref) => {
+      parent_body.insertBefore(newNode, ref.nextSibling);
+    };
+    let last_p = null;
+    let last_ins = null;
+    let after = current_p;
+    for (let i = 0; i < remaining_lines.length; i++) {
+      const raw_line = remaining_lines[i];
+      const [clean_text, style_name] = this._parse_markdown_style(raw_line);
+      const new_p = xmlDoc.createElement("w:p");
+      if (style_name) {
+        this._set_paragraph_style(new_p, style_name);
+      } else {
+        const existing_pPr = findChild(current_p, "w:pPr");
+        if (existing_pPr) {
+          new_p.appendChild(existing_pPr.cloneNode(true));
+        }
+      }
+      let pPr = findChild(new_p, "w:pPr");
+      if (!pPr) {
+        pPr = xmlDoc.createElement("w:pPr");
+        new_p.insertBefore(pPr, new_p.firstChild);
+      }
+      let rPr = findChild(pPr, "w:rPr");
+      if (!rPr) {
+        rPr = xmlDoc.createElement("w:rPr");
+        pPr.appendChild(rPr);
+      }
+      const ins_mark = this._create_track_change_tag("w:ins", "", reuse_id);
+      rPr.appendChild(ins_mark);
+      const content_ins = this._build_tracked_ins_for_line(
+        clean_text,
+        anchor_run,
+        reuse_id,
+        xmlDoc
+      );
+      if (content_ins) {
+        new_p.appendChild(content_ins);
+      }
+      insertAfterEl(new_p, after);
+      after = new_p;
+      last_p = new_p;
+      last_ins = content_ins;
+      if (!first_node) {
+        first_node = new_p;
+      }
+    }
+    return { first_node, last_p, last_ins, used_block_mode: block_mode };
+  }
+  /**
+   * Builds a single tracked-insert wrapper (<w:ins>) containing one or more
+   * <w:r> elements representing the inline markdown segments of `line_text`.
+   * Returns null if line_text is empty.
+   */
+  _build_tracked_ins_for_line(line_text, anchor_run, reuse_id, xmlDoc) {
+    if (!line_text && line_text !== "") return null;
+    const ins = this._create_track_change_tag("w:ins", "", reuse_id);
+    const segments = this._parse_inline_markdown(line_text);
+    if (segments.length === 0) {
+      return null;
+    }
+    for (const [segText, segProps] of segments) {
+      const r = xmlDoc.createElement("w:r");
+      if (anchor_run && anchor_run._element) {
+        const anchor_rPr = findChild(anchor_run._element, "w:rPr");
+        if (anchor_rPr) {
+          const clone = anchor_rPr.cloneNode(true);
+          for (const tag of ["w:vanish", "w:strike", "w:dstrike"]) {
+            const found = findChild(clone, tag);
+            if (found) clone.removeChild(found);
+          }
+          r.appendChild(clone);
+        }
+      }
+      this._apply_run_props(r, segProps, false);
+      const t = xmlDoc.createElement("w:t");
+      this._set_text_content(t, segText);
+      r.appendChild(t);
+      ins.appendChild(r);
     }
+    return ins;
   }
   _parse_markdown_style(text) {
     const stripped_text = text.trimStart();
@@ -2273,6 +3118,172 @@ var RedlineEngine = class {
       }
     }
   }
+  /**
+   * Replaces (or creates) a paragraph's <w:pPr> with a single <w:pStyle> entry
+   * pointing at `style_name`. Strips any existing pPr to avoid layering a new
+   * heading style on top of a previous list/heading configuration.
+   *
+   * In Python, the style id is resolved via doc.styles[style_name].style_id and
+   * falls back to stripping spaces. Node has no equivalent style cache exposed
+   * on `doc`, so we always use the simple "strip spaces" fallback: "Heading 1"
+   * becomes the style id "Heading1", "List Number" becomes "ListNumber", etc.
+   * This matches python-docx's default style-id convention for the built-in
+   * paragraph styles and is what Word writes by default.
+   */
+  _set_paragraph_style(p_element, style_name) {
+    const xmlDoc = p_element.ownerDocument;
+    const existing_pPr = findChild(p_element, "w:pPr");
+    if (existing_pPr) {
+      p_element.removeChild(existing_pPr);
+    }
+    const pPr = xmlDoc.createElement("w:pPr");
+    const pStyle = xmlDoc.createElement("w:pStyle");
+    const style_id = style_name.replace(/\s+/g, "");
+    pStyle.setAttribute("w:val", style_id);
+    pPr.appendChild(pStyle);
+    p_element.insertBefore(pPr, p_element.firstChild);
+  }
+  _anchor_reply_comment(parent_id, new_id) {
+    const docEl = this.doc.part._element.ownerDocument;
+    const starts = findAllDescendants(
+      this.doc.element,
+      "w:commentRangeStart"
+    ).filter((n) => n.getAttribute("w:id") === parent_id);
+    if (starts.length === 0) return;
+    const parent_start = starts[0];
+    const new_start = docEl.createElement("w:commentRangeStart");
+    new_start.setAttribute("w:id", new_id);
+    insertAfter(new_start, parent_start);
+    const ends = findAllDescendants(
+      this.doc.element,
+      "w:commentRangeEnd"
+    ).filter((n) => n.getAttribute("w:id") === parent_id);
+    if (ends.length === 0) return;
+    const parent_end = ends[0];
+    const parent_refs = findAllDescendants(
+      this.doc.element,
+      "w:commentReference"
+    ).filter((n) => n.getAttribute("w:id") === parent_id);
+    let insertion_point = parent_end;
+    if (parent_refs.length > 0) {
+      const ref_el = parent_refs[0];
+      if (ref_el.parentNode && ref_el.parentNode.tagName === "w:r") {
+        insertion_point = ref_el.parentNode;
+      }
+    }
+    const new_end = docEl.createElement("w:commentRangeEnd");
+    new_end.setAttribute("w:id", new_id);
+    insertAfter(new_end, insertion_point);
+    const ref_run = docEl.createElement("w:r");
+    const rPr = docEl.createElement("w:rPr");
+    const rStyle = docEl.createElement("w:rStyle");
+    rStyle.setAttribute("w:val", "CommentReference");
+    rPr.appendChild(rStyle);
+    ref_run.appendChild(rPr);
+    const ref = docEl.createElement("w:commentReference");
+    ref.setAttribute("w:id", new_id);
+    ref_run.appendChild(ref);
+    insertAfter(ref_run, new_end);
+  }
+  _clean_wrapping_comments(element) {
+    let first_node = element;
+    while (true) {
+      const prev2 = getPreviousElement(first_node);
+      if (prev2 && (prev2.tagName === "w:ins" || prev2.tagName === "w:del")) {
+        first_node = prev2;
+      } else {
+        break;
+      }
+    }
+    let last_node = element;
+    while (true) {
+      const nxt2 = getNextElement(last_node);
+      if (nxt2 && (nxt2.tagName === "w:ins" || nxt2.tagName === "w:del")) {
+        last_node = nxt2;
+      } else {
+        break;
+      }
+    }
+    const starts_to_remove = [];
+    let prev = getPreviousElement(first_node);
+    while (prev) {
+      if (prev.tagName === "w:commentRangeStart") {
+        starts_to_remove.push(prev);
+        prev = getPreviousElement(prev);
+      } else if (prev.tagName === "w:rPr" || prev.tagName === "w:pPr") {
+        prev = getPreviousElement(prev);
+      } else {
+        break;
+      }
+    }
+    const ends_to_remove = [];
+    let nxt = getNextElement(last_node);
+    while (nxt) {
+      if (nxt.tagName === "w:commentRangeEnd") {
+        ends_to_remove.push(nxt);
+        nxt = getNextElement(nxt);
+      } else if (nxt.tagName === "w:r" && findAllDescendants(nxt, "w:commentReference").length > 0) {
+        ends_to_remove.push(nxt);
+        nxt = getNextElement(nxt);
+      } else if (nxt.tagName === "w:commentReference") {
+        ends_to_remove.push(nxt);
+        nxt = getNextElement(nxt);
+      } else {
+        break;
+      }
+    }
+    const end_ids = /* @__PURE__ */ new Set();
+    for (const e of ends_to_remove) {
+      if (e.tagName === "w:commentRangeEnd") {
+        const eid = e.getAttribute("w:id");
+        if (eid) end_ids.add(eid);
+      } else {
+        let ref = findAllDescendants(e, "w:commentReference")[0];
+        if (!ref && e.tagName === "w:commentReference") ref = e;
+        if (ref) {
+          const eid = ref.getAttribute("w:id");
+          if (eid) end_ids.add(eid);
+        }
+      }
+    }
+    for (const s of starts_to_remove) {
+      const c_id = s.getAttribute("w:id");
+      if (c_id && end_ids.has(c_id)) {
+        this.comments_manager.deleteComment(c_id);
+        if (s.parentNode) s.parentNode.removeChild(s);
+        for (const e of ends_to_remove) {
+          let e_id = null;
+          if (e.tagName === "w:commentRangeEnd") {
+            e_id = e.getAttribute("w:id");
+          } else {
+            let ref = findAllDescendants(e, "w:commentReference")[0];
+            if (!ref && e.tagName === "w:commentReference") ref = e;
+            if (ref) e_id = ref.getAttribute("w:id");
+          }
+          if (e_id === c_id && e.parentNode) {
+            e.parentNode.removeChild(e);
+          }
+        }
+      }
+    }
+  }
+  _delete_comments_in_element(element) {
+    const refs = findAllDescendants(element, "w:commentReference");
+    for (const ref of refs) {
+      const c_id = ref.getAttribute("w:id");
+      if (c_id) {
+        this.comments_manager.deleteComment(c_id);
+        for (const tag of ["w:commentRangeStart", "w:commentRangeEnd"]) {
+          const nodes = findAllDescendants(this.doc.element, tag);
+          for (const node of nodes) {
+            if (node.getAttribute("w:id") === c_id && node.parentNode) {
+              node.parentNode.removeChild(node);
+            }
+          }
+        }
+      }
+    }
+  }
   validate_edits(edits) {
     const errors = [];
     if (!this.mapper.full_text) this.mapper["_build_map"]();
@@ -2283,23 +3294,41 @@ var RedlineEngine = class {
       let matches = this.mapper.find_all_match_indices(edit.target_text);
       let activeText = this.mapper.full_text;
       if (matches.length === 0) {
-        if (!this.clean_mapper) this.clean_mapper = new DocumentMapper(this.doc, true);
+        if (!this.clean_mapper)
+          this.clean_mapper = new DocumentMapper(this.doc, true);
         matches = this.clean_mapper.find_all_match_indices(edit.target_text);
         if (matches.length > 0) activeText = this.clean_mapper.full_text;
       }
       if (matches.length === 0) {
-        errors.push(`- Edit ${i + 1} Failed: Target text not found in document:
-  "${edit.target_text}"`);
+        errors.push(
+          `- Edit ${i + 1} Failed: Target text not found in document:
+  "${edit.target_text}"`
+        );
       } else if (matches.length > 1) {
-        errors.push(`- Edit ${i + 1} Failed: Target text is ambiguous. Found ${matches.length} matches.
-Provide more context.`);
+        const positions = matches.map(([start, length]) => [
+          start,
+          start + length
+        ]);
+        errors.push(
+          format_ambiguity_error(
+            i + 1,
+            edit.target_text,
+            activeText,
+            positions
+          )
+        );
       }
       for (const [start, length] of matches) {
-        const spans = this.mapper.spans.filter((s) => s.end > start && s.start < start + length);
+        const spans = this.mapper.spans.filter(
+          (s) => s.end > start && s.start < start + length
+        );
         const nestedAuthors = /* @__PURE__ */ new Set();
         for (const s of spans) {
           if (s.ins_id) {
-            const insNodes = findAllDescendants(this.doc.element, "w:ins").filter((n) => n.getAttribute("w:id") === s.ins_id);
+            const insNodes = findAllDescendants(
+              this.doc.element,
+              "w:ins"
+            ).filter((n) => n.getAttribute("w:id") === s.ins_id);
             if (insNodes.length > 0) {
               const auth = insNodes[0].getAttribute("w:author");
               if (auth && auth !== this.author) nestedAuthors.add(auth);
@@ -2307,7 +3336,46 @@ Provide more context.`);
           }
         }
         if (nestedAuthors.size > 0) {
-          errors.push(`- Edit ${i + 1} Failed: Modification targets an active insertion from another author (${Array.from(nestedAuthors).join(", ")}).`);
+          errors.push(
+            `- Edit ${i + 1} Failed: Modification targets an active insertion from another author (${Array.from(nestedAuthors).join(", ")}). Accept that change first or scope your edit outside of it.`
+          );
+        }
+      }
+    }
+    return errors;
+  }
+  validate_review_actions(actions) {
+    const errors = [];
+    for (let i = 0; i < actions.length; i++) {
+      const action = actions[i];
+      const type = action.type;
+      if (type === "reply") {
+        const cid = action.target_id.replace("Com:", "");
+        let found = false;
+        const part = this.doc.pkg.parts.find(
+          (p) => p.contentType === "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml"
+        );
+        if (part) {
+          const comments = findAllDescendants(part._element, "w:comment");
+          found = comments.some((c) => c.getAttribute("w:id") === cid);
+        }
+        if (!found) {
+          errors.push(
+            `- Action ${i + 1} Failed: Target comment ID ${action.target_id} not found.`
+          );
+        }
+      } else if (type === "accept" || type === "reject") {
+        const target_id = action.target_id.replace("Chg:", "");
+        const all_ins = findAllDescendants(this.doc.element, "w:ins").filter(
+          (n) => n.getAttribute("w:id") === target_id
+        );
+        const all_del = findAllDescendants(this.doc.element, "w:del").filter(
+          (n) => n.getAttribute("w:id") === target_id
+        );
+        if (all_ins.length === 0 && all_del.length === 0) {
+          errors.push(
+            `- Action ${i + 1} Failed: Target ID ${action.target_id} not found.`
+          );
         }
       }
     }
@@ -2315,8 +3383,22 @@ Provide more context.`);
   }
   process_batch(changes) {
     this.skipped_details = [];
-    const actions = changes.filter((c) => ["accept", "reject", "reply"].includes(c.type));
-    const edits = changes.filter((c) => !["accept", "reject", "reply"].includes(c.type));
+    const actions = changes.filter(
+      (c) => ["accept", "reject", "reply"].includes(c.type)
+    );
+    const edits = changes.filter(
+      (c) => !["accept", "reject", "reply"].includes(c.type)
+    );
+    const all_errors = [];
+    if (actions.length > 0) {
+      all_errors.push(...this.validate_review_actions(actions));
+    }
+    if (edits.length > 0) {
+      all_errors.push(...this.validate_edits(edits));
+    }
+    if (all_errors.length > 0) {
+      throw new BatchValidationError(all_errors);
+    }
     let applied_actions = 0, skipped_actions = 0;
     if (actions.length > 0) {
       const res = this.apply_review_actions(actions);
@@ -2327,10 +3409,6 @@ Provide more context.`);
         if (this.clean_mapper) this.clean_mapper["_build_map"]();
       }
     }
-    if (edits.length > 0) {
-      const errors = this.validate_edits(edits);
-      if (errors.length > 0) throw new BatchValidationError(errors);
-    }
     let applied_edits = 0, skipped_edits = 0;
     if (edits.length > 0) {
       const res = this.apply_edits(edits);
@@ -2359,7 +3437,9 @@ Provide more context.`);
           resolved_edits.push([edit, null]);
         } else {
           skipped++;
-          this.skipped_details.push(`- Failed to locate row target: '${(edit.target_text || "").substring(0, 40)}...'`);
+          this.skipped_details.push(
+            `- Failed to locate row target: '${(edit.target_text || "").substring(0, 40)}...'`
+          );
         }
       } else {
         const resolved = this._pre_resolve_heuristic_edit(edit);
@@ -2371,19 +3451,27 @@ Provide more context.`);
           }
         } else {
           skipped++;
-          this.skipped_details.push(`- Failed to apply edit targeting: '${(edit.target_text || "insertion").substring(0, 40)}...'`);
+          this.skipped_details.push(
+            `- Failed to apply edit targeting: '${(edit.target_text || "insertion").substring(0, 40)}...'`
+          );
         }
       }
     }
-    resolved_edits.sort((a, b) => (b[0]._match_start_index || 0) - (a[0]._match_start_index || 0));
+    resolved_edits.sort(
+      (a, b) => (b[0]._match_start_index || 0) - (a[0]._match_start_index || 0)
+    );
     const occupied_ranges = [];
     for (const [edit, orig_new] of resolved_edits) {
       const start = edit._match_start_index || 0;
       const end = start + (edit.target_text ? edit.target_text.length : 0);
-      const overlaps = occupied_ranges.some(([occ_start, occ_end]) => start < occ_end && end > occ_start);
+      const overlaps = occupied_ranges.some(
+        ([occ_start, occ_end]) => start < occ_end && end > occ_start
+      );
       if (overlaps) {
         skipped++;
-        this.skipped_details.push(`- Skipped overlapping edit targeting: '${(edit.target_text || "insertion").substring(0, 40)}...'`);
+        this.skipped_details.push(
+          `- Skipped overlapping edit targeting: '${(edit.target_text || "insertion").substring(0, 40)}...'`
+        );
         continue;
       }
       let success = false;
@@ -2397,7 +3485,9 @@ Provide more context.`);
         occupied_ranges.push([start, end]);
       } else {
         skipped++;
-        this.skipped_details.push(`- Failed to apply edit targeting: '${(edit.target_text || "insertion").substring(0, 40)}...'`);
+        this.skipped_details.push(
+          `- Failed to apply edit targeting: '${(edit.target_text || "insertion").substring(0, 40)}...'`
+        );
       }
     }
     return [applied, skipped];
@@ -2409,17 +3499,28 @@ Provide more context.`);
       const type = action.type;
       if (type === "reply") {
         const cid = action.target_id.replace("Com:", "");
-        this.comments_manager.addComment(this.author, action.text, cid);
+        const new_id = this.comments_manager.addComment(
+          this.author,
+          action.text,
+          cid
+        );
+        this._anchor_reply_comment(cid, new_id);
         applied++;
         continue;
       }
       const target_id = action.target_id.replace("Chg:", "");
-      const all_ins = findAllDescendants(this.doc.element, "w:ins").filter((n) => n.getAttribute("w:id") === target_id);
-      const all_del = findAllDescendants(this.doc.element, "w:del").filter((n) => n.getAttribute("w:id") === target_id);
+      const all_ins = findAllDescendants(this.doc.element, "w:ins").filter(
+        (n) => n.getAttribute("w:id") === target_id
+      );
+      const all_del = findAllDescendants(this.doc.element, "w:del").filter(
+        (n) => n.getAttribute("w:id") === target_id
+      );
       const all_nodes = [...all_ins, ...all_del];
       if (all_nodes.length === 0) {
         skipped++;
-        this.skipped_details.push(`- Failed to apply action: Target ID ${action.target_id} not found.`);
+        this.skipped_details.push(
+          `- Failed to apply action: Target ID ${action.target_id} not found.`
+        );
         continue;
       }
       for (const node of all_nodes) {
@@ -2428,12 +3529,16 @@ Provide more context.`);
         const is_trPr = parent_tag === "w:trPr";
         if (type === "accept") {
           if (is_ins) {
+            this._clean_wrapping_comments(node);
             if (is_trPr) node.parentNode?.removeChild(node);
             else {
-              while (node.firstChild) node.parentNode?.insertBefore(node.firstChild, node);
+              while (node.firstChild)
+                node.parentNode?.insertBefore(node.firstChild, node);
               node.parentNode?.removeChild(node);
             }
           } else {
+            this._clean_wrapping_comments(node);
+            this._delete_comments_in_element(node);
             if (is_trPr) {
               const tr = node.parentNode?.parentNode;
               tr?.parentNode?.removeChild(tr);
@@ -2443,21 +3548,28 @@ Provide more context.`);
           }
         } else if (type === "reject") {
           if (is_ins) {
+            this._clean_wrapping_comments(node);
+            this._delete_comments_in_element(node);
             if (is_trPr) {
               const tr = node.parentNode?.parentNode;
               tr?.parentNode?.removeChild(tr);
             } else node.parentNode?.removeChild(node);
           } else {
+            this._clean_wrapping_comments(node);
             if (is_trPr) node.parentNode?.removeChild(node);
             else {
-              const delTexts = Array.from(node.getElementsByTagName("w:delText"));
+              const delTexts = Array.from(
+                node.getElementsByTagName("w:delText")
+              );
               for (const dt of delTexts) {
                 const t = dt.ownerDocument.createElement("w:t");
                 t.textContent = dt.textContent;
-                if (dt.hasAttribute("xml:space")) t.setAttribute("xml:space", "preserve");
+                if (dt.hasAttribute("xml:space"))
+                  t.setAttribute("xml:space", "preserve");
                 dt.parentNode?.replaceChild(t, dt);
               }
-              while (node.firstChild) node.parentNode?.insertBefore(node.firstChild, node);
+              while (node.firstChild)
+                node.parentNode?.insertBefore(node.firstChild, node);
               node.parentNode?.removeChild(node);
             }
           }
@@ -2469,7 +3581,10 @@ Provide more context.`);
   }
   _apply_table_edit(edit, rebuild_map) {
     const start_idx = edit._match_start_index || 0;
-    const [anchor_run, anchor_para] = this.mapper.get_insertion_anchor(start_idx, rebuild_map);
+    const [anchor_run, anchor_para] = this.mapper.get_insertion_anchor(
+      start_idx,
+      rebuild_map
+    );
     let target_element = null;
     if (anchor_run) target_element = anchor_run._element;
     else if (anchor_para) target_element = anchor_para._element;
@@ -2496,7 +3611,8 @@ Provide more context.`);
         const r = tr.ownerDocument.createElement("w:r");
         const t = tr.ownerDocument.createElement("w:t");
         t.textContent = cellText;
-        if (cellText.trim() !== cellText) t.setAttribute("xml:space", "preserve");
+        if (cellText.trim() !== cellText)
+          t.setAttribute("xml:space", "preserve");
         r.appendChild(t);
         p.appendChild(r);
         tc.appendChild(p);
@@ -2513,14 +3629,20 @@ Provide more context.`);
     let [start_idx, match_len] = this.mapper.find_match_index(edit.target_text);
     let use_clean_map = false;
     if (start_idx === -1) {
-      if (!this.clean_mapper) this.clean_mapper = new DocumentMapper(this.doc, true);
-      [start_idx, match_len] = this.clean_mapper.find_match_index(edit.target_text);
+      if (!this.clean_mapper)
+        this.clean_mapper = new DocumentMapper(this.doc, true);
+      [start_idx, match_len] = this.clean_mapper.find_match_index(
+        edit.target_text
+      );
       if (start_idx !== -1) use_clean_map = true;
       else return null;
     }
     const active_mapper = use_clean_map ? this.clean_mapper : this.mapper;
     const effective_new_text = edit.new_text || "";
-    const actual_doc_text = this.mapper.full_text.substring(start_idx, start_idx + match_len);
+    const actual_doc_text = this.mapper.full_text.substring(
+      start_idx,
+      start_idx + match_len
+    );
     if (actual_doc_text === effective_new_text || edit.target_text === effective_new_text) {
       return {
         type: "modify",
@@ -2541,330 +3663,337 @@ Provide more context.`);
       final_new = effective_new_text.substring(actual_doc_text.length);
       effective_start_idx = start_idx + match_len;
     } else {
-      const [prefix_len, suffix_len] = trim_common_context(actual_doc_text, effective_new_text);
+      const [prefix_len, suffix_len] = trim_common_context(
+        actual_doc_text,
+        effective_new_text
+      );
       const t_end = actual_doc_text.length - suffix_len;
       const n_end = effective_new_text.length - suffix_len;
       final_target = actual_doc_text.substring(prefix_len, t_end);
       final_new = effective_new_text.substring(prefix_len, n_end);
       effective_start_idx = start_idx + prefix_len;
-      if (!final_target && final_new) effective_op = "INSERTION";
-      else if (final_target && !final_new) effective_op = "DELETION";
-      else if (final_target && final_new) effective_op = "MODIFICATION";
-      else effective_op = "COMMENT_ONLY";
-    }
-    return {
-      type: "modify",
-      target_text: final_target,
-      new_text: final_new,
-      comment: edit.comment,
-      _match_start_index: effective_start_idx,
-      _internal_op: effective_op,
-      _active_mapper_ref: active_mapper
-    };
-  }
-  _apply_single_edit_indexed(edit, orig_new, rebuild_map) {
-    let op = edit._internal_op;
-    const active_mapper = edit._active_mapper_ref || this.mapper;
-    const start_idx = edit._match_start_index || 0;
-    const length = edit.target_text ? edit.target_text.length : 0;
-    const del_id = ["DELETION", "MODIFICATION"].includes(op) ? this._getNextId() : null;
-    const ins_id = ["INSERTION", "MODIFICATION"].includes(op) ? this._getNextId() : null;
-    if (op === "COMMENT_ONLY") {
-      return true;
-    }
-    if (op === "INSERTION") {
-      const [anchor_run, anchor_para] = active_mapper.get_insertion_anchor(start_idx, rebuild_map);
-      if (!anchor_run && !anchor_para) return false;
-      const xmlDoc = this.doc.part._element.ownerDocument;
-      const ins = this._create_track_change_tag("w:ins", "", ins_id);
-      const segments = this._parse_inline_markdown(edit.new_text || "");
-      for (const [segText, segProps] of segments) {
-        const r = xmlDoc.createElement("w:r");
-        this._apply_run_props(r, segProps, false);
-        const t = xmlDoc.createElement("w:t");
-        this._set_text_content(t, segText);
-        r.appendChild(t);
-        ins.appendChild(r);
-      }
-      if (anchor_run) {
-        insertAfter(ins, anchor_run._element);
-      } else if (anchor_para) {
-        anchor_para._element.appendChild(ins);
-      }
-      return true;
-    }
-    const target_runs = active_mapper.find_target_runs_by_index(start_idx, length, rebuild_map);
-    if (target_runs.length === 0) return false;
-    let last_del = null;
-    for (const run of target_runs) {
-      const del_tag = this._create_track_change_tag("w:del", "", del_id);
-      const new_run = run._element.cloneNode(true);
-      const tNodes = Array.from(new_run.getElementsByTagName("w:t"));
-      tNodes.forEach((t) => {
-        const delText = new_run.ownerDocument.createElement("w:delText");
-        delText.textContent = t.textContent;
-        if (t.hasAttribute("xml:space")) delText.setAttribute("xml:space", "preserve");
-        new_run.replaceChild(delText, t);
-      });
-      del_tag.appendChild(new_run);
-      run._element.parentNode?.replaceChild(del_tag, run._element);
-      last_del = del_tag;
-    }
-    if (op === "MODIFICATION" && edit.new_text && last_del) {
-      const xmlDoc = this.doc.part._element.ownerDocument;
-      const ins = this._create_track_change_tag("w:ins", "", ins_id);
-      const segments = this._parse_inline_markdown(edit.new_text);
-      for (const [segText, segProps] of segments) {
-        const r = xmlDoc.createElement("w:r");
-        this._apply_run_props(r, segProps, false);
-        const t = xmlDoc.createElement("w:t");
-        this._set_text_content(t, segText);
-        r.appendChild(t);
-        ins.appendChild(r);
-      }
-      insertAfter(ins, last_del);
-    }
-    return true;
-  }
-};
-
-// src/markup.ts
-function _should_strip_markers(text, marker) {
-  if (!text.startsWith(marker) || !text.endsWith(marker)) return false;
-  if (text.length < marker.length * 2) return false;
-  const inner = text.substring(marker.length, text.length - marker.length);
-  if (!inner) return false;
-  if (inner.includes(marker)) return false;
-  if (!/[a-zA-Z]/.test(inner)) return false;
-  if (marker === "__" && /^\w+$/.test(inner)) return false;
-  if (marker === "_") {
-    if (inner.includes("_")) return false;
-    if (/^[0-9_]+$/.test(inner)) return false;
-  }
-  return true;
-}
-function _strip_balanced_markers(text) {
-  let prefix_markup = "";
-  let suffix_markup = "";
-  let clean_text = text;
-  const markers = ["**", "__", "_", "*"];
-  for (const marker of markers) {
-    if (_should_strip_markers(clean_text, marker)) {
-      prefix_markup += marker;
-      suffix_markup = marker + suffix_markup;
-      clean_text = clean_text.substring(marker.length, clean_text.length - marker.length);
-      break;
-    }
-  }
-  return [prefix_markup, clean_text, suffix_markup];
-}
-function _replace_smart_quotes(text) {
-  return text.replace(/“/g, '"').replace(/”/g, '"').replace(/‘/g, "'").replace(/’/g, "'");
-}
-function _find_safe_boundaries(text, start, end) {
-  let new_start = start;
-  let new_end = end;
-  const expand_if_unbalanced = (marker) => {
-    const current_match = text.substring(new_start, new_end);
-    const count = (current_match.match(new RegExp(marker.replace(/\*/g, "\\*"), "g")) || []).length;
-    if (count % 2 !== 0) {
-      const suffix = text.substring(new_end);
-      if (suffix.startsWith(marker)) {
-        new_end += marker.length;
-        return;
-      }
-      const prefix = text.substring(0, new_start);
-      if (prefix.endsWith(marker)) {
-        new_start -= marker.length;
-        return;
-      }
-    }
-  };
-  for (let i = 0; i < 2; i++) {
-    expand_if_unbalanced("**");
-    expand_if_unbalanced("__");
-    expand_if_unbalanced("_");
-    expand_if_unbalanced("*");
-  }
-  return [new_start, new_end];
-}
-function _refine_match_boundaries(text, start, end) {
-  const markers = ["**", "__", "*", "_"];
-  let current_text = text.substring(start, end);
-  let best_start = start;
-  let best_end = end;
-  const countMarker = (str, mk) => (str.match(new RegExp(mk.replace(/\*/g, "\\*"), "g")) || []).length;
-  for (const marker of markers) {
-    if (current_text.startsWith(marker)) {
-      const current_score = countMarker(current_text, marker) % 2;
-      const trimmed_text = current_text.substring(marker.length);
-      const trimmed_score = countMarker(trimmed_text, marker) % 2;
-      if (current_score === 1 && trimmed_score === 0) {
-        best_start += marker.length;
-        current_text = trimmed_text;
-      }
-    }
-  }
-  for (const marker of markers) {
-    if (current_text.endsWith(marker)) {
-      const current_score = countMarker(current_text, marker) % 2;
-      const trimmed_text = current_text.substring(0, current_text.length - marker.length);
-      const trimmed_score = countMarker(trimmed_text, marker) % 2;
-      if (current_score === 1 && trimmed_score === 0) {
-        best_end -= marker.length;
-        current_text = trimmed_text;
-      }
-    }
-  }
-  return [best_start, best_end];
-}
-function _make_fuzzy_regex(target_text) {
-  target_text = _replace_smart_quotes(target_text);
-  const parts = [];
-  const token_pattern = /(_+)|(\s+)|(['"])|([.,;:\/])/g;
-  const md_noise = "[*_]*";
-  const structural_noise = "(?:\\s*(?:[*+\\->]|\\d+\\.)\\s+|\\s*\\n\\s*)";
-  const start_list_marker = "(?:[ \\t]*(?:[*+\\->]|\\d+\\.)\\s+)?";
-  parts.push(start_list_marker);
-  parts.push(md_noise);
-  let last_idx = 0;
-  let match;
-  const escapeRegExp = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  while ((match = token_pattern.exec(target_text)) !== null) {
-    const literal = target_text.substring(last_idx, match.index);
-    if (literal) {
-      parts.push(escapeRegExp(literal));
-      parts.push(md_noise);
+      if (!final_target && final_new) effective_op = "INSERTION";
+      else if (final_target && !final_new) effective_op = "DELETION";
+      else if (final_target && final_new) effective_op = "MODIFICATION";
+      else effective_op = "COMMENT_ONLY";
     }
-    const g_underscore = match[1];
-    const g_space = match[2];
-    const g_quote = match[3];
-    const g_punct = match[4];
-    if (g_underscore) {
-      parts.push("_+");
-    } else if (g_space) {
-      if (g_space.includes("\n")) {
-        parts.push(`(?:${structural_noise}|\\s+)+`);
+    return {
+      type: "modify",
+      target_text: final_target,
+      new_text: final_new,
+      comment: edit.comment,
+      _match_start_index: effective_start_idx,
+      _internal_op: effective_op,
+      _active_mapper_ref: active_mapper
+    };
+  }
+  _apply_single_edit_indexed(edit, orig_new, rebuild_map) {
+    let op = edit._internal_op;
+    const active_mapper = edit._active_mapper_ref || this.mapper;
+    const start_idx = edit._match_start_index || 0;
+    const length = edit.target_text ? edit.target_text.length : 0;
+    const del_id = ["DELETION", "MODIFICATION"].includes(op) ? this._getNextId() : null;
+    const ins_id = ["INSERTION", "MODIFICATION"].includes(op) ? this._getNextId() : null;
+    if (op === "COMMENT_ONLY") {
+      const target_runs2 = active_mapper.find_target_runs_by_index(
+        start_idx,
+        length,
+        rebuild_map
+      );
+      if (target_runs2.length === 0) return false;
+      if (!edit.comment) return true;
+      const first_el = target_runs2[0]._element;
+      const last_el = target_runs2[target_runs2.length - 1]._element;
+      let start_p = first_el;
+      while (start_p && start_p.tagName !== "w:p")
+        start_p = start_p.parentNode;
+      let end_p = last_el;
+      while (end_p && end_p.tagName !== "w:p")
+        end_p = end_p.parentNode;
+      if (!start_p || !end_p) return false;
+      const ascend_to_paragraph_child = (el, p) => {
+        let cur = el;
+        while (cur.parentNode && cur.parentNode !== p) {
+          cur = cur.parentNode;
+        }
+        return cur;
+      };
+      const first_anchor = ascend_to_paragraph_child(first_el, start_p);
+      const last_anchor = ascend_to_paragraph_child(last_el, end_p);
+      if (start_p === end_p) {
+        this._attach_comment(start_p, first_anchor, last_anchor, edit.comment);
       } else {
-        parts.push("\\s+");
+        this._attach_comment_spanning(
+          start_p,
+          first_anchor,
+          end_p,
+          last_anchor,
+          edit.comment
+        );
       }
-    } else if (g_quote) {
-      if (g_quote === "'") parts.push("[\u2018\u2019']");
-      else parts.push('["\u201C\u201D]');
-    } else if (g_punct) {
-      parts.push(escapeRegExp(g_punct));
+      return true;
     }
-    parts.push(md_noise);
-    last_idx = token_pattern.lastIndex;
-  }
-  const remaining = target_text.substring(last_idx);
-  if (remaining) parts.push(escapeRegExp(remaining));
-  return parts.join("");
-}
-function _find_match_in_text(text, target) {
-  if (!target) return [-1, -1];
-  let idx = text.indexOf(target);
-  if (idx !== -1) return _find_safe_boundaries(text, idx, idx + target.length);
-  const norm_text = _replace_smart_quotes(text);
-  const norm_target = _replace_smart_quotes(target);
-  idx = norm_text.indexOf(norm_target);
-  if (idx !== -1) return _find_safe_boundaries(text, idx, idx + norm_target.length);
-  try {
-    const pattern = new RegExp(_make_fuzzy_regex(target));
-    const match = pattern.exec(text);
-    if (match) {
-      const raw_start = match.index;
-      const raw_end = match.index + match[0].length;
-      const [refined_start, refined_end] = _refine_match_boundaries(text, raw_start, raw_end);
-      return _find_safe_boundaries(text, refined_start, refined_end);
+    if (op === "INSERTION") {
+      const [anchor_run, anchor_para] = active_mapper.get_insertion_anchor(
+        start_idx,
+        rebuild_map
+      );
+      if (!anchor_run && !anchor_para) return false;
+      const result = this._track_insert_multiline(
+        edit.new_text || "",
+        anchor_run,
+        anchor_para,
+        ins_id
+      );
+      if (!result.first_node) return false;
+      const is_inline_first = result.first_node.tagName === "w:ins";
+      if (is_inline_first) {
+        if (anchor_run) {
+          insertAfter(result.first_node, anchor_run._element);
+        } else if (anchor_para) {
+          anchor_para._element.appendChild(result.first_node);
+        }
+      }
+      if (edit.comment) {
+        const ascend_to_paragraph_child = (el, p) => {
+          let cur = el;
+          while (cur.parentNode && cur.parentNode !== p) {
+            cur = cur.parentNode;
+          }
+          return cur;
+        };
+        if (result.last_p && result.last_ins) {
+          let start_p = result.first_node;
+          while (start_p && start_p.tagName !== "w:p")
+            start_p = start_p.parentNode;
+          if (start_p) {
+            let first_anchor_target = result.first_node;
+            if (result.first_node.tagName === "w:p") {
+              first_anchor_target = findAllDescendants(result.first_node, "w:ins")[0] || result.first_node;
+            }
+            const start_anchor = ascend_to_paragraph_child(
+              first_anchor_target,
+              start_p
+            );
+            const end_anchor = ascend_to_paragraph_child(
+              result.last_ins,
+              result.last_p
+            );
+            this._attach_comment_spanning(
+              start_p,
+              start_anchor,
+              result.last_p,
+              end_anchor,
+              edit.comment
+            );
+          }
+        } else {
+          let host_p = result.first_node;
+          while (host_p && host_p.tagName !== "w:p")
+            host_p = host_p.parentNode;
+          if (host_p) {
+            let first_anchor_target = result.first_node;
+            if (result.first_node.tagName === "w:p") {
+              first_anchor_target = findAllDescendants(result.first_node, "w:ins")[0] || result.first_node;
+            }
+            const anchor = ascend_to_paragraph_child(first_anchor_target, host_p);
+            this._attach_comment(host_p, anchor, anchor, edit.comment);
+          }
+        }
+      }
+      return true;
     }
-  } catch (e) {
-  }
-  return [-1, -1];
-}
-function _build_critic_markup(target_text, new_text, comment, edit_index, include_index, highlight_only) {
-  const parts = [];
-  let [prefix_markup, clean_target, suffix_markup] = _strip_balanced_markers(target_text);
-  let clean_new = new_text;
-  if (prefix_markup && new_text) {
-    if (new_text.startsWith(prefix_markup) && new_text.endsWith(suffix_markup)) {
-      const inner_len = prefix_markup.length;
-      clean_new = new_text.length > inner_len * 2 ? new_text.substring(inner_len, new_text.length - inner_len) : new_text;
+    const target_runs = active_mapper.find_target_runs_by_index(
+      start_idx,
+      length,
+      rebuild_map
+    );
+    const virtual_spans = active_mapper.get_virtual_spans_in_range(start_idx, length);
+    if (target_runs.length === 0 && virtual_spans.length === 0) return false;
+    const affected_ps = /* @__PURE__ */ new Set();
+    for (const run of target_runs) {
+      let p = run._element.parentNode;
+      while (p && p.tagName !== "w:p") p = p.parentNode;
+      if (p) affected_ps.add(p);
     }
-  }
-  parts.push(prefix_markup);
-  if (highlight_only) {
-    parts.push(`{==${clean_target}==}`);
-  } else {
-    const has_target = Boolean(clean_target);
-    const has_new = Boolean(clean_new);
-    if (has_target && !has_new) parts.push(`{--${clean_target}--}`);
-    else if (!has_target && has_new) parts.push(`{++${clean_new}++}`);
-    else if (has_target && has_new) parts.push(`{--${clean_target}--}{++${clean_new}++}`);
-  }
-  parts.push(suffix_markup);
-  const meta_parts = [];
-  if (comment) meta_parts.push(comment);
-  if (include_index) meta_parts.push(`[Edit:${edit_index}]`);
-  if (meta_parts.length > 0) {
-    parts.push(`{>>${meta_parts.join(" ")}<<}`);
-  }
-  return parts.join("");
-}
-function apply_edits_to_markdown(markdown_text, edits, include_index = false, highlight_only = false) {
-  if (!edits || edits.length === 0) return markdown_text;
-  const matched_edits = [];
-  for (let idx = 0; idx < edits.length; idx++) {
-    const edit = edits[idx];
-    const target = edit.target_text || "";
-    if (!target) {
-      continue;
+    let first_del = null;
+    let last_del = null;
+    for (const run of target_runs) {
+      const del_tag = this._create_track_change_tag("w:del", "", del_id);
+      const new_run = run._element.cloneNode(true);
+      const tNodes = Array.from(new_run.getElementsByTagName("w:t"));
+      tNodes.forEach((t) => {
+        const delText = new_run.ownerDocument.createElement("w:delText");
+        delText.textContent = t.textContent;
+        if (t.hasAttribute("xml:space"))
+          delText.setAttribute("xml:space", "preserve");
+        new_run.replaceChild(delText, t);
+      });
+      del_tag.appendChild(new_run);
+      run._element.parentNode?.replaceChild(del_tag, run._element);
+      if (first_del === null) first_del = del_tag;
+      last_del = del_tag;
     }
-    const [start, end] = _find_match_in_text(markdown_text, target);
-    if (start === -1) continue;
-    const actual_matched_text = markdown_text.substring(start, end);
-    matched_edits.push([start, end, actual_matched_text, edit, idx]);
-  }
-  const matched_edits_filtered = [];
-  const occupied_ranges = [];
-  matched_edits.sort((a, b) => a[4] - b[4]);
-  for (const [start, end, actual_text, edit, orig_idx] of matched_edits) {
-    let overlaps = false;
-    for (const [occ_start, occ_end] of occupied_ranges) {
-      if (start < occ_end && end > occ_start) {
-        overlaps = true;
-        break;
+    let ins_elem = null;
+    let mod_last_p = null;
+    let mod_last_ins = null;
+    if (op === "MODIFICATION" && edit.new_text && last_del) {
+      let mod_anchor_para_el = last_del;
+      while (mod_anchor_para_el && mod_anchor_para_el.tagName !== "w:p") {
+        mod_anchor_para_el = mod_anchor_para_el.parentNode;
+      }
+      const mod_anchor_para = mod_anchor_para_el ? new Paragraph(mod_anchor_para_el, null) : null;
+      const style_source_run = target_runs.length > 0 ? target_runs[target_runs.length - 1] : null;
+      const result = this._track_insert_multiline(
+        edit.new_text,
+        style_source_run,
+        mod_anchor_para,
+        ins_id
+      );
+      if (result.first_node) {
+        const is_inline_first = result.first_node.tagName === "w:ins";
+        if (is_inline_first) {
+          insertAfter(result.first_node, last_del);
+          ins_elem = result.first_node;
+        } else {
+          ins_elem = result.last_ins;
+        }
+        mod_last_p = result.last_p;
+        mod_last_ins = result.last_ins;
+      }
+    }
+    if (op === "DELETION" || op === "MODIFICATION") {
+      if (op === "MODIFICATION" && target_runs.length === 0 && virtual_spans.length > 0 && edit.new_text) {
+        const first_span = virtual_spans[0];
+        if (first_span.paragraph) {
+          const p1_el = first_span.paragraph._element;
+          const last_runs = findAllDescendants(p1_el, "w:r");
+          const anchor = last_runs.length > 0 ? new Run(last_runs[last_runs.length - 1], first_span.paragraph) : null;
+          const result = this._track_insert_multiline(
+            edit.new_text,
+            anchor,
+            first_span.paragraph,
+            ins_id
+          );
+          if (result.first_node) {
+            p1_el.appendChild(result.first_node);
+          }
+        }
+      }
+      for (const span of [...virtual_spans].reverse()) {
+        if (span.paragraph) {
+          const p1_element = span.paragraph._element;
+          let p2_element = getNextElement(p1_element);
+          while (p2_element && p2_element.tagName !== "w:p") {
+            p2_element = getNextElement(p2_element);
+          }
+          if (p2_element && p2_element.tagName === "w:p") {
+            let pPr = findChild(p1_element, "w:pPr");
+            if (!pPr) {
+              pPr = p1_element.ownerDocument.createElement("w:pPr");
+              p1_element.insertBefore(pPr, p1_element.firstChild);
+            }
+            let rPr = findChild(pPr, "w:rPr");
+            if (!rPr) {
+              rPr = p1_element.ownerDocument.createElement("w:rPr");
+              pPr.appendChild(rPr);
+            }
+            const del_mark = this._create_track_change_tag("w:del");
+            rPr.appendChild(del_mark);
+            const children = Array.from(p2_element.childNodes);
+            for (const child of children) {
+              if (child.nodeType === 1 && child.tagName === "w:pPr") {
+                continue;
+              }
+              p1_element.appendChild(child);
+            }
+            if (p2_element.parentNode) {
+              p2_element.parentNode.removeChild(p2_element);
+            }
+          }
+        }
       }
     }
-    if (!overlaps) {
-      matched_edits_filtered.push([start, end, actual_text, edit, orig_idx]);
-      occupied_ranges.push([start, end]);
+    if (edit.comment && first_del !== null) {
+      let end_anchor_el;
+      let end_p;
+      if (mod_last_p && mod_last_ins) {
+        end_anchor_el = mod_last_ins;
+        end_p = mod_last_p;
+      } else {
+        const final_anchor = ins_elem !== null ? ins_elem : last_del;
+        end_anchor_el = final_anchor;
+        end_p = final_anchor;
+        while (end_p && end_p.tagName !== "w:p")
+          end_p = end_p.parentNode;
+      }
+      let start_p = first_del;
+      while (start_p && start_p.tagName !== "w:p")
+        start_p = start_p.parentNode;
+      if (!start_p || !end_p) return true;
+      const ascend_to_paragraph_child = (el, p) => {
+        let cur = el;
+        while (cur.parentNode && cur.parentNode !== p) {
+          cur = cur.parentNode;
+        }
+        return cur;
+      };
+      const start_anchor = ascend_to_paragraph_child(first_del, start_p);
+      const end_anchor = ascend_to_paragraph_child(end_anchor_el, end_p);
+      if (start_p === end_p) {
+        this._attach_comment(start_p, start_anchor, end_anchor, edit.comment);
+      } else {
+        this._attach_comment_spanning(
+          start_p,
+          start_anchor,
+          end_p,
+          end_anchor,
+          edit.comment
+        );
+      }
+    }
+    for (const p_elem of affected_ps) {
+      let has_visible = false;
+      for (const tag of ["w:t", "w:tab", "w:br"]) {
+        const nodes = findAllDescendants(p_elem, tag);
+        for (const node of nodes) {
+          let is_deleted = false;
+          let curr = node.parentNode;
+          while (curr && curr !== p_elem.parentNode) {
+            if (curr.tagName === "w:del") {
+              is_deleted = true;
+              break;
+            }
+            curr = curr.parentNode;
+          }
+          if (!is_deleted) {
+            if (tag === "w:t" && !node.textContent) continue;
+            has_visible = true;
+            break;
+          }
+        }
+        if (has_visible) break;
+      }
+      if (!has_visible) {
+        let pPr = findChild(p_elem, "w:pPr");
+        if (!pPr) {
+          pPr = p_elem.ownerDocument.createElement("w:pPr");
+          p_elem.insertBefore(pPr, p_elem.firstChild);
+        }
+        let rPr = findChild(pPr, "w:rPr");
+        if (!rPr) {
+          rPr = p_elem.ownerDocument.createElement("w:rPr");
+          pPr.appendChild(rPr);
+        }
+        if (!findChild(rPr, "w:del")) {
+          const del_mark = this._create_track_change_tag("w:del");
+          rPr.appendChild(del_mark);
+        }
+      }
     }
+    return true;
   }
-  matched_edits_filtered.sort((a, b) => b[0] - a[0]);
-  let result = markdown_text;
-  for (const [start, end, actual_text, edit, orig_idx] of matched_edits_filtered) {
-    const new_txt = edit.new_text || "";
-    const [prefix_len, suffix_len] = trim_common_context(actual_text, new_txt);
-    const unmodified_prefix = prefix_len > 0 ? actual_text.substring(0, prefix_len) : "";
-    const unmodified_suffix = suffix_len > 0 ? actual_text.substring(actual_text.length - suffix_len) : "";
-    const t_end = actual_text.length - suffix_len;
-    const n_end = new_txt.length - suffix_len;
-    const isolated_target = actual_text.substring(prefix_len, t_end);
-    const isolated_new = new_txt.substring(prefix_len, n_end);
-    const markup = _build_critic_markup(
-      isolated_target,
-      isolated_new,
-      edit.comment,
-      orig_idx,
-      include_index,
-      highlight_only
-    );
-    const full_replacement = unmodified_prefix + markup + unmodified_suffix;
-    result = result.substring(0, start) + full_replacement + result.substring(end);
-  }
-  return result;
-}
+};
 
 // src/pagination.ts
 var PAGE_TARGET_CHARS = 19e3;
@@ -3657,7 +4786,12 @@ function extract_outline(doc, projected_body, body_pages, body_page_offsets, par
     const level = _heading_level(paragraph);
     const text = _heading_text(paragraph, comments_map);
     const style = _determine_heading_style(paragraph);
-    const owned_end = _find_owned_end(block_records, heading_indices, h_pos, level);
+    const owned_end = _find_owned_end(
+      block_records,
+      heading_indices,
+      h_pos,
+      level
+    );
     const owned_blocks = block_records.slice(rec_idx + 1, owned_end);
     const has_table = _direct_has_table(block_records, rec_idx + 1, owned_end);
     const footnote_ids = _collect_footnote_ids(owned_blocks);
@@ -3704,7 +4838,13 @@ function _walk_doc_body(doc, comments_map) {
       const p_text = build_paragraph_text(item, comments_map, false);
       const block_len = (prefix + p_text).length;
       if (!is_first_block) cursor += 2;
-      records.push({ item, is_paragraph: true, is_table: false, start_offset: cursor, projected_length: block_len });
+      records.push({
+        item,
+        is_paragraph: true,
+        is_table: false,
+        start_offset: cursor,
+        projected_length: block_len
+      });
       cursor += block_len;
       is_first_block = false;
     } else if (item instanceof Table) {
@@ -3712,7 +4852,13 @@ function _walk_doc_body(doc, comments_map) {
       const block_len = table_text ? table_text.length : 0;
       if (!is_first_block) cursor += 2;
       const table_start = cursor;
-      records.push({ item, is_paragraph: false, is_table: true, start_offset: table_start, projected_length: block_len });
+      records.push({
+        item,
+        is_paragraph: false,
+        is_table: true,
+        start_offset: table_start,
+        projected_length: block_len
+      });
       _record_table_inner_blocks_lite(item, table_start, records, comments_map);
       cursor += block_len;
       is_first_block = false;
@@ -3732,7 +4878,12 @@ function _compute_inner_block_offset(table, target_paragraph, table_start_offset
       if (seen_cells.has(cell)) continue;
       seen_cells.add(cell);
       if (cells_in_row > 0) cursor += 3;
-      const [new_cursor, found] = _walk_cell_for_offset(cell, target_el, cursor, comments_map);
+      const [new_cursor, found] = _walk_cell_for_offset(
+        cell,
+        target_el,
+        cursor,
+        comments_map
+      );
       if (found) return new_cursor;
       cursor = new_cursor;
       cells_in_row++;
@@ -3752,9 +4903,15 @@ function _walk_cell_for_offset(cell, target_el, cell_start_cursor, comments_map)
       const p_text = build_paragraph_text(inner_item, comments_map, false);
       cursor += (prefix + p_text).length;
     } else if (inner_item instanceof Table) {
-      const nested_offset = _compute_inner_block_offset(inner_item, new Paragraph(target_el, null), cursor, comments_map);
+      const nested_offset = _compute_inner_block_offset(
+        inner_item,
+        new Paragraph(target_el, null),
+        cursor,
+        comments_map
+      );
       if (nested_offset !== cursor) {
-        if (_element_is_descendant(target_el, inner_item._element)) return [nested_offset, true];
+        if (_element_is_descendant(target_el, inner_item._element))
+          return [nested_offset, true];
       }
       const table_text = extract_table(inner_item, comments_map, false, 0);
       cursor += table_text ? table_text.length : 0;
@@ -3779,11 +4936,33 @@ function _record_table_inner_blocks_lite(table, inherited_offset, records, comme
       seen_cells.add(cell);
       for (const inner_item of iter_block_items(cell)) {
         if (inner_item instanceof Paragraph) {
-          const true_offset = _is_heading(inner_item) ? _compute_inner_block_offset(table, inner_item, inherited_offset, comments_map) : inherited_offset;
-          records.push({ item: inner_item, is_paragraph: true, is_table: false, start_offset: true_offset, projected_length: 0 });
+          const true_offset = _is_heading(inner_item) ? _compute_inner_block_offset(
+            table,
+            inner_item,
+            inherited_offset,
+            comments_map
+          ) : inherited_offset;
+          records.push({
+            item: inner_item,
+            is_paragraph: true,
+            is_table: false,
+            start_offset: true_offset,
+            projected_length: 0
+          });
         } else if (inner_item instanceof Table) {
-          records.push({ item: inner_item, is_paragraph: false, is_table: true, start_offset: inherited_offset, projected_length: 0 });
-          _record_table_inner_blocks_lite(inner_item, inherited_offset, records, comments_map);
+          records.push({
+            item: inner_item,
+            is_paragraph: false,
+            is_table: true,
+            start_offset: inherited_offset,
+            projected_length: 0
+          });
+          _record_table_inner_blocks_lite(
+            inner_item,
+            inherited_offset,
+            records,
+            comments_map
+          );
         }
       }
     }
@@ -3804,7 +4983,8 @@ ${header}`);
       if (fn_text) blocks.push(fn_text);
     } else if (item instanceof Paragraph) {
       let prefix = get_paragraph_prefix(item);
-      if (is_first_para && c_type === "FootnoteItem") prefix = `[^${part.note_type}-${part.id}]: ${prefix}`;
+      if (is_first_para && c_type === "FootnoteItem")
+        prefix = `[^${part.note_type}-${part.id}]: ${prefix}`;
       const p_text = build_paragraph_text(item, comments_map, false);
       blocks.push(prefix + p_text);
       is_first_para = false;
@@ -3853,37 +5033,51 @@ function _strip_inline_formatting(text) {
   return text;
 }
 function _determine_heading_style(paragraph) {
-  const [style_cache, default_pstyle] = _get_style_cache(paragraph._parent.part || paragraph._parent);
+  const [style_cache, default_pstyle] = _get_style_cache(
+    paragraph._parent.part || paragraph._parent
+  );
   const pPr = findChild(paragraph._element, "w:pPr");
   let style_id = default_pstyle;
   if (pPr) {
-    const oLvl = findChild(pPr, "w:outlineLvl");
-    if (oLvl && /^\d+$/.test(oLvl.getAttribute("w:val") || "")) {
-      const style = _safe_style_name(paragraph, style_cache, default_pstyle);
-      if (style && (style.startsWith("Heading") || style === "Title")) return style;
-      return "(outline_level)";
-    }
     const pStyle = findChild(pPr, "w:pStyle");
     if (pStyle) style_id = pStyle.getAttribute("w:val") || default_pstyle;
   }
-  const style_name = style_id && style_cache && style_cache[style_id] ? style_cache[style_id].name : null;
-  if (style_name && (style_name.startsWith("Heading") || style_name === "Title")) return style_name;
-  if (style_name && /Heading[ ]?([1-6])(?![0-9])/.test(style_name)) return style_name;
-  return "(heuristic)";
-}
-function _safe_style_name(paragraph, style_cache, default_pstyle) {
-  const pPr = findChild(paragraph._element, "w:pPr");
-  let style_id = default_pstyle;
+  let outline_level = null;
   if (pPr) {
-    const pStyle = findChild(pPr, "w:pStyle");
-    if (pStyle) style_id = pStyle.getAttribute("w:val") || default_pstyle;
+    const oLvl = findChild(pPr, "w:outlineLvl");
+    if (oLvl && /^\d+$/.test(oLvl.getAttribute("w:val") || "")) {
+      outline_level = parseInt(oLvl.getAttribute("w:val"), 10);
+    }
+  }
+  if (outline_level === null && style_id && style_cache && style_cache[style_id]) {
+    outline_level = style_cache[style_id].outline_level;
+  }
+  const style_name = style_id && style_cache && style_cache[style_id] ? style_cache[style_id].name : style_id;
+  let normalized_style_name = style_name;
+  if (normalized_style_name && typeof normalized_style_name === "string") {
+    if (normalized_style_name.toLowerCase().startsWith("heading")) {
+      normalized_style_name = normalized_style_name.replace(/^heading/i, "Heading");
+    } else if (normalized_style_name.toLowerCase() === "title") {
+      normalized_style_name = "Title";
+    }
+  }
+  if (outline_level !== null && outline_level >= 0 && outline_level <= 8) {
+    if (normalized_style_name && (normalized_style_name.startsWith("Heading") || normalized_style_name === "Title")) {
+      return normalized_style_name;
+    }
+    return "(outline_level)";
   }
-  return style_id && style_cache && style_cache[style_id] ? style_cache[style_id].name : null;
+  if (normalized_style_name && (normalized_style_name.startsWith("Heading") || normalized_style_name === "Title"))
+    return normalized_style_name;
+  if (normalized_style_name && /Heading[ ]?([1-6])(?![0-9])/.test(normalized_style_name))
+    return normalized_style_name;
+  return "(heuristic)";
 }
 function _find_owned_end(block_records, heading_indices, current_h_pos, current_level) {
   for (let next_h_pos = current_h_pos + 1; next_h_pos < heading_indices.length; next_h_pos++) {
     const next_idx = heading_indices[next_h_pos];
-    if (_heading_level(block_records[next_idx].item) <= current_level) return next_idx;
+    if (_heading_level(block_records[next_idx].item) <= current_level)
+      return next_idx;
   }
   return block_records.length;
 }
@@ -4014,7 +5208,7 @@ var SanitizeReport = class {
     if (this.warnings.length > 0) {
       lines.push(`Result: CLEAN WITH WARNINGS (${this.warnings.length} warning${this.warnings.length > 1 ? "s" : ""})`);
     } else {
-      lines.push("Result: SECURE & READY TO SEND");
+      lines.push(`Result: CLEAN (${this.tracked_changes_found} changes resolved, ${this.comments_removed} comments removed)`);
     }
     lines.push(sep);
     return lines.join("\n");
@@ -4033,6 +5227,83 @@ function findDescendantsByLocalName(element, localName) {
   }
   return result;
 }
+function coalesce_runs(doc) {
+  let count = 0;
+  function areRunsIdentical(rPr1, rPr2) {
+    const xml1 = rPr1 ? rPr1.toString() : "";
+    const xml2 = rPr2 ? rPr2.toString() : "";
+    return xml1 === xml2;
+  }
+  function hasSpecialContent(run) {
+    const safeTags = ["w:t", "w:tab", "w:br", "w:cr", "w:delText", "w:rPr"];
+    for (let i = 0; i < run.childNodes.length; i++) {
+      const child = run.childNodes[i];
+      if (child.nodeType === 1) {
+        const tag = child.tagName;
+        if (!safeTags.includes(tag)) return true;
+      }
+    }
+    return false;
+  }
+  function coalesceContainer(container) {
+    const children = Array.from(container.childNodes).filter((n) => n.nodeType === 1);
+    let i = 0;
+    while (i < children.length - 1) {
+      const curr = children[i];
+      const nxt = children[i + 1];
+      if (curr.tagName === "w:r" && nxt.tagName === "w:r") {
+        if (!hasSpecialContent(curr) && !hasSpecialContent(nxt)) {
+          const rPr1 = findChild(curr, "w:rPr");
+          const rPr2 = findChild(nxt, "w:rPr");
+          if (areRunsIdentical(rPr1, rPr2)) {
+            let last_t = null;
+            for (let c = 0; c < curr.childNodes.length; c++) {
+              const child = curr.childNodes[c];
+              if (child.nodeType === 1 && (child.tagName === "w:t" || child.tagName === "w:delText")) {
+                last_t = child;
+              }
+            }
+            const nxtChildren = Array.from(nxt.childNodes).filter((n) => n.nodeType === 1);
+            for (const child of nxtChildren) {
+              if (child.tagName === "w:rPr") continue;
+              if ((child.tagName === "w:t" || child.tagName === "w:delText") && last_t && last_t.tagName === child.tagName) {
+                const t1 = last_t.textContent || "";
+                const t2 = child.textContent || "";
+                const combined = t1 + t2;
+                last_t.textContent = combined;
+                if (combined.trim() !== combined) {
+                  last_t.setAttribute("xml:space", "preserve");
+                }
+              } else {
+                curr.appendChild(child);
+                if (child.tagName === "w:t" || child.tagName === "w:delText") {
+                  last_t = child;
+                }
+              }
+            }
+            container.removeChild(nxt);
+            children.splice(i + 1, 1);
+            count++;
+            continue;
+          }
+        }
+      }
+      if (["w:ins", "w:del", "w:hyperlink", "w:sdt", "w:smartTag", "w:fldSimple", "w:sdtContent"].includes(curr.tagName)) {
+        coalesceContainer(curr);
+      }
+      i++;
+    }
+    if (children.length > 0) {
+      const last = children[children.length - 1];
+      if (["w:ins", "w:del", "w:hyperlink", "w:sdt", "w:smartTag", "w:fldSimple", "w:sdtContent"].includes(last.tagName)) {
+        coalesceContainer(last);
+      }
+    }
+  }
+  const paragraphs = findAllDescendants(doc.element, "w:p");
+  for (const p of paragraphs) coalesceContainer(p);
+  return count ? [`Adjacent identical runs coalesced: ${count}`] : [];
+}
 function strip_rsid(doc) {
   let count = 0;
   const rsidAttrs = ["w:rsidR", "w:rsidRPr", "w:rsidRDefault", "w:rsidP", "w:rsidDel", "w:rsidSect", "w:rsidTr"];
@@ -4388,6 +5659,7 @@ async function finalize_document(doc, options) {
   report.add_transform_lines(strip_proof_errors(doc));
   report.add_transform_lines(strip_empty_properties(doc));
   report.add_transform_lines(strip_hidden_text(doc));
+  report.add_transform_lines(coalesce_runs(doc));
   report.add_transform_lines(scrub_doc_properties(doc));
   report.add_transform_lines(scrub_timestamps(doc));
   report.add_transform_lines(strip_custom_xml(doc));
@@ -4415,6 +5687,26 @@ async function finalize_document(doc, options) {
   if (options.export_pdf) {
     report.warnings.push("PDF export requires the Python/Word COM environment and is skipped in this zero-dependency Node agent.");
   }
+  for (const part of doc.pkg.parts) {
+    if (part === doc.part || part.contentType.includes("wordprocessingml") && part.contentType.endsWith("+xml")) {
+      if (part._element.hasAttribute("xmlns:w16du")) {
+        let hasW16du = false;
+        if (Array.from(part._element.attributes || []).some((a) => a.name.startsWith("w16du:") && a.name !== "xmlns:w16du")) {
+          hasW16du = true;
+        }
+        if (!hasW16du) {
+          const allNodes = findAllDescendants(part._element, "*");
+          for (const n of allNodes) {
+            if (n.tagName.startsWith("w16du:") || Array.from(n.attributes || []).some((a) => a.name.startsWith("w16du:"))) {
+              hasW16du = true;
+              break;
+            }
+          }
+        }
+        if (!hasW16du) part._element.removeAttribute("xmlns:w16du");
+      }
+    }
+  }
   if (report.warnings.length > 0) report.status = "clean_with_warnings";
   const outBuffer = await doc.save();
   return { reportText: report.render(), outBuffer };
@@ -4432,6 +5724,7 @@ function identifyEngine() {
   RedlineEngine,
   apply_edits_to_markdown,
   create_unified_diff,
+  create_word_patch_diff,
   extractTextFromBuffer,
   extract_outline,
   finalize_document,