@ansonlai/docx-redline-js 0.8.0 → 0.8.2

package/dist/docx-redline.bundle.cjs

@@ -1,4 +1,4 @@
-// @ansonlai/docx-redline-js standalone CommonJS bundle v0.8.0 — https://github.com/AnsonLai/docx-redline-js
+// @ansonlai/docx-redline-js standalone CommonJS bundle v0.8.2 — https://github.com/AnsonLai/docx-redline-js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -8080,6 +8080,7 @@ __export(index_exports, {
   rejectTrackedChangesInOoxml: () => rejectTrackedChangesInOoxml,
   remapNumberingPayloadForDocument: () => remapNumberingPayloadForDocument,
   removeFormattingFromRPr: () => removeFormattingFromRPr,
+  repairKnownContentTypes: () => repairKnownContentTypes,
   reserveNextNumberingId: () => reserveNextNumberingId,
   reserveNextNumberingIdPair: () => reserveNextNumberingIdPair,
   resolveParagraphRangeByRefs: () => resolveParagraphRangeByRefs,
@@ -9138,15 +9139,29 @@ function createDiffEngine(options = {}) {
   engine.Diff_Timeout = timeout;
   return engine;
 }
-function tokenize(text2) {
+function tokenize(text2, atomicChars = null) {
   const tokens = [];
+  const pushWord = (word) => {
+    if (!atomicChars || atomicChars.size === 0) {
+      tokens.push(word);
+      return;
+    }
+    let start = 0;
+    for (let index = 0; index < word.length; index++) {
+      if (!atomicChars.has(word[index])) continue;
+      if (index > start) tokens.push(word.slice(start, index));
+      tokens.push(word[index]);
+      start = index + 1;
+    }
+    if (start < word.length) tokens.push(word.slice(start));
+  };
   const leading = text2.match(/^\s+/);
   if (leading) tokens.push(leading[0]);
   const regex = /(\S+)(\s*)/g;
   regex.lastIndex = leading?.[0].length || 0;
   let match;
   while ((match = regex.exec(text2)) !== null) {
-    if (match[1]) tokens.push(match[1]);
+    if (match[1]) pushWord(match[1]);
     if (match[2]) tokens.push(match[2]);
   }
   return tokens;
@@ -9174,8 +9189,8 @@ function wordsToChars(text1, text2, options = {}) {
     }
     return { chars, tokenIds };
   }
-  const tokens1 = tokenize(text1);
-  const tokens2 = tokenize(text2);
+  const tokens1 = tokenize(text1, options.atomicChars);
+  const tokens2 = tokenize(text2, options.atomicChars);
   const encoded1 = mapTokensToChars(tokens1);
   const encoded2 = mapTokensToChars(tokens2);
   return {
@@ -14333,6 +14348,19 @@ function applyReconstructionDiffs(xmlDoc, diffs, context, serializer, author, fo
       pendingReplacementEvent = null;
     }
   }
+  for (const offset of Array.from(sentinelMapByStart.keys()).sort((a, b) => a - b)) {
+    for (const sentinel of sentinelMapByStart.get(offset)) {
+      if (!sentinel.isCommentMarker || emittedCommentMarkers.has(sentinel.node)) continue;
+      emittedCommentMarkers.add(sentinel.node);
+      if (isWordElement(sentinel.node, "commentReference")) {
+        const run = createWordElement(xmlDoc, "w:r");
+        run.appendChild(sentinel.node.cloneNode(true));
+        currentParagraph.appendChild(run);
+      } else {
+        currentParagraph.appendChild(sentinel.node.cloneNode(true));
+      }
+    }
+  }
   if (generateRedlines) {
     containerFragments.forEach((fragment) => {
       Array.from(fragment.childNodes).forEach((node) => {
@@ -14567,7 +14595,11 @@ function applyReconstructionMode(xmlDoc, originalText, modifiedText, serializer,
   if (mapping.paragraphs.length === 0) {
     return withOoxmlSourceType({ oxml: serializer.serializeToString(xmlDoc), hasChanges: false });
   }
-  const diffs = computeWordDiffs(mapping.originalFullText, mapping.processedModifiedText, diffOptions);
+  const wordDiffs = computeWordDiffs(mapping.originalFullText, mapping.processedModifiedText, {
+    ...diffOptions,
+    atomicChars: new Set(mapping.referenceMap.keys())
+  });
+  const diffs = keepUnchangedTextOutsideWrappers(anchorSharedReferences(wordDiffs, mapping.referenceMap), mapping);
   return withOoxmlSourceType(applyReconstructionDiffs(
     xmlDoc,
     diffs,
@@ -14579,6 +14611,109 @@ function applyReconstructionMode(xmlDoc, originalText, modifiedText, serializer,
     options
   ));
 }
+function forEachChangeGroup(diffs, onEqual, onGroup) {
+  let index = 0;
+  while (index < diffs.length) {
+    if (diffs[index][0] === 0) {
+      onEqual(diffs[index]);
+      index++;
+      continue;
+    }
+    const group = [];
+    while (index < diffs.length && diffs[index][0] !== 0) group.push(diffs[index++]);
+    onGroup(
+      group,
+      group.filter(([op]) => op === -1).map(([, text2]) => text2).join(""),
+      group.filter(([op]) => op === 1).map(([, text2]) => text2).join("")
+    );
+  }
+}
+function pushChange(result, deleted, inserted) {
+  if (deleted === inserted) {
+    if (deleted) result.push([0, deleted]);
+    return;
+  }
+  if (deleted) result.push([-1, deleted]);
+  if (inserted) result.push([1, inserted]);
+}
+function anchorSharedReferences(diffs, referenceMap) {
+  if (referenceMap.size === 0) return diffs;
+  const result = [];
+  forEachChangeGroup(diffs, (part) => result.push(part), (group, deleted, inserted) => {
+    const deletedRefs = [...deleted].filter((char) => referenceMap.has(char) && inserted.includes(char));
+    const insertedRefs = [...inserted].filter((char) => deletedRefs.includes(char));
+    if (deletedRefs.length === 0 || deletedRefs.join("") !== insertedRefs.join("")) {
+      result.push(...group);
+      return;
+    }
+    let deletedStart = 0;
+    let insertedStart = 0;
+    for (const ref of deletedRefs) {
+      const deletedAt = deleted.indexOf(ref, deletedStart);
+      const insertedAt = inserted.indexOf(ref, insertedStart);
+      pushChange(result, deleted.slice(deletedStart, deletedAt), inserted.slice(insertedStart, insertedAt));
+      result.push([0, ref]);
+      deletedStart = deletedAt + 1;
+      insertedStart = insertedAt + 1;
+    }
+    pushChange(result, deleted.slice(deletedStart), inserted.slice(insertedStart));
+  });
+  return result;
+}
+function commonPrefixLength(left, right) {
+  const limit = Math.min(left.length, right.length);
+  let length = 0;
+  while (length < limit && left[length] === right[length]) length++;
+  return length;
+}
+function commonSuffixLength(left, right, limit) {
+  let length = 0;
+  while (length < limit && left[left.length - 1 - length] === right[right.length - 1 - length]) length++;
+  return length;
+}
+function keepUnchangedTextOutsideWrappers(diffs, mapping) {
+  const wrapperAt = (index) => mapping.getRunProperties(index).wrapper || null;
+  const result = [];
+  let originalOffset = 0;
+  forEachChangeGroup(diffs, (part) => {
+    result.push(part);
+    originalOffset += part[1].length;
+  }, (group, deleted, inserted) => {
+    const start = originalOffset;
+    const end = start + deleted.length;
+    originalOffset = end;
+    const isWrapperBoundary = (index) => index > start && index < end && wrapperAt(index - 1) !== wrapperAt(index);
+    let prefix = 0;
+    let suffix = 0;
+    if (deleted && inserted) {
+      const sharedSuffix = commonSuffixLength(deleted, inserted, Math.min(deleted.length, inserted.length));
+      for (let length = sharedSuffix; length > 0; length--) {
+        if (isWrapperBoundary(end - length)) {
+          suffix = length;
+          break;
+        }
+      }
+      const sharedPrefix = Math.min(
+        commonPrefixLength(deleted, inserted),
+        Math.min(deleted.length, inserted.length) - suffix
+      );
+      for (let length = sharedPrefix; length > 0; length--) {
+        if (isWrapperBoundary(start + length)) {
+          prefix = length;
+          break;
+        }
+      }
+    }
+    if (prefix === 0 && suffix === 0) {
+      result.push(...group);
+      return;
+    }
+    if (prefix > 0) result.push([0, deleted.slice(0, prefix)]);
+    pushChange(result, deleted.slice(prefix, deleted.length - suffix), inserted.slice(prefix, inserted.length - suffix));
+    if (suffix > 0) result.push([0, deleted.slice(deleted.length - suffix)]);
+  });
+  return result;
+}
 
 // engine/table-mode.js
 function noChanges(serializer, xmlDoc) {
@@ -18127,6 +18262,260 @@ function ingestWordOoxmlToMarkdownResult(ooxml) {
   return { text: lines.join("\n\n").trim(), status: "ok", warnings: parsed.warnings };
 }
 
+// services/comment-builders.js
+var NS_W14 = "http://schemas.microsoft.com/office/word/2010/wordml";
+var NS_W15 = "http://schemas.microsoft.com/office/word/2012/wordml";
+function createCommentParaId(commentId) {
+  const numeric = Number.parseInt(String(commentId), 10);
+  const value = Number.isFinite(numeric) ? 1879048192 + (numeric >>> 0) >>> 0 : 1879048192;
+  return value.toString(16).toUpperCase().padStart(8, "0").slice(-8);
+}
+function buildCommentElement(commentId, author, content, date, paraId = createCommentParaId(commentId)) {
+  const initials = author.split(" ").map((word) => word[0]).join("").toUpperCase() || "AI";
+  const escapedContent = escapeXml(content);
+  const escapedAuthor = escapeXml(author);
+  return `<w:comment w:id="${commentId}" w:author="${escapedAuthor}" w:date="${date}" w:initials="${initials}">
+      <w:p w14:paraId="${escapeXml(paraId)}" xmlns:w14="${NS_W14}">
+        <w:r><w:t>${escapedContent}</w:t></w:r>
+      </w:p>
+    </w:comment>`;
+}
+function buildCommentsPartXml(comments) {
+  if (!comments || comments.length === 0) {
+    return `<w:comments xmlns:w="${NS_W}"></w:comments>`;
+  }
+  const commentElements = comments.map(
+    (comment) => buildCommentElement(comment.id, comment.author, comment.content, comment.date, comment.paraId)
+  ).join("\n    ");
+  return `<w:comments xmlns:w="${NS_W}">
+    ${commentElements}
+  </w:comments>`;
+}
+function buildCommentsExtendedPartXml(entries) {
+  const body = (entries || []).map((entry) => {
+    const parent = entry.paraIdParent ? ` w15:paraIdParent="${escapeXml(entry.paraIdParent)}"` : "";
+    return `<w15:commentEx w15:paraId="${escapeXml(entry.paraId)}"${parent} w15:done="${entry.done ? "1" : "0"}"/>`;
+  }).join("");
+  return `<w15:commentsEx xmlns:w15="${NS_W15}">${body}</w15:commentsEx>`;
+}
+
+// services/comment-thread-parts.js
+var attrOf = (node, qualified, local) => node?.getAttribute?.(qualified) || node?.getAttribute?.(local) || "";
+function commentThreadParagraph(commentElement) {
+  const paragraphs = Array.from(commentElement?.getElementsByTagNameNS?.("*", "p") || []);
+  return paragraphs.length ? paragraphs[paragraphs.length - 1] : null;
+}
+function commentParaId(commentElement) {
+  return attrOf(commentThreadParagraph(commentElement), "w14:paraId", "paraId").toUpperCase();
+}
+function usedParaIds(commentsDoc, extendedDoc) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const p of Array.from(commentsDoc?.getElementsByTagNameNS("*", "p") || [])) {
+    const id = attrOf(p, "w14:paraId", "paraId");
+    if (id) ids.add(id.toUpperCase());
+  }
+  for (const ex of Array.from(extendedDoc?.getElementsByTagNameNS("*", "commentEx") || [])) {
+    const id = attrOf(ex, "w15:paraId", "paraId");
+    if (id) ids.add(id.toUpperCase());
+  }
+  return ids;
+}
+function allocateParaId(commentId, occupied) {
+  let candidate = createCommentParaId(commentId);
+  let value = Number.parseInt(candidate, 16) >>> 0;
+  while (occupied.has(candidate)) {
+    value = value + 1 >>> 0;
+    candidate = value.toString(16).toUpperCase().padStart(8, "0");
+  }
+  occupied.add(candidate);
+  return candidate;
+}
+var parseDoc = (xml, partName) => {
+  const parsed = parseOoxmlSafe(xml, "application/xml");
+  if (!parsed.doc || parsed.error) return { error: { code: "PARSE_ERROR", message: `Could not parse ${partName}: ${parsed.error?.message || "invalid XML"}` } };
+  return { doc: parsed.doc };
+};
+function applyThreadResolutionToParts({ commentsXml, commentsExtendedXml = null, commentId, resolved = true }) {
+  if (!commentsXml) return { status: "error", error: { code: "COMMENTS_PART_MISSING", message: "Resolving a comment requires an existing word/comments.xml part." } };
+  const commentsParsed = parseDoc(commentsXml, "word/comments.xml");
+  if (commentsParsed.error) return { status: "error", error: commentsParsed.error };
+  const commentsDoc = commentsParsed.doc;
+  const idOf = (node) => attrOf(node, "w:id", "id");
+  const comments = Array.from(commentsDoc.getElementsByTagNameNS("*", "comment"));
+  const target = comments.find((node) => idOf(node) === String(commentId));
+  if (!target) return { status: "error", error: { code: "COMMENT_NOT_FOUND", message: `Comment '${commentId}' was not found.` } };
+  let extendedDoc;
+  if (commentsExtendedXml) {
+    const parsed = parseDoc(commentsExtendedXml, "word/commentsExtended.xml");
+    if (parsed.error) return { status: "error", error: parsed.error };
+    extendedDoc = parsed.doc;
+  } else {
+    extendedDoc = parseDoc(`<w15:commentsEx xmlns:w15="${NS_W15}"/>`, "word/commentsExtended.xml").doc;
+  }
+  const root = extendedDoc.documentElement;
+  const entryFor = (paraId) => Array.from(root.getElementsByTagNameNS("*", "commentEx")).find((node) => attrOf(node, "w15:paraId", "paraId").toUpperCase() === paraId) || null;
+  const occupied = usedParaIds(commentsDoc, extendedDoc);
+  let commentsChanged = false;
+  const keyOf = (node) => {
+    let paraId = commentParaId(node);
+    if (!paraId) {
+      paraId = allocateParaId(idOf(node), occupied);
+      commentThreadParagraph(node)?.setAttributeNS(NS_W14, "w14:paraId", paraId);
+      commentsChanged = true;
+    }
+    return paraId;
+  };
+  const targetKey = keyOf(target);
+  const targetEntry = entryFor(targetKey);
+  const rootKey = targetEntry && attrOf(targetEntry, "w15:paraIdParent", "paraIdParent").toUpperCase() || targetKey;
+  const threadKeys = /* @__PURE__ */ new Set([rootKey, targetKey]);
+  for (const entry of Array.from(root.getElementsByTagNameNS("*", "commentEx"))) {
+    if (attrOf(entry, "w15:paraIdParent", "paraIdParent").toUpperCase() === rootKey) threadKeys.add(attrOf(entry, "w15:paraId", "paraId").toUpperCase());
+  }
+  const doneValue = resolved ? "1" : "0";
+  let extendedChanged = !commentsExtendedXml;
+  for (const key of threadKeys) {
+    let entry = entryFor(key);
+    if (!entry) {
+      entry = extendedDoc.createElementNS(NS_W15, "w15:commentEx");
+      entry.setAttributeNS(NS_W15, "w15:paraId", key);
+      if (key !== rootKey) entry.setAttributeNS(NS_W15, "w15:paraIdParent", rootKey);
+      entry.setAttributeNS(NS_W15, "w15:done", doneValue);
+      root.appendChild(entry);
+      extendedChanged = true;
+    } else if (attrOf(entry, "w15:done", "done") !== doneValue) {
+      entry.setAttributeNS(NS_W15, "w15:done", doneValue);
+      extendedChanged = true;
+    }
+  }
+  const byKey = new Map(comments.map((node) => [commentParaId(node), node]));
+  const commentIds = [...threadKeys].map((key) => byKey.get(key)).filter(Boolean).map(idOf);
+  const rootComment = byKey.get(rootKey);
+  const serializer = createSerializer();
+  const hasChanges = extendedChanged || commentsChanged;
+  return {
+    status: "ok",
+    hasChanges,
+    resolved,
+    threadRootId: rootComment ? idOf(rootComment) : String(commentId),
+    commentIds,
+    ...hasChanges ? { commentsExtendedXml: serializer.serializeToString(extendedDoc) } : {},
+    ...commentsChanged ? { commentsXml: serializer.serializeToString(commentsDoc) } : {}
+  };
+}
+var NS_W_MAIN = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+function anchorReplyInDocument(xmlDoc, memberIds, newId) {
+  const wanted = new Set(memberIds.map(String));
+  const idOf = (node) => attrOf(node, "w:id", "id");
+  const all = (name) => Array.from(xmlDoc.getElementsByTagNameNS("*", name)).filter((node) => wanted.has(idOf(node)));
+  const starts = all("commentRangeStart");
+  const references = all("commentReference");
+  if (!starts.length || !references.length) return false;
+  const lastStart = starts[starts.length - 1];
+  const lastReference = references[references.length - 1];
+  const referenceRun = lastReference.parentNode?.localName === "r" ? lastReference.parentNode : lastReference;
+  const make = (name, parent) => {
+    const element = xmlDoc.createElementNS(NS_W_MAIN, `w:${name}`);
+    element.setAttributeNS(NS_W_MAIN, "w:id", String(newId));
+    if (parent) parent.appendChild(element);
+    return element;
+  };
+  const insertAfter = (anchor, node) => anchor.parentNode.insertBefore(node, anchor.nextSibling);
+  insertAfter(lastStart, make("commentRangeStart"));
+  const end = make("commentRangeEnd");
+  const run = xmlDoc.createElementNS(NS_W_MAIN, "w:r");
+  run.appendChild(xmlDoc.createElementNS(NS_W_MAIN, "w:rPr"));
+  make("commentReference", run);
+  insertAfter(referenceRun, end);
+  insertAfter(end, run);
+  return true;
+}
+var NS_W16CID = "http://schemas.microsoft.com/office/word/2016/wordml/cid";
+var NS_W16CEX = "http://schemas.microsoft.com/office/word/2018/wordml/cex";
+var durableIdFor = (paraId, taken) => {
+  let value = (Number.parseInt(paraId, 16) ^ 625341585) & 2147483646;
+  let candidate = value.toString(16).toUpperCase().padStart(8, "0");
+  while (taken.has(candidate)) {
+    value = value + 2 & 2147483646;
+    candidate = value.toString(16).toUpperCase().padStart(8, "0");
+  }
+  taken.add(candidate);
+  return candidate;
+};
+function reconcileCommentSiblingParts({ commentsXml, commentsIdsXml = null, commentsExtensibleXml = null }) {
+  const out = {};
+  if (!commentsXml || !commentsIdsXml && !commentsExtensibleXml) return out;
+  const commentsParsed = parseOoxmlSafe(commentsXml, "application/xml");
+  if (!commentsParsed.doc || commentsParsed.error) return out;
+  const serializer = createSerializer();
+  const byKey = /* @__PURE__ */ new Map();
+  for (const node of Array.from(commentsParsed.doc.getElementsByTagNameNS("*", "comment"))) {
+    const key = commentParaId(node);
+    if (key) byKey.set(key, node);
+  }
+  let idsDoc = null;
+  const durableByKey = /* @__PURE__ */ new Map();
+  const taken = /* @__PURE__ */ new Set();
+  let idsChanged = false;
+  if (commentsIdsXml) {
+    const parsed = parseOoxmlSafe(commentsIdsXml, "application/xml");
+    if (!parsed.doc || parsed.error) return out;
+    idsDoc = parsed.doc;
+    const root = idsDoc.documentElement;
+    for (const entry of Array.from(root.getElementsByTagNameNS("*", "commentId"))) {
+      const key = attrOf(entry, "w16cid:paraId", "paraId").toUpperCase();
+      const durable = attrOf(entry, "w16cid:durableId", "durableId").toUpperCase();
+      if (durable) taken.add(durable);
+      if (!byKey.has(key)) {
+        root.removeChild(entry);
+        idsChanged = true;
+        continue;
+      }
+      durableByKey.set(key, durable);
+    }
+    for (const key of byKey.keys()) {
+      if (durableByKey.has(key)) continue;
+      const durable = durableIdFor(key, taken);
+      const entry = idsDoc.createElementNS(NS_W16CID, "w16cid:commentId");
+      entry.setAttributeNS(NS_W16CID, "w16cid:paraId", key);
+      entry.setAttributeNS(NS_W16CID, "w16cid:durableId", durable);
+      root.appendChild(entry);
+      durableByKey.set(key, durable);
+      idsChanged = true;
+    }
+  }
+  let extDoc = null;
+  let extChanged = false;
+  if (commentsExtensibleXml && idsDoc) {
+    const parsed = parseOoxmlSafe(commentsExtensibleXml, "application/xml");
+    if (parsed.doc && !parsed.error) {
+      extDoc = parsed.doc;
+      const root = extDoc.documentElement;
+      const live = new Set(durableByKey.values());
+      const present = /* @__PURE__ */ new Set();
+      for (const entry of Array.from(root.getElementsByTagNameNS("*", "commentExtensible"))) {
+        const durable = attrOf(entry, "w16cex:durableId", "durableId").toUpperCase();
+        if (!live.has(durable)) {
+          root.removeChild(entry);
+          extChanged = true;
+        } else present.add(durable);
+      }
+      for (const [key, durable] of durableByKey) {
+        if (present.has(durable)) continue;
+        const date = attrOf(byKey.get(key), "w:date", "date");
+        const entry = extDoc.createElementNS(NS_W16CEX, "w16cex:commentExtensible");
+        entry.setAttributeNS(NS_W16CEX, "w16cex:durableId", durable);
+        if (date) entry.setAttributeNS(NS_W16CEX, "w16cex:dateUtc", date);
+        root.appendChild(entry);
+        extChanged = true;
+      }
+    }
+  }
+  if (idsChanged) out.commentsIdsXml = serializer.serializeToString(idsDoc);
+  if (extChanged) out.commentsExtensibleXml = serializer.serializeToString(extDoc);
+  return out;
+}
+
 // core/sha256.js
 var K = new Uint32Array([
   1116352408,
@@ -18619,7 +19008,7 @@ function readCommentDefinitions(commentsDoc) {
       author: attr2(comment, "author") || null,
       date: attr2(comment, "date") || null,
       text: paragraphs.map((p) => extractCanonicalParagraphText(p)).join("\n"),
-      paraId: paragraphs[0]?.getAttribute?.("w14:paraId") || paragraphs[0]?.getAttribute?.("paraId") || null
+      paraId: commentParaId(comment) || null
     });
   }
   return result;
@@ -18850,43 +19239,6 @@ function inspectDocumentParts(parts, options = {}) {
   };
 }
 
-// services/comment-builders.js
-var NS_W14 = "http://schemas.microsoft.com/office/word/2010/wordml";
-var NS_W15 = "http://schemas.microsoft.com/office/word/2012/wordml";
-function createCommentParaId(commentId) {
-  const numeric = Number.parseInt(String(commentId), 10);
-  const value = Number.isFinite(numeric) ? 1879048192 + (numeric >>> 0) >>> 0 : 1879048192;
-  return value.toString(16).toUpperCase().padStart(8, "0").slice(-8);
-}
-function buildCommentElement(commentId, author, content, date, paraId = createCommentParaId(commentId)) {
-  const initials = author.split(" ").map((word) => word[0]).join("").toUpperCase() || "AI";
-  const escapedContent = escapeXml(content);
-  const escapedAuthor = escapeXml(author);
-  return `<w:comment w:id="${commentId}" w:author="${escapedAuthor}" w:date="${date}" w:initials="${initials}">
-      <w:p w14:paraId="${escapeXml(paraId)}" xmlns:w14="${NS_W14}">
-        <w:r><w:t>${escapedContent}</w:t></w:r>
-      </w:p>
-    </w:comment>`;
-}
-function buildCommentsPartXml(comments) {
-  if (!comments || comments.length === 0) {
-    return `<w:comments xmlns:w="${NS_W}"></w:comments>`;
-  }
-  const commentElements = comments.map(
-    (comment) => buildCommentElement(comment.id, comment.author, comment.content, comment.date, comment.paraId)
-  ).join("\n    ");
-  return `<w:comments xmlns:w="${NS_W}">
-    ${commentElements}
-  </w:comments>`;
-}
-function buildCommentsExtendedPartXml(entries) {
-  const body = (entries || []).map((entry) => {
-    const parent = entry.paraIdParent ? ` w15:paraIdParent="${escapeXml(entry.paraIdParent)}"` : "";
-    return `<w15:commentEx w15:paraId="${escapeXml(entry.paraId)}"${parent} w15:done="${entry.done ? "1" : "0"}"/>`;
-  }).join("");
-  return `<w15:commentsEx xmlns:w15="${NS_W15}">${body}</w15:commentsEx>`;
-}
-
 // services/comment-locator.js
 function createParagraphTextIndex(paragraph, options = {}) {
   const revisionView = options.revisionView === "current" ? "accepted" : options.revisionView || "accepted";
@@ -19347,29 +19699,7 @@ function parseRequired(xml, partName) {
   }
   return { doc: parsed.doc };
 }
-function usedParaIds(commentsDoc, extendedDoc) {
-  const ids = /* @__PURE__ */ new Set();
-  for (const p of Array.from(commentsDoc?.getElementsByTagNameNS("*", "p") || [])) {
-    const id = attr3(p, "w14:paraId", "paraId");
-    if (id) ids.add(id.toUpperCase());
-  }
-  for (const ex of Array.from(extendedDoc?.getElementsByTagNameNS("*", "commentEx") || [])) {
-    const id = attr3(ex, "w15:paraId", "paraId");
-    if (id) ids.add(id.toUpperCase());
-  }
-  return ids;
-}
-function allocateParaId(commentId, occupied) {
-  let candidate = createCommentParaId(commentId);
-  let value = Number.parseInt(candidate, 16) >>> 0;
-  while (occupied.has(candidate)) {
-    value = value + 1 >>> 0;
-    candidate = value.toString(16).toUpperCase().padStart(8, "0");
-  }
-  occupied.add(candidate);
-  return candidate;
-}
-function applyCommentReplyToParts({ commentsXml, commentsExtendedXml = null, parentCommentId, commentId, commentContent, author, date = (/* @__PURE__ */ new Date()).toISOString() }) {
+function applyCommentReplyToParts({ commentsXml, commentsExtendedXml = null, documentXml = null, parentCommentId, commentId, commentContent, author, date = (/* @__PURE__ */ new Date()).toISOString() }) {
   if (!commentsXml) return { status: "error", error: { code: "COMMENTS_PART_MISSING", message: "A comment reply requires an existing word/comments.xml part." } };
   const commentsParsed = parseRequired(commentsXml, "word/comments.xml");
   if (commentsParsed.error) return { status: "error", error: commentsParsed.error };
@@ -19383,15 +19713,31 @@ function applyCommentReplyToParts({ commentsXml, commentsExtendedXml = null, par
     extendedDoc = parsed.doc;
   }
   const occupied = usedParaIds(commentsDoc, extendedDoc);
-  const parentParagraph = Array.from(parent.getElementsByTagNameNS(NS_W6, "p"))[0] || Array.from(parent.getElementsByTagNameNS("*", "p"))[0];
+  if (documentXml) for (const match of String(documentXml).matchAll(/w14:paraId="([0-9A-Fa-f]{8})"/g)) occupied.add(match[1].toUpperCase());
+  const parentParagraph = commentThreadParagraph(parent);
   if (!parentParagraph) return { status: "error", error: { code: "PARENT_COMMENT_INVALID", message: `Parent comment '${parentCommentId}' has no paragraph.` } };
-  let parentParaId = attr3(parentParagraph, "w14:paraId", "paraId");
+  let parentParaId = commentParaId(parent);
   if (!parentParaId) {
     parentParaId = allocateParaId(parentCommentId, occupied);
     parentParagraph.setAttributeNS(NS_W14, "w14:paraId", parentParaId);
   } else {
     parentParaId = parentParaId.toUpperCase();
   }
+  for (const node of Array.from(extendedDoc?.getElementsByTagNameNS("*", "commentEx") || [])) {
+    if (attr3(node, "w15:paraId", "paraId").toUpperCase() === parentParaId) {
+      const root2 = attr3(node, "w15:paraIdParent", "paraIdParent").toUpperCase();
+      if (root2) parentParaId = root2;
+      break;
+    }
+  }
+  const threadCommentIds = [];
+  const commentNodes = Array.from(commentsDoc.getElementsByTagNameNS("*", "comment"));
+  const parentOf = new Map(Array.from(extendedDoc?.getElementsByTagNameNS("*", "commentEx") || []).map((node) => [attr3(node, "w15:paraId", "paraId").toUpperCase(), attr3(node, "w15:paraIdParent", "paraIdParent").toUpperCase()]));
+  for (const node of commentNodes) {
+    const key = commentParaId(node);
+    if (key === parentParaId || parentOf.get(key) === parentParaId) threadCommentIds.push(attr3(node, "w:id", "id"));
+  }
+  const threadRootCommentId = attr3(commentNodes.find((node) => commentParaId(node) === parentParaId), "w:id", "id") || String(parentCommentId);
   const replyParaId = allocateParaId(commentId, occupied);
   const replyParsed = parseRequired(`<w:comments xmlns:w="${NS_W6}" xmlns:w14="${NS_W14}">${buildCommentElement(commentId, author, commentContent, date, replyParaId)}</w:comments>`, "reply comment");
   commentsDoc.documentElement.appendChild(commentsDoc.importNode(replyParsed.doc.documentElement.firstChild, true));
@@ -19400,16 +19746,18 @@ function applyCommentReplyToParts({ commentsXml, commentsExtendedXml = null, par
   }
   const root = extendedDoc.documentElement;
   const entries = Array.from(root.getElementsByTagNameNS("*", "commentEx"));
-  if (!entries.some((node) => attr3(node, "w15:paraId", "paraId").toUpperCase() === parentParaId)) {
+  const rootEntry = entries.find((node) => attr3(node, "w15:paraId", "paraId").toUpperCase() === parentParaId);
+  if (!rootEntry) {
     const parentEx = extendedDoc.createElementNS(NS_W15, "w15:commentEx");
     parentEx.setAttributeNS(NS_W15, "w15:paraId", parentParaId);
     parentEx.setAttributeNS(NS_W15, "w15:done", "0");
     root.appendChild(parentEx);
   }
+  const threadDone = attr3(rootEntry, "w15:done", "done") === "1" ? "1" : "0";
   const replyEx = extendedDoc.createElementNS(NS_W15, "w15:commentEx");
   replyEx.setAttributeNS(NS_W15, "w15:paraId", replyParaId);
   replyEx.setAttributeNS(NS_W15, "w15:paraIdParent", parentParaId);
-  replyEx.setAttributeNS(NS_W15, "w15:done", "0");
+  replyEx.setAttributeNS(NS_W15, "w15:done", threadDone);
   root.appendChild(replyEx);
   const serializer = createSerializer();
   return {
@@ -19422,7 +19770,9 @@ function applyCommentReplyToParts({ commentsXml, commentsExtendedXml = null, par
     commentId,
     parentCommentId: String(parentCommentId),
     paraId: replyParaId,
-    parentParaId
+    parentParaId,
+    threadRootCommentId,
+    threadCommentIds: threadCommentIds.length ? threadCommentIds : [threadRootCommentId]
   };
 }
 
@@ -19487,19 +19837,19 @@ function applyFormattingRemovalToOoxml(ooxmlString, targetText, formatTypes) {
   if (!targetText || !ooxmlString) return ooxmlString;
   const doc = parseOoxml(ooxmlString);
   if (!doc) return ooxmlString;
-  const NS_W10 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
-  const runs = doc.getElementsByTagNameNS(NS_W10, "r");
-  const insertions = doc.getElementsByTagNameNS(NS_W10, "ins");
+  const NS_W11 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+  const runs = doc.getElementsByTagNameNS(NS_W11, "r");
+  const insertions = doc.getElementsByTagNameNS(NS_W11, "ins");
   const allRuns = [...Array.from(runs)];
   for (const ins of insertions) {
-    const insideRuns = ins.getElementsByTagNameNS(NS_W10, "r");
+    const insideRuns = ins.getElementsByTagNameNS(NS_W11, "r");
     allRuns.push(...Array.from(insideRuns));
   }
   for (const run of allRuns) {
-    const textNodes = run.getElementsByTagNameNS(NS_W10, "t");
+    const textNodes = run.getElementsByTagNameNS(NS_W11, "t");
     const runText = Array.from(textNodes).map((t) => t.textContent).join("");
     if (runText.includes(targetText) || runText === targetText) {
-      const rPrElements = run.getElementsByTagNameNS(NS_W10, "rPr");
+      const rPrElements = run.getElementsByTagNameNS(NS_W11, "rPr");
       if (rPrElements.length > 0) {
         const rPr = rPrElements[0];
         const newRPr = removeFormattingFromRPr(rPr, formatTypes);
@@ -19534,7 +19884,7 @@ var HIGHLIGHT_COLOR_MAP = {
   "white": "white"
 };
 function injectHighlightIntoRPr(doc, rPr, color = "yellow", options = {}) {
-  const NS_W10 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+  const NS_W11 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
   const ooxmlColor = HIGHLIGHT_COLOR_MAP[color.toLowerCase()] || "yellow";
   const generateRedlines = options?.generateRedlines ?? false;
   const author = options?.author || getDefaultAuthor();
@@ -19553,10 +19903,10 @@ function injectHighlightIntoRPr(doc, rPr, color = "yellow", options = {}) {
       }
     });
   }
-  const existingHighlight = rPrElement.getElementsByTagNameNS(NS_W10, "highlight");
+  const existingHighlight = rPrElement.getElementsByTagNameNS(NS_W11, "highlight");
   Array.from(existingHighlight).forEach(removeNode2);
   const highlightEl = createWordElement(doc, "w:highlight");
-  highlightEl.setAttributeNS(NS_W10, "w:val", ooxmlColor);
+  highlightEl.setAttributeNS(NS_W11, "w:val", ooxmlColor);
   rPrElement.appendChild(highlightEl);
   if (generateRedlines && previousRPrState) {
     const rPrChange = createWordElement(doc, "w:rPrChange");
@@ -19565,7 +19915,7 @@ function injectHighlightIntoRPr(doc, rPr, color = "yellow", options = {}) {
     rPrChange.setAttribute("w:author", metadata.author);
     rPrChange.setAttribute("w:date", metadata.date);
     rPrChange.appendChild(previousRPrState);
-    const existingChange = rPrElement.getElementsByTagNameNS(NS_W10, "rPrChange");
+    const existingChange = rPrElement.getElementsByTagNameNS(NS_W11, "rPrChange");
     Array.from(existingChange).forEach(removeNode2);
     rPrElement.appendChild(rPrChange);
   }
@@ -19582,12 +19932,12 @@ function applyHighlightToOoxml(ooxmlString, targetText, color = "yellow", option
   } else {
     revisionIdAllocator = createRevisionIdAllocator(doc);
   }
-  const NS_W10 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+  const NS_W11 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
   const getRunText = (run) => {
-    const textNodes = run.getElementsByTagNameNS(NS_W10, "t");
+    const textNodes = run.getElementsByTagNameNS(NS_W11, "t");
     return Array.from(textNodes).map((t) => t.textContent).join("");
   };
-  const allRuns = Array.from(doc.getElementsByTagNameNS(NS_W10, "r"));
+  const allRuns = Array.from(doc.getElementsByTagNameNS(NS_W11, "r"));
   const sourceRunsWithClaimedRevisionIds = /* @__PURE__ */ new WeakSet();
   const cloneRunWithText2 = (sourceRun, text2, shouldHighlight) => {
     const clonedRun = sourceRun.cloneNode(true);
@@ -19596,14 +19946,14 @@ function applyHighlightToOoxml(ooxmlString, targetText, color = "yellow", option
     } else {
       sourceRunsWithClaimedRevisionIds.add(sourceRun);
     }
-    const textNodes = clonedRun.getElementsByTagNameNS(NS_W10, "t");
+    const textNodes = clonedRun.getElementsByTagNameNS(NS_W11, "t");
     Array.from(textNodes).forEach(removeNode2);
     const newText = createWordElement(doc, "w:t");
     newText.setAttribute("xml:space", "preserve");
     newText.textContent = text2;
     clonedRun.appendChild(newText);
     if (shouldHighlight) {
-      const rPrElements = clonedRun.getElementsByTagNameNS(NS_W10, "rPr");
+      const rPrElements = clonedRun.getElementsByTagNameNS(NS_W11, "rPr");
       const existingRPr = rPrElements.length > 0 ? rPrElements[0] : null;
       const newRPr = injectHighlightIntoRPr(doc, existingRPr, color, options);
       if (existingRPr) {
@@ -19652,20 +20002,68 @@ function applyHighlightToOoxml(ooxmlString, targetText, color = "yellow", option
   return serializeOoxml(doc);
 }
 
+// services/package-parts.js
+var WORD_ML = "application/vnd.openxmlformats-officedocument.wordprocessingml";
+var REL_OFFICE_DOC = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+var PART_SPECS = Object.freeze([
+  { id: "document", path: "word/document.xml", pathPattern: null, contentType: `${WORD_ML}.document.main+xml`, legacyContentTypes: [], relType: `${REL_OFFICE_DOC}/officeDocument`, relTarget: null, verified: true },
+  { id: "numbering", path: "word/numbering.xml", pathPattern: null, contentType: `${WORD_ML}.numbering+xml`, legacyContentTypes: [], relType: `${REL_OFFICE_DOC}/numbering`, relTarget: "numbering.xml", verified: false },
+  { id: "comments", path: "word/comments.xml", pathPattern: null, contentType: `${WORD_ML}.comments+xml`, legacyContentTypes: [], relType: `${REL_OFFICE_DOC}/comments`, relTarget: "comments.xml", verified: true },
+  {
+    id: "commentsExtended",
+    path: "word/commentsExtended.xml",
+    pathPattern: null,
+    contentType: `${WORD_ML}.commentsExtended+xml`,
+    // Written by this package through 0.8.0; Word does not recognize it and offers to repair the file.
+    legacyContentTypes: ["application/vnd.ms-word.commentsExtended+xml"],
+    relType: "http://schemas.microsoft.com/office/2011/relationships/commentsExtended",
+    relTarget: "commentsExtended.xml",
+    verified: true
+  },
+  { id: "commentsIds", path: "word/commentsIds.xml", pathPattern: null, contentType: `${WORD_ML}.commentsIds+xml`, legacyContentTypes: [], relType: "http://schemas.microsoft.com/office/2016/09/relationships/commentsIds", relTarget: "commentsIds.xml", verified: true },
+  { id: "commentsExtensible", path: "word/commentsExtensible.xml", pathPattern: null, contentType: `${WORD_ML}.commentsExtensible+xml`, legacyContentTypes: [], relType: "http://schemas.microsoft.com/office/2018/08/relationships/commentsExtensible", relTarget: "commentsExtensible.xml", verified: true },
+  // Not yet produced by any Word fixture (Word only writes people.xml for signed-in authors): unverified.
+  { id: "people", path: "word/people.xml", pathPattern: null, contentType: `${WORD_ML}.people+xml`, legacyContentTypes: [], relType: "http://schemas.microsoft.com/office/2011/relationships/people", relTarget: "people.xml", verified: false },
+  { id: "header", path: null, pathPattern: /^word\/header\d+\.xml$/i, contentType: `${WORD_ML}.header+xml`, legacyContentTypes: [], relType: `${REL_OFFICE_DOC}/header`, relTarget: null, verified: true },
+  { id: "footer", path: null, pathPattern: /^word\/footer\d+\.xml$/i, contentType: `${WORD_ML}.footer+xml`, legacyContentTypes: [], relType: `${REL_OFFICE_DOC}/footer`, relTarget: null, verified: true }
+].map((spec) => Object.freeze(spec)));
+var BY_ID = new Map(PART_SPECS.map((spec) => [spec.id, spec]));
+function getPartSpec(id) {
+  const spec = BY_ID.get(id);
+  if (!spec) throw new Error(`Unknown package part: ${id}`);
+  return spec;
+}
+function toEntryName(partName) {
+  return String(partName || "").replace(/^\/+/, "");
+}
+function findPartSpecByPartName(partName) {
+  const name = toEntryName(partName);
+  const lower = name.toLowerCase();
+  return PART_SPECS.find((spec) => spec.path ? spec.path.toLowerCase() === lower : spec.pathPattern?.test(name)) || null;
+}
+function correctedContentTypeFor(partName, actualContentType) {
+  const spec = findPartSpecByPartName(partName);
+  if (!spec || !spec.legacyContentTypes.includes(actualContentType)) return null;
+  return spec.contentType;
+}
+
 // services/standalone-docx-plumbing.js
 var NS_W7 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
 var NS_CT = "http://schemas.openxmlformats.org/package/2006/content-types";
 var NS_RELS = "http://schemas.openxmlformats.org/package/2006/relationships";
-var NUMBERING_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering";
-var NUMBERING_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml";
-var COMMENTS_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments";
-var COMMENTS_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml";
-var COMMENTS_EXTENDED_REL_TYPE = "http://schemas.microsoft.com/office/2011/relationships/commentsExtended";
-var COMMENTS_EXTENDED_CONTENT_TYPE = "application/vnd.ms-word.commentsExtended+xml";
-var DOCUMENT_PATH = "word/document.xml";
-var NUMBERING_PATH = "word/numbering.xml";
-var COMMENTS_PATH = "word/comments.xml";
-var COMMENTS_EXTENDED_PATH = "word/commentsExtended.xml";
+var NUMBERING = getPartSpec("numbering");
+var COMMENTS = getPartSpec("comments");
+var COMMENTS_EXTENDED = getPartSpec("commentsExtended");
+var NUMBERING_REL_TYPE = NUMBERING.relType;
+var NUMBERING_CONTENT_TYPE = NUMBERING.contentType;
+var COMMENTS_REL_TYPE = COMMENTS.relType;
+var COMMENTS_CONTENT_TYPE = COMMENTS.contentType;
+var COMMENTS_EXTENDED_REL_TYPE = COMMENTS_EXTENDED.relType;
+var COMMENTS_EXTENDED_CONTENT_TYPE = COMMENTS_EXTENDED.contentType;
+var DOCUMENT_PATH = getPartSpec("document").path;
+var NUMBERING_PATH = NUMBERING.path;
+var COMMENTS_PATH = COMMENTS.path;
+var COMMENTS_EXTENDED_PATH = COMMENTS_EXTENDED.path;
 var CONTENT_TYPES_PATH = "[Content_Types].xml";
 var DOCUMENT_RELS_PATH = "word/_rels/document.xml.rels";
 function parseXmlStrictStandalone(xmlText, label = "xml") {
@@ -19953,6 +20351,22 @@ async function ensureCommentsExtendedArtifactsInZip(zip, commentsExtendedXml, op
     }
   }
 }
+async function repairKnownContentTypes(zip) {
+  const ctText = await readZipText(zip, CONTENT_TYPES_PATH);
+  if (!ctText) return [];
+  const ctDoc = parseXmlStrictStandalone(ctText, CONTENT_TYPES_PATH);
+  const repairs = [];
+  for (const override of Array.from(ctDoc.getElementsByTagNameNS("*", "Override"))) {
+    const partName = override.getAttribute("PartName") || "";
+    const actual = override.getAttribute("ContentType") || "";
+    const expected = correctedContentTypeFor(partName, actual);
+    if (!expected) continue;
+    override.setAttribute("ContentType", expected);
+    repairs.push({ partName, from: actual, to: expected });
+  }
+  if (repairs.length > 0) zip.file(CONTENT_TYPES_PATH, createSerializer().serializeToString(ctDoc));
+  return repairs;
+}
 async function validateDocxPackage(zip) {
   const documentXml = await readZipText(zip, DOCUMENT_PATH);
   if (!documentXml) {
@@ -20034,9 +20448,8 @@ async function validateDocxPackage(zip) {
       const paraIdToCommentId = /* @__PURE__ */ new Map();
       for (const comment of Array.from(commentsDoc.getElementsByTagNameNS("*", "comment"))) {
         const id = comment.getAttribute("w:id") || comment.getAttribute("id");
-        const paragraph = Array.from(comment.getElementsByTagNameNS("*", "p"))[0];
-        const paraId = paragraph?.getAttribute("w14:paraId") || paragraph?.getAttribute("paraId");
-        if (paraId) paraIdToCommentId.set(paraId.toUpperCase(), id);
+        const paraId = commentParaId(comment);
+        if (paraId) paraIdToCommentId.set(paraId, id);
       }
       const knownParaIds = new Set(paraIdToCommentId.keys());
       const extendedParaIds = /* @__PURE__ */ new Set();
@@ -20097,10 +20510,39 @@ async function validateDocxPackage(zip) {
       throw new Error("Validation failed: comments rel missing");
     }
   }
+  {
+    const relationshipById = /* @__PURE__ */ new Map();
+    for (const rel of Array.from(relsDoc.getElementsByTagNameNS("*", "Relationship"))) {
+      relationshipById.set(rel.getAttribute("Id") || "", { type: rel.getAttribute("Type") || "", target: rel.getAttribute("Target") || "" });
+    }
+    const headerSpec = getPartSpec("header");
+    const footerSpec = getPartSpec("footer");
+    const overrideTypeByPart = new Map(Array.from(ctDoc.getElementsByTagNameNS("*", "Override")).map((override) => [(override.getAttribute("PartName") || "").toLowerCase(), override.getAttribute("ContentType") || ""]));
+    for (const reference of [
+      ...Array.from(documentDoc.getElementsByTagNameNS(NS_W7, "headerReference")),
+      ...Array.from(documentDoc.getElementsByTagNameNS(NS_W7, "footerReference"))
+    ]) {
+      const relId = reference.getAttributeNS?.("http://schemas.openxmlformats.org/officeDocument/2006/relationships", "id") || reference.getAttribute("r:id") || "";
+      const spec = reference.localName === "headerReference" ? headerSpec : footerSpec;
+      const relationship = relationshipById.get(relId);
+      if (!relationship) throw new Error(`Validation failed: ${reference.localName} ${relId || "(no r:id)"} has no document relationship`);
+      if (relationship.type !== spec.relType) throw new Error(`Validation failed: ${reference.localName} ${relId} points at a relationship of the wrong type (${relationship.type})`);
+      const partName = relationship.target.startsWith("/") ? relationship.target : `/word/${relationship.target}`;
+      const partXml = await readZipText(zip, partName.slice(1));
+      if (!partXml) throw new Error(`Validation failed: ${reference.localName} ${relId} targets a missing part: ${partName}`);
+      parseXmlStrictStandalone(partXml, partName.slice(1));
+      const contentType = overrideTypeByPart.get(partName.toLowerCase());
+      if (contentType !== spec.contentType) throw new Error(`Validation failed: ${partName} content type is ${contentType ? `'${contentType}'` : "missing"}; Word expects '${spec.contentType}'`);
+    }
+  }
   if (commentsExtendedXml) {
-    const hasContentType = Array.from(ctDoc.getElementsByTagNameNS("*", "Override")).some(
-      (override) => (override.getAttribute("PartName") || "").toLowerCase() === "/word/commentsextended.xml" && (override.getAttribute("ContentType") || "") === COMMENTS_EXTENDED_CONTENT_TYPE
+    const extendedOverride = Array.from(ctDoc.getElementsByTagNameNS("*", "Override")).find(
+      (override) => (override.getAttribute("PartName") || "").toLowerCase() === "/word/commentsextended.xml"
     );
+    if (extendedOverride && extendedOverride.getAttribute("ContentType") !== COMMENTS_EXTENDED_CONTENT_TYPE) {
+      throw new Error(`Validation failed: commentsExtended CT override has wrong content type '${extendedOverride.getAttribute("ContentType")}' (Word expects '${COMMENTS_EXTENDED_CONTENT_TYPE}')`);
+    }
+    const hasContentType = !!extendedOverride;
     const hasRelationship = Array.from(relsDoc.getElementsByTagNameNS("*", "Relationship")).some(
       (rel) => (rel.getAttribute("Type") || "") === COMMENTS_EXTENDED_REL_TYPE
     );
@@ -20464,6 +20906,156 @@ function reconcileReceiptsAgainstOutput(parts, receipts) {
   return { valid: true };
 }
 
+// services/headers-footers.js
+var NS_W8 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+var NS_R2 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+var REVISION_ELEMENTS = /* @__PURE__ */ new Set(["ins", "del", "moveFrom", "moveTo", "rPrChange", "pPrChange", "sectPrChange", "tblPrChange", "tblGridChange", "tcPrChange", "trPrChange", "numberingChange"]);
+var REVISION_CONTENT_ELEMENTS = /* @__PURE__ */ new Set(["ins", "del", "moveFrom", "moveTo"]);
+var attrOf2 = (node, qualified, local) => node?.getAttribute?.(qualified) || node?.getAttribute?.(local) || "";
+function resolveTarget(target) {
+  const clean = String(target || "");
+  if (clean.startsWith("/")) return clean.replace(/^\/+/, "");
+  const parts = ["word"];
+  for (const segment of clean.split("/")) {
+    if (segment === "..") parts.pop();
+    else if (segment && segment !== ".") parts.push(segment);
+  }
+  return parts.join("/");
+}
+function discoverHeaderFooterParts({ documentXml, relsXml = null, settingsXml = null }) {
+  if (!documentXml || !relsXml) return [];
+  const documentParsed = parseOoxmlSafe(documentXml, "application/xml");
+  const relsParsed = parseOoxmlSafe(relsXml, "application/xml");
+  if (!documentParsed.doc || documentParsed.error || !relsParsed.doc || relsParsed.error) return [];
+  const targetByRelId = /* @__PURE__ */ new Map();
+  for (const rel of Array.from(relsParsed.doc.getElementsByTagNameNS("*", "Relationship"))) {
+    targetByRelId.set(rel.getAttribute("Id") || "", rel.getAttribute("Target") || "");
+  }
+  const evenAndOdd = !!settingsXml && /<w:evenAndOddHeaders\b(?![^>]*w:val="(?:0|false|off)")/.test(settingsXml);
+  const byPath = /* @__PURE__ */ new Map();
+  const inForce = /* @__PURE__ */ new Map();
+  const sectPrs = Array.from(documentParsed.doc.getElementsByTagNameNS(NS_W8, "sectPr"));
+  sectPrs.forEach((sectPr, sectionIndex) => {
+    const titlePg = Array.from(sectPr.childNodes || []).some((child) => child.localName === "titlePg" && !/^(0|false|off)$/i.test(attrOf2(child, "w:val", "val")));
+    for (const ref of Array.from(sectPr.childNodes || [])) {
+      if (ref.nodeType !== 1 || ref.localName !== "headerReference" && ref.localName !== "footerReference") continue;
+      const relId = ref.getAttributeNS?.(NS_R2, "id") || ref.getAttribute("r:id") || "";
+      const target = targetByRelId.get(relId);
+      if (!target) continue;
+      const path = resolveTarget(target);
+      const kind = ref.localName === "headerReference" ? "header" : "footer";
+      const type = attrOf2(ref, "w:type", "type") || "default";
+      const entry = byPath.get(path) || { path, kind, type, sections: [], applies: [], titlePgSections: 0 };
+      if (!entry.sections.includes(sectionIndex)) entry.sections.push(sectionIndex);
+      if (titlePg) entry.titlePgSections += 1;
+      byPath.set(path, entry);
+      inForce.set(`${kind}:${type}`, path);
+    }
+    for (const path of inForce.values()) {
+      const entry = byPath.get(path);
+      if (entry && !entry.applies.includes(sectionIndex)) entry.applies.push(sectionIndex);
+    }
+  });
+  return Array.from(byPath.values()).map((entry) => ({
+    path: entry.path,
+    kind: entry.kind,
+    type: entry.type,
+    sections: entry.sections,
+    appliesToSections: entry.applies,
+    sharedBySections: entry.applies.length > 1,
+    // first-page parts only show with w:titlePg; even parts only with w:evenAndOddHeaders in settings.xml.
+    active: entry.type === "first" ? entry.titlePgSections > 0 : entry.type === "even" ? evenAndOdd : true
+  }));
+}
+function resolvePartSelector(parts, selector) {
+  const describe = (part) => ({ path: part.path, kind: part.kind, type: part.type, sections: part.sections, appliesToSections: part.appliesToSections });
+  if (typeof selector === "string") {
+    const wanted = selector.replace(/^\/+/, "").toLowerCase();
+    const match = parts.find((part) => part.path.toLowerCase() === wanted || part.path.toLowerCase() === `word/${wanted}`);
+    if (match) return { part: match };
+    return { error: { code: "PART_NOT_FOUND", message: `No header/footer part '${selector}' is referenced by the document.`, candidates: parts.map(describe) } };
+  }
+  if (!selector || typeof selector !== "object" || selector.kind !== "header" && selector.kind !== "footer") {
+    return { error: { code: "INVALID_OPERATION", message: 'part must be a part path or { kind: "header"|"footer", type?: "default"|"first"|"even", section?: number }.' } };
+  }
+  const type = selector.type || "default";
+  if (!["default", "first", "even"].includes(type)) {
+    return { error: { code: "INVALID_OPERATION", message: `part.type must be default, first or even (got '${type}').` } };
+  }
+  let matches = parts.filter((part) => part.kind === selector.kind && part.type === type);
+  if (Number.isInteger(selector.section)) matches = matches.filter((part) => part.appliesToSections.includes(selector.section));
+  if (matches.length === 1) return { part: matches[0] };
+  if (matches.length === 0) {
+    return { error: { code: "PART_NOT_FOUND", message: `The document has no ${type} ${selector.kind}${Number.isInteger(selector.section) ? ` for section ${selector.section}` : ""}.`, candidates: parts.map(describe) } };
+  }
+  return { error: { code: "PART_AMBIGUOUS", message: `Several ${type} ${selector.kind} parts exist; add "section" or use the part path.`, candidates: matches.map(describe) } };
+}
+function isHeaderFooterPath(path) {
+  const spec = findPartSpecByPartName(path);
+  return spec?.id === "header" || spec?.id === "footer";
+}
+function countRevisionsInsideFields(xml) {
+  const parsed = parseOoxmlSafe(xml, "application/xml");
+  if (!parsed.doc || parsed.error) return 0;
+  let depth = 0;
+  let count = 0;
+  const visit = (node) => {
+    for (const child of Array.from(node.childNodes || [])) {
+      if (child.nodeType !== 1) continue;
+      const name = child.localName;
+      if (name === "fldChar") {
+        const type = attrOf2(child, "w:fldCharType", "fldCharType");
+        if (type === "begin") depth += 1;
+        else if (type === "end") depth = Math.max(0, depth - 1);
+        continue;
+      }
+      if (REVISION_CONTENT_ELEMENTS.has(name) && depth > 0) count += 1;
+      if (name === "fldSimple") {
+        depth += 1;
+        visit(child);
+        depth -= 1;
+        continue;
+      }
+      visit(child);
+    }
+  };
+  visit(parsed.doc.documentElement);
+  return count;
+}
+function collectRevisionIds(xml) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const match of String(xml || "").matchAll(/<w:(?:ins|del|moveFrom|moveTo|rPrChange|pPrChange|sectPrChange|tblPrChange|tblGridChange|tcPrChange|trPrChange|numberingChange)\b[^>]*?\bw:id="(\d+)"/g)) ids.add(match[1]);
+  return ids;
+}
+function renumberCollidingRevisionIds(xml, taken) {
+  const parsed = parseOoxmlSafe(xml, "application/xml");
+  if (!parsed.doc || parsed.error) return { xml, renumbered: 0, idMap: /* @__PURE__ */ new Map() };
+  const idMap = /* @__PURE__ */ new Map();
+  let next = 1 + Math.max(0, ...Array.from(taken, (id) => Number(id)).filter(Number.isFinite));
+  const used = new Set(taken);
+  let renumbered = 0;
+  const visit = (node) => {
+    for (const child of Array.from(node.childNodes || [])) {
+      if (child.nodeType !== 1) continue;
+      if (REVISION_ELEMENTS.has(child.localName)) {
+        const id = attrOf2(child, "w:id", "id");
+        if (id && used.has(id)) {
+          while (used.has(String(next))) next += 1;
+          child.setAttributeNS(NS_W8, "w:id", String(next));
+          idMap.set(id, String(next));
+          used.add(String(next));
+          renumbered += 1;
+        } else if (id) {
+          used.add(id);
+        }
+      }
+      visit(child);
+    }
+  };
+  visit(parsed.doc.documentElement);
+  return renumbered > 0 ? { xml: createSerializer().serializeToString(parsed.doc), renumbered, idMap } : { xml, renumbered: 0, idMap };
+}
+
 // services/error-recovery.js
 var ERROR_RECOVERY_VERSION = 1;
 var RULES = Object.freeze({
@@ -20501,6 +21093,12 @@ var RULES = Object.freeze({
   STRUCTURED_CONTENT_INVALID: ["request", "request_fixable", "change_request"],
   UNSUPPORTED_INSERTION_AFFINITY: ["request", "request_fixable", "change_request"],
   EXISTING_REVISIONS: ["target-safety", "policy_choice_required", "set_option"],
+  PART_NOT_FOUND: ["target-resolution", "target_refresh_required", "reinspect"],
+  PART_AMBIGUOUS: ["target-resolution", "candidate_selection_required", "choose_candidate"],
+  COMMENT_IN_HEADER_FOOTER: ["request", "request_fixable", "change_request"],
+  FIELD_EDIT_REFUSED: ["target-safety", "request_fixable", "change_request"],
+  COMMENT_NOT_FOUND: ["target-resolution", "target_refresh_required", "reinspect"],
+  PARENT_ANCHOR_NOT_FOUND: ["target-resolution", "target_refresh_required", "reinspect"],
   COMMENTED_CONTENT_MERGE: ["target-safety", "user_authorization_required", "resolve_comments"],
   COMMENTED_CONTENT_DELETE: ["target-safety", "user_authorization_required", "resolve_comments"],
   OVERLAPPING_SOURCE_TARGETS: ["batch-compilation", "source_conflict", "consolidate_operations"],
@@ -20953,6 +21551,7 @@ var SUPPORTED_OPERATION_TYPES = /* @__PURE__ */ new Set([
   "delete",
   "comment",
   "comment_reply",
+  "comment_resolve",
   "highlight"
 ]);
 var EXISTING_REVISIONS_POLICIES = Object.freeze([
@@ -20971,11 +21570,14 @@ function isRecord(value) {
 function nonEmptyString(value) {
   return typeof value === "string" && value.trim().length > 0;
 }
+function isCommentThreadOperationKind(kind) {
+  return kind === "comment_reply" || kind === "comment_resolve";
+}
 function getCanonicalOperationType(operation) {
   const type = operation?.type;
   if (type === "insert" && operation?.target?.revisionView === "rejected") return "rejected-insert";
   if (type === "restore") return "restore";
-  if (type === "comment" || type === "comment_reply" || type === "highlight") return type;
+  if (type === "comment" || type === "comment_reply" || type === "comment_resolve" || type === "highlight") return type;
   if (type === "paragraph-format") return "paragraph-format";
   if (type === "character-format" || type === "format" && (operation?.textToFormat != null || operation?.properties != null)) return "format";
   return "redline";
@@ -21095,7 +21697,7 @@ function validateDocumentOperation(operation) {
     };
   }
   const target = normalized.targetDescriptor;
-  if (normalized.operationKind !== "comment_reply" && !nonEmptyString(target.text) && target.index == null && !target.paragraphId && !target.fingerprint && !target.captureRef) {
+  if (!isCommentThreadOperationKind(normalized.operationKind) && !nonEmptyString(target.text) && target.index == null && !target.paragraphId && !target.fingerprint && !target.captureRef) {
     return {
       valid: false,
       error: {
@@ -21322,6 +21924,14 @@ function validateDocumentOperation(operation) {
       return { valid: false, error: { code: "INVALID_OPERATION", message: 'Comment reply operations require a non-empty "commentContent" field.' } };
     }
   }
+  if (normalized.operationKind === "comment_resolve") {
+    if (!nonEmptyString(String(normalized.commentId ?? ""))) {
+      return { valid: false, error: { code: "INVALID_OPERATION", message: 'Comment resolve operations require a "commentId".' } };
+    }
+    if (normalized.resolved != null && typeof normalized.resolved !== "boolean") {
+      return { valid: false, error: { code: "INVALID_OPERATION", message: 'Comment resolve "resolved" must be a boolean when provided.' } };
+    }
+  }
   if (normalized.operationKind === "highlight") {
     if (!nonEmptyString(normalized.textToHighlight)) {
       return {
@@ -21801,7 +22411,7 @@ function compileOperationBatch(xmlDoc, operations = [], options = {}) {
     const dynamicOccurrence = operation.targetDescriptor?.occurrence != null && !operation.targetDescriptor?.paragraphId && !operation.targetDescriptor?.fingerprint;
     const compositeTextTarget = typeof operation.targetDescriptor?.text === "string" && /\r|\n/.test(operation.targetDescriptor.text) && !operation.targetEndDescriptor;
     if (dynamicOccurrence || compositeTextTarget) binding.dynamic = true;
-    if (validation.valid && operation.operationKind !== "comment_reply" && !operation.targetDescriptor?.captureRef && !binding.dynamic) {
+    if (validation.valid && operation.operationKind !== "comment_reply" && operation.operationKind !== "comment_resolve" && !operation.targetDescriptor?.captureRef && !binding.dynamic) {
       try {
         const start = resolveDescriptor(
           xmlDoc,
@@ -22302,12 +22912,12 @@ function resolveTargetFromCapture(xmlDoc, session, targetDescriptor, _opType = "
 }
 
 // services/document-operation-mutations.js
-var NS_W8 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+var NS_W9 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
 var NS_W142 = "http://schemas.microsoft.com/office/word/2010/wordml";
 function getCommentIdsInElement(element) {
   const ids = /* @__PURE__ */ new Set();
   for (const localName2 of ["commentRangeStart", "commentRangeEnd", "commentReference"]) {
-    for (const node of Array.from(element?.getElementsByTagNameNS?.(NS_W8, localName2) || [])) {
+    for (const node of Array.from(element?.getElementsByTagNameNS?.(NS_W9, localName2) || [])) {
       const id = node.getAttribute("w:id") || node.getAttribute("id");
       if (id !== "") ids.add(id);
     }
@@ -22521,7 +23131,7 @@ function normalizeBodySectionOrder(xmlDoc) {
   normalizeBodySectionOrderStandalone(xmlDoc);
 }
 function removeProofErrNodes(paragraph) {
-  for (const node of Array.from(paragraph?.getElementsByTagNameNS?.(NS_W8, "proofErr") || [])) {
+  for (const node of Array.from(paragraph?.getElementsByTagNameNS?.(NS_W9, "proofErr") || [])) {
     node.parentNode?.removeChild(node);
   }
 }
@@ -22532,12 +23142,12 @@ function preprocessRedlineTargetParagraph(targetParagraph) {
 function getDirectWordChild4(element, localName2) {
   if (!element) return null;
   return Array.from(element.childNodes || []).find(
-    (node) => node && node.nodeType === 1 && node.namespaceURI === NS_W8 && node.localName === localName2
+    (node) => node && node.nodeType === 1 && node.namespaceURI === NS_W9 && node.localName === localName2
   ) || null;
 }
 function computeTableIndexInDocument(xmlDoc, tableElement) {
   if (!xmlDoc || !tableElement) return null;
-  const tables = Array.from(xmlDoc.getElementsByTagNameNS(NS_W8, "tbl"));
+  const tables = Array.from(xmlDoc.getElementsByTagNameNS(NS_W9, "tbl"));
   const idx = tables.indexOf(tableElement);
   return idx >= 0 ? idx + 1 : null;
 }
@@ -22587,7 +23197,7 @@ function buildInsertedListParagraph(xmlDoc, anchorParagraph, entry, revisionMeta
     markParagraphMarkInserted(xmlDoc, paragraph, author);
   }
   const run = createWordElement(xmlDoc, "w:r");
-  const anchorFirstRun = Array.from(anchorParagraph.getElementsByTagNameNS(NS_W8, "r"))[0] || null;
+  const anchorFirstRun = Array.from(anchorParagraph.getElementsByTagNameNS(NS_W9, "r"))[0] || null;
   const anchorRunPr = anchorFirstRun ? getDirectWordChild4(anchorFirstRun, "rPr") : null;
   if (anchorRunPr) {
     run.appendChild(clonePropertiesWithoutRevisionHistory(anchorRunPr));
@@ -22612,7 +23222,7 @@ function buildInsertedListParagraph(xmlDoc, anchorParagraph, entry, revisionMeta
 }
 function serializeParagraphRangeAsDocument(paragraphs, serializer) {
   const paragraphXml = (paragraphs || []).map((paragraph) => serializer.serializeToString(paragraph)).join("");
-  return `<w:document xmlns:w="${NS_W8}"><w:body>${paragraphXml}</w:body></w:document>`;
+  return `<w:document xmlns:w="${NS_W9}"><w:body>${paragraphXml}</w:body></w:document>`;
 }
 function applyExplicitRangeListInsertions({
   xmlDoc,
@@ -22681,7 +23291,7 @@ function buildEmptyParagraphTemplateFromAnchor(xmlDoc, anchorParagraph) {
   const anchorPPr = getDirectWordChild4(anchorParagraph, "pPr");
   if (anchorPPr) paragraph.appendChild(clonePropertiesWithoutRevisionHistory(anchorPPr));
   const run = createWordElement(xmlDoc, "w:r");
-  const anchorFirstRun = Array.from(anchorParagraph.getElementsByTagNameNS(NS_W8, "r"))[0] || null;
+  const anchorFirstRun = Array.from(anchorParagraph.getElementsByTagNameNS(NS_W9, "r"))[0] || null;
   const anchorRunPr = anchorFirstRun ? getDirectWordChild4(anchorFirstRun, "rPr") : null;
   if (anchorRunPr) run.appendChild(clonePropertiesWithoutRevisionHistory(anchorRunPr));
   const textNode = createWordElement(xmlDoc, "w:t");
@@ -22704,7 +23314,7 @@ function wrapParagraphContentInInsertion(xmlDoc, paragraph, revisionMetadata, au
   ins.setAttribute("w:author", metadata.author);
   ins.setAttribute("w:date", metadata.date);
   for (const child of Array.from(paragraph.childNodes || [])) {
-    if (child?.nodeType === 1 && child.namespaceURI === NS_W8 && child.localName === "pPr") continue;
+    if (child?.nodeType === 1 && child.namespaceURI === NS_W9 && child.localName === "pPr") continue;
     ins.appendChild(child.cloneNode(true));
   }
   wrappedParagraph.appendChild(ins);
@@ -22728,7 +23338,7 @@ async function buildInsertedPlainParagraph(xmlDoc, anchorParagraph, text2, revis
   if (typeof markdownResult?.oxml === "string") {
     const extracted = extractReplacementNodes(markdownResult.oxml);
     sourceParagraph = (extracted.replacementNodes || []).find(
-      (node) => node && node.nodeType === 1 && node.namespaceURI === NS_W8 && node.localName === "p"
+      (node) => node && node.nodeType === 1 && node.namespaceURI === NS_W9 && node.localName === "p"
     ) || null;
   }
   if (!sourceParagraph) {
@@ -22760,7 +23370,7 @@ function collectNumberingIdsFromNodes(nodes) {
 }
 function directDeletionCarrierText(carrier) {
   return Array.from(carrier?.childNodes || []).reduce((text2, child) => {
-    return text2 + (child?.nodeType === 1 && child.namespaceURI === NS_W8 && child.localName === "r" ? getRunContentPieces(child).map((piece) => piece.text).join("") : "");
+    return text2 + (child?.nodeType === 1 && child.namespaceURI === NS_W9 && child.localName === "r" ? getRunContentPieces(child).map((piece) => piece.text).join("") : "");
   }, "");
 }
 function findOccurrenceOffset(text2, needle, occurrence) {
@@ -22802,9 +23412,9 @@ function hasUnsupportedDeletionSplitMarkup(paragraph, carrier) {
   }
   for (const child of Array.from(carrier?.childNodes || [])) {
     if (child.nodeType !== 1) continue;
-    if (!(child.namespaceURI === NS_W8 && child.localName === "r")) return true;
+    if (!(child.namespaceURI === NS_W9 && child.localName === "r")) return true;
     for (const runChild of Array.from(child.childNodes || [])) {
-      if (runChild.nodeType !== 1 || runChild.namespaceURI !== NS_W8) continue;
+      if (runChild.nodeType !== 1 || runChild.namespaceURI !== NS_W9) continue;
       if (!["rPr", "delText", "t", "tab", "br", "cr", "noBreakHyphen", "softHyphen"].includes(runChild.localName)) return true;
     }
   }
@@ -22813,7 +23423,7 @@ function hasUnsupportedDeletionSplitMarkup(paragraph, carrier) {
 function insertedRunPropertiesAtDeletionOffset(carrier, localOffset) {
   let offset = 0;
   for (const child of Array.from(carrier?.childNodes || [])) {
-    if (!(child?.nodeType === 1 && child.namespaceURI === NS_W8 && child.localName === "r")) continue;
+    if (!(child?.nodeType === 1 && child.namespaceURI === NS_W9 && child.localName === "r")) continue;
     const length = getRunTextLength(getRunContentPieces(child));
     if (localOffset <= offset + length) {
       return clonePropertiesWithoutRevisionHistory(getDirectWordChild4(child, "rPr"));
@@ -22843,7 +23453,7 @@ function normalizedAuthor2(author) {
 function directWordParagraphSibling(paragraph, direction = "nextSibling") {
   let cursor = paragraph?.[direction] || null;
   while (cursor) {
-    if (cursor.nodeType === 1 && cursor.namespaceURI === NS_W8 && cursor.localName === "p") return cursor;
+    if (cursor.nodeType === 1 && cursor.namespaceURI === NS_W9 && cursor.localName === "p") return cursor;
     cursor = cursor[direction] || null;
   }
   return null;
@@ -22853,7 +23463,7 @@ function createSanitizedRestorationPPr(xmlDoc, sourceParagraph) {
   const pPr = createWordElement(xmlDoc, "w:pPr");
   if (!sourcePPr) return pPr;
   for (const child of Array.from(sourcePPr.childNodes || [])) {
-    if (child.nodeType !== 1 || child.namespaceURI !== NS_W8) continue;
+    if (child.nodeType !== 1 || child.namespaceURI !== NS_W9) continue;
     if (!RESTORATION_PPR_ALLOWLIST.has(child.localName)) continue;
     pPr.appendChild(xmlDoc.importNode(child, true));
   }
@@ -22862,14 +23472,14 @@ function createSanitizedRestorationPPr(xmlDoc, sourceParagraph) {
 function collectRestorationAnchorWarnings(sourceParagraph) {
   const warnings = [];
   const bookmarkNames = /* @__PURE__ */ new Set();
-  for (const node of Array.from(sourceParagraph?.getElementsByTagNameNS?.(NS_W8, "bookmarkStart") || [])) {
+  for (const node of Array.from(sourceParagraph?.getElementsByTagNameNS?.(NS_W9, "bookmarkStart") || [])) {
     const name = wordAttribute4(node, "name") || "(unnamed)";
     bookmarkNames.add(name);
   }
   for (const name of bookmarkNames) warnings.push(`RESTORATION_DROPPED_BOOKMARK:${name}`);
   const commentIds = /* @__PURE__ */ new Set();
   for (const localName2 of ["commentRangeStart", "commentRangeEnd", "commentReference"]) {
-    for (const node of Array.from(sourceParagraph?.getElementsByTagNameNS?.(NS_W8, localName2) || [])) {
+    for (const node of Array.from(sourceParagraph?.getElementsByTagNameNS?.(NS_W9, localName2) || [])) {
       const id = wordAttribute4(node, "id");
       if (id !== "") commentIds.add(id);
     }
@@ -22886,24 +23496,24 @@ function removeRestorationAnchors(paragraph) {
     "commentReference"
   ];
   for (const localName2 of anchorNames) {
-    for (const node of Array.from(paragraph?.getElementsByTagNameNS?.(NS_W8, localName2) || [])) {
+    for (const node of Array.from(paragraph?.getElementsByTagNameNS?.(NS_W9, localName2) || [])) {
       node.parentNode?.removeChild(node);
     }
   }
-  for (const run of Array.from(paragraph?.getElementsByTagNameNS?.(NS_W8, "r") || [])) {
-    const meaningful = Array.from(run.childNodes || []).some((child) => child.nodeType === 1 && child.namespaceURI === NS_W8 && child.localName !== "rPr");
+  for (const run of Array.from(paragraph?.getElementsByTagNameNS?.(NS_W9, "r") || [])) {
+    const meaningful = Array.from(run.childNodes || []).some((child) => child.nodeType === 1 && child.namespaceURI === NS_W9 && child.localName !== "rPr");
     if (!meaningful) run.parentNode?.removeChild(run);
   }
 }
 function buildRejectedRestorationTemplate(xmlDoc, sourceParagraph, serializer) {
   const rejected = rejectTrackedChangesInOoxml(serializer.serializeToString(sourceParagraph), { allAuthors: true });
   const parsed = parseOoxmlSafe(rejected.oxml, "application/xml");
-  const rejectedParagraph = parsed.doc?.getElementsByTagNameNS?.(NS_W8, "p")?.[0] || null;
+  const rejectedParagraph = parsed.doc?.getElementsByTagNameNS?.(NS_W9, "p")?.[0] || null;
   if (!rejectedParagraph) return null;
   const paragraph = createWordElement(xmlDoc, "w:p");
   paragraph.appendChild(createSanitizedRestorationPPr(xmlDoc, sourceParagraph));
   for (const child of Array.from(rejectedParagraph.childNodes || [])) {
-    if (child.nodeType === 1 && child.namespaceURI === NS_W8 && child.localName === "pPr") continue;
+    if (child.nodeType === 1 && child.namespaceURI === NS_W9 && child.localName === "pPr") continue;
     paragraph.appendChild(xmlDoc.importNode(child, true));
   }
   removeRestorationAnchors(paragraph);
@@ -22924,7 +23534,7 @@ async function editRestorationTemplate(xmlDoc, template, modifiedText, author, s
   );
   if (result?.status === "error" || typeof result?.oxml !== "string") return null;
   const extracted = extractReplacementNodes(result.oxml);
-  const paragraph = (extracted.replacementNodes || []).find((node) => node?.nodeType === 1 && node.namespaceURI === NS_W8 && node.localName === "p");
+  const paragraph = (extracted.replacementNodes || []).find((node) => node?.nodeType === 1 && node.namespaceURI === NS_W9 && node.localName === "p");
   return paragraph ? xmlDoc.importNode(paragraph, true) : null;
 }
 function allocateFreshParagraphId(xmlDoc, operationSession) {
@@ -23095,7 +23705,7 @@ async function insertIntoRejectedDeletedText(documentXml, targetText, anchor, mo
   }
   const insertionOffset = anchorStart + anchor.offset;
   const carriers = Array.from(paragraph.childNodes || []).filter(
-    (node) => node?.nodeType === 1 && node.namespaceURI === NS_W8 && node.localName === "del"
+    (node) => node?.nodeType === 1 && node.namespaceURI === NS_W9 && node.localName === "del"
   );
   if (carriers.some((carrier) => hasUnsupportedDeletionSplitMarkup(paragraph, carrier))) {
     return {
@@ -23752,7 +24362,7 @@ async function applyToParagraphByExactText(documentXml, targetText, modifiedText
         };
       }
       if (!allSame) {
-        const hasMove = targetParagraph.getElementsByTagNameNS(NS_W8, "moveFrom").length > 0 || targetParagraph.getElementsByTagNameNS(NS_W8, "moveTo").length > 0;
+        const hasMove = targetParagraph.getElementsByTagNameNS(NS_W9, "moveFrom").length > 0 || targetParagraph.getElementsByTagNameNS(NS_W9, "moveTo").length > 0;
         if (hasMove) {
           return {
             documentXml,
@@ -23767,8 +24377,8 @@ async function applyToParagraphByExactText(documentXml, targetText, modifiedText
         }
       }
     } else {
-      const hasDel = targetParagraph.getElementsByTagNameNS(NS_W8, "del").length > 0;
-      const hasMove = targetParagraph.getElementsByTagNameNS(NS_W8, "moveFrom").length > 0 || targetParagraph.getElementsByTagNameNS(NS_W8, "moveTo").length > 0;
+      const hasDel = targetParagraph.getElementsByTagNameNS(NS_W9, "del").length > 0;
+      const hasMove = targetParagraph.getElementsByTagNameNS(NS_W9, "moveFrom").length > 0 || targetParagraph.getElementsByTagNameNS(NS_W9, "moveTo").length > 0;
       if (hasDel) {
         return {
           documentXml,
@@ -24287,7 +24897,7 @@ async function applyFormattingToParagraphByExactText(documentXml, targetText, te
   const targetParagraph = resolved.paragraph;
   const collectVisibleRuns = () => {
     const runEntries2 = [];
-    const allRuns = Array.from(targetParagraph.getElementsByTagNameNS(NS_W8, "r"));
+    const allRuns = Array.from(targetParagraph.getElementsByTagNameNS(NS_W9, "r"));
     for (const run of allRuns) {
       let parent = run.parentNode;
       let isDel = false;
@@ -24379,7 +24989,7 @@ async function applyFormattingToParagraphByExactText(documentXml, targetText, te
   const targetRuns = finalRuns.filter((span) => span.start >= matchStart && span.end <= matchEnd);
   let anyChanged = false;
   for (const entry of targetRuns) {
-    const rPr = entry.run.getElementsByTagNameNS(NS_W8, "rPr")[0] || null;
+    const rPr = entry.run.getElementsByTagNameNS(NS_W9, "rPr")[0] || null;
     if (checkRunPropertiesChanged(rPr, properties)) {
       anyChanged = true;
       break;
@@ -24390,7 +25000,7 @@ async function applyFormattingToParagraphByExactText(documentXml, targetText, te
   }
   for (const entry of targetRuns) {
     const run = entry.run;
-    let rPr = run.getElementsByTagNameNS(NS_W8, "rPr")[0];
+    let rPr = run.getElementsByTagNameNS(NS_W9, "rPr")[0];
     if (!rPr) {
       rPr = createWordElement(xmlDoc, "w:rPr");
       run.insertBefore(rPr, run.firstChild);
@@ -24399,7 +25009,7 @@ async function applyFormattingToParagraphByExactText(documentXml, targetText, te
     let insideSameAuthorIns = false;
     while (insAncestor && insAncestor !== targetParagraph) {
       if (insAncestor.nodeType === 1 && (insAncestor.localName === "ins" || insAncestor.nodeName === "w:ins")) {
-        const insAuthor = insAncestor.getAttribute("w:author") || insAncestor.getAttributeNS(NS_W8, "author");
+        const insAuthor = insAncestor.getAttribute("w:author") || insAncestor.getAttributeNS(NS_W9, "author");
         if (insAuthor === (author || getDefaultAuthor())) {
           insideSameAuthorIns = true;
         }
@@ -24447,7 +25057,7 @@ async function applyParagraphFormatToParagraphByExactText(documentXml, targetTex
     return { documentXml, hasChanges: false, status: "error", error: resolved?.error || { code: "TARGET_NOT_FOUND", message: "Target paragraph not found." } };
   }
   const targetParagraph = resolved.paragraph;
-  let pPr = targetParagraph.getElementsByTagNameNS(NS_W8, "pPr")[0];
+  let pPr = targetParagraph.getElementsByTagNameNS(NS_W9, "pPr")[0];
   if (!pPr) {
     pPr = createWordElement(xmlDoc, "w:pPr");
     targetParagraph.insertBefore(pPr, targetParagraph.firstChild);
@@ -24495,7 +25105,7 @@ async function applyOperationToDocumentXml(documentXml, op, author, runtimeConte
   }
   let operation = validation.operation || normalizeDocumentOperation(op);
   const authorUsed = resolveDocumentOperationAuthor(operation, author, getDefaultAuthor());
-  if (operation.operationKind !== "comment_reply" && operation.operationKind !== "rejected-insert" && operation.operationKind !== "restore" && (operation.targetDescriptor?.revisionView === "rejected" || operation.targetEndDescriptor?.revisionView === "rejected")) {
+  if (operation.operationKind !== "comment_reply" && operation.operationKind !== "comment_resolve" && operation.operationKind !== "rejected-insert" && operation.operationKind !== "restore" && (operation.targetDescriptor?.revisionView === "rejected" || operation.targetEndDescriptor?.revisionView === "rejected")) {
     return {
       documentXml,
       hasChanges: false,
@@ -24662,6 +25272,7 @@ async function applyOperationToDocumentXml(documentXml, op, author, runtimeConte
         result = applyCommentReplyToParts({
           commentsXml: existingCommentsXml,
           commentsExtendedXml: existingExtendedXml,
+          documentXml,
           parentCommentId: operation.parentCommentId,
           commentId,
           commentContent: operation.commentContent,
@@ -24669,8 +25280,30 @@ async function applyOperationToDocumentXml(documentXml, op, author, runtimeConte
           date: operation.date || (/* @__PURE__ */ new Date()).toISOString()
         });
         result.documentXml = documentXml;
-        if (result.hasChanges && session.receiptCollector) session.receiptCollector.recordComment(commentId);
+        if (result.status !== "error" && result.hasChanges) {
+          if (!session.document || !anchorReplyInDocument(session.document, result.threadCommentIds, commentId)) {
+            result = { documentXml, hasChanges: false, status: "error", error: { code: "PARENT_ANCHOR_NOT_FOUND", message: `Comment '${operation.parentCommentId}' has no anchor in the document body, so a reply cannot be placed.` } };
+          } else if (session.receiptCollector) {
+            session.receiptCollector.recordComment(commentId);
+          }
+        }
       }
+    } else if (operation.operationKind === "comment_resolve") {
+      const resolution = applyThreadResolutionToParts({
+        commentsXml: session.commentsXml || runtimeContext?.commentsXml || options.commentsXml,
+        commentsExtendedXml: session.commentsExtendedXml || runtimeContext?.commentsExtendedXml || options.commentsExtendedXml,
+        commentId: operation.commentId,
+        resolved: operation.resolved !== false
+      });
+      result = resolution.status === "error" ? { documentXml, hasChanges: false, status: "error", error: resolution.error } : {
+        documentXml,
+        hasChanges: resolution.hasChanges,
+        ...resolution.commentsXml ? { commentsXml: resolution.commentsXml, commentsXmlMode: "replace" } : {},
+        ...resolution.commentsExtendedXml ? { commentsExtendedXml: resolution.commentsExtendedXml, commentsExtendedXmlMode: "replace" } : {},
+        resolved: resolution.resolved,
+        threadRootId: resolution.threadRootId,
+        commentIds: resolution.commentIds
+      };
     } else if (operation.operationKind === "highlight") {
       result = await applyHighlightToParagraphByExactText(
         documentXml,
@@ -24811,7 +25444,7 @@ async function applyOperationToDocumentXml(documentXml, op, author, runtimeConte
           ...resolutionCapture
         };
       }
-      session.markMutationCommitted(operation.operationKind !== "comment_reply");
+      session.markMutationCommitted(true);
       if (operation._compiledSourceId && session.sourceTargetRegistry) {
         session.sourceTargetRegistry.commitMutation(
           operation._compiledSourceId,
@@ -24924,9 +25557,9 @@ async function applyOperationToDocumentXml(documentXml, op, author, runtimeConte
 }
 
 // services/batch-operation-orchestrator.js
-var NS_W9 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+var NS_W10 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
 function operationTargetPriority(op) {
-  return op?.type === "comment" || op?.type === "comment_reply" ? 0 : 1;
+  return op?.type === "comment" || op?.type === "comment_reply" || op?.type === "comment_resolve" ? 0 : 1;
 }
 function buildOperationDependencyPlan(operations = []) {
   const list = Array.isArray(operations) ? operations : [];
@@ -25001,7 +25634,7 @@ function buildOperationDependencyPlan(operations = []) {
         inDegrees[i2]++;
       }
       const kind = normalizeDocumentOperation(op).operationKind;
-      if (kind !== "comment" && kind !== "comment_reply") {
+      if (kind !== "comment" && kind !== "comment_reply" && kind !== "comment_resolve") {
         if (!mutatingCaptureConsumers.has(ref)) mutatingCaptureConsumers.set(ref, []);
         mutatingCaptureConsumers.get(ref).push({
           index: i2,
@@ -25069,9 +25702,9 @@ function mergeCommentsXml(existingXml, incomingXml) {
   const serializer = createSerializer();
   const existingRoot = existingDoc.documentElement;
   const existingIds = new Set(
-    Array.from(existingDoc.getElementsByTagNameNS(NS_W9, "comment")).map((node) => node.getAttribute("w:id") || node.getAttribute("id")).filter(Boolean)
+    Array.from(existingDoc.getElementsByTagNameNS(NS_W10, "comment")).map((node) => node.getAttribute("w:id") || node.getAttribute("id")).filter(Boolean)
   );
-  for (const comment of Array.from(incomingDoc.getElementsByTagNameNS(NS_W9, "comment"))) {
+  for (const comment of Array.from(incomingDoc.getElementsByTagNameNS(NS_W10, "comment"))) {
     const id = comment.getAttribute("w:id") || comment.getAttribute("id");
     if (id && existingIds.has(id)) continue;
     existingRoot.appendChild(existingDoc.importNode(comment, true));
@@ -25232,7 +25865,7 @@ async function applyOperationsToDocumentXml(documentXml, operations, author, run
     context.targetRefSnapshot = session.initialTargetReferenceSnapshot;
   }
   session.runtimeContext = context;
-  if (sourceOperations.some((op) => op?.type === "comment_reply")) {
+  if (sourceOperations.some((op) => op?.type === "comment_reply" || op?.type === "comment_resolve")) {
     session.commentsXml = context.commentsXml || options.commentsXml || null;
     session.commentsExtendedXml = context.commentsExtendedXml || options.commentsExtendedXml || null;
     session.commentsXmlMode = "replace";
@@ -25305,6 +25938,7 @@ async function applyOperationsToDocumentXml(documentXml, operations, author, run
         ...result.resolvedTarget ? { resolvedTarget: result.resolvedTarget } : {},
         ...result.resolvedAnchor ? { resolvedAnchor: result.resolvedAnchor } : {},
         ...result.change ? { change: result.change } : {},
+        ...result.operationType === "comment_resolve" && !isError ? { resolved: result.resolved, threadRootId: result.threadRootId, commentIds: result.commentIds } : {},
         ...Array.isArray(result.warnings) && result.warnings.length > 0 ? { warnings: result.warnings } : {},
         ...result.error ? { error: result.error } : {},
         ...result.receipt ? { receipt: result.receipt } : {}
@@ -25581,6 +26215,26 @@ function preflightOperations(documentXml, operations, author, options = {}) {
     }
     commentsRequired = commentsRequired || operation.operationKind === "comment" || operation.operationKind === "comment_reply";
     numberingRequired = numberingRequired || operationNeedsNumbering(operation);
+    if (operation.operationKind === "comment_resolve") {
+      const commentId = String(operation.commentId);
+      results.push(options._existingCommentDetails?.[commentId] ? {
+        index: index + 1,
+        type: sourceOperation.type,
+        operationType: operation.operationKind,
+        status: "ready",
+        authorUsed,
+        resolvedBy: "comment_id",
+        commentId
+      } : {
+        index: index + 1,
+        type: sourceOperation.type,
+        operationType: operation.operationKind,
+        status: "error",
+        authorUsed,
+        error: { code: "COMMENT_NOT_FOUND", message: `Comment '${commentId}' was not found.` }
+      });
+      continue;
+    }
     if (operation.operationKind === "comment_reply") {
       const parentId = String(operation.parentCommentId);
       const parent = options._existingCommentDetails?.[parentId];
@@ -26732,6 +27386,15 @@ var text = (entries, path) => {
   if (typeof entry === "string") return entry;
   return textDecoder2.decode(entry);
 };
+function reconcileCommentSiblings(working) {
+  const updated = reconcileCommentSiblingParts({
+    commentsXml: text(working, "word/comments.xml"),
+    commentsIdsXml: text(working, "word/commentsIds.xml"),
+    commentsExtensibleXml: text(working, "word/commentsExtensible.xml")
+  });
+  if (updated.commentsIdsXml) working.set("word/commentsIds.xml", textEncoder4.encode(updated.commentsIdsXml));
+  if (updated.commentsExtensibleXml) working.set("word/commentsExtensible.xml", textEncoder4.encode(updated.commentsExtensibleXml));
+}
 var cloneEntries = (entries) => new Map([...entries].map(([name, data]) => [name, new Uint8Array(data)]));
 function toBufferCompatible(uint8Arr) {
   if (typeof Buffer !== "undefined" && typeof Buffer.from === "function") {
@@ -26799,6 +27462,7 @@ function computePackageRevisionToken(input) {
     entries
   });
 }
+var COMMENT_OPERATION_TYPES = /* @__PURE__ */ new Set(["comment", "comment_reply", "comment_resolve"]);
 function nextCommentId(entries) {
   const ids = `${text(entries, "word/document.xml") || ""} ${text(entries, "word/comments.xml") || ""}`.match(/(?:w:)?id=["'](\d+)["']/g) || [];
   let next = ids.reduce((max2, token) => Math.max(max2, Number(token.match(/\d+/)?.[0] || 0)), 0) + 1;
@@ -26817,7 +27481,7 @@ function existingCommentDetails(entries) {
       id,
       author: comment.getAttribute("w:author") || comment.getAttribute("author") || "",
       text: String(comment.textContent || "").trim(),
-      paraId: Array.from(comment.getElementsByTagNameNS("*", "p"))[0]?.getAttribute("w14:paraId") || null
+      paraId: commentParaId(comment) || null
     };
   }
   return details;
@@ -26848,13 +27512,34 @@ var DocxDocument = class {
   }
   inspect(options = {}) {
     const digestFn = options.digestFn || ((bytes) => sha256(bytes));
-    return inspectDocumentParts({
+    const inspection = inspectDocumentParts({
       documentXml: text(this.entries, "word/document.xml"),
       commentsXml: text(this.entries, "word/comments.xml"),
       commentsExtendedXml: text(this.entries, "word/commentsExtended.xml"),
       numberingXml: text(this.entries, "word/numbering.xml"),
       stylesXml: text(this.entries, "word/styles.xml")
     }, { ...options, digestFn });
+    if (inspection.status === "error") return inspection;
+    return { ...inspection, headersFooters: this.inspectHeadersFooters() };
+  }
+  /**
+   * Header and footer parts the document uses, with their paragraph text, so operations can target them with
+   * `part`. `hasFields` marks parts containing PAGE/NUMPAGES-style fields (edit around them, not inside).
+   */
+  inspectHeadersFooters() {
+    return discoverHeaderFooterParts({
+      documentXml: text(this.entries, "word/document.xml"),
+      relsXml: text(this.entries, "word/_rels/document.xml.rels"),
+      settingsXml: text(this.entries, "word/settings.xml")
+    }).map((part) => {
+      const xml = text(this.entries, part.path) || "";
+      const partInspection = xml ? inspectDocumentParts({ documentXml: xml }) : { paragraphs: [] };
+      return {
+        ...part,
+        hasFields: /<w:fldChar\b|<w:fldSimple\b/.test(xml),
+        paragraphs: (partInspection.paragraphs || []).map((paragraph) => ({ index: paragraph.index, text: paragraph.text }))
+      };
+    });
   }
   getRevisionToken() {
     return computePackageRevisionToken(this.entries);
@@ -26863,12 +27548,51 @@ var DocxDocument = class {
     return this.getRevisionToken();
   }
   preflight(operations, author = getDefaultAuthor(), options = {}) {
-    return preflightOperations(
+    const list = Array.isArray(operations) ? operations : [];
+    const runBody = (ops) => preflightOperations(
       text(this.entries, "word/document.xml"),
-      operations,
+      ops,
       author || getDefaultAuthor(),
       { ...options, _existingCommentDetails: existingCommentDetails(this.entries) }
     );
+    if (!list.some((operation) => operation && typeof operation === "object" && operation.part != null)) return runBody(operations);
+    const parts = this.inspectHeadersFooters();
+    const bodyOps = [];
+    const results = [];
+    const conflicts = [];
+    const authorsUsed = /* @__PURE__ */ new Set();
+    let valid = true;
+    list.forEach((operation, i2) => {
+      if (!operation || typeof operation !== "object" || operation.part == null) {
+        bodyOps.push({ operation, origIndex: i2 });
+        return;
+      }
+      const resolved = resolvePartSelector(parts, operation.part);
+      const refusal = COMMENT_OPERATION_TYPES.has(operation.type) ? { code: "COMMENT_IN_HEADER_FOOTER", message: "Word does not support comments in headers or footers." } : resolved.error;
+      if (refusal) {
+        valid = false;
+        results.push({ index: i2 + 1, type: operation.type || "redline", status: "error", error: normalizeErrorWithRecovery({ ...refusal, operationIndex: i2 + 1 }) });
+        return;
+      }
+      const { part: _selector, ...rest } = operation;
+      const partResult = preflightOperations(text(this.entries, resolved.part.path), [rest], author || getDefaultAuthor(), { ...options, _existingCommentDetails: {} });
+      valid = valid && partResult.valid;
+      for (const result of partResult.results || []) results.push({ ...result, index: i2 + 1, part: resolved.part.path });
+      conflicts.push(...partResult.conflicts || []);
+      for (const name of partResult.authorsUsed || []) authorsUsed.add(name);
+    });
+    let requiredArtifacts = { comments: false, numbering: false };
+    if (bodyOps.length) {
+      const body = runBody(bodyOps.map((item) => item.operation));
+      valid = valid && body.valid;
+      for (const result of body.results || []) results.push({ ...result, index: bodyOps[result.index - 1].origIndex + 1 });
+      conflicts.push(...body.conflicts || []);
+      for (const name of body.authorsUsed || []) authorsUsed.add(name);
+      requiredArtifacts = body.requiredArtifacts || requiredArtifacts;
+    }
+    results.sort((a, b) => a.index - b.index);
+    const ok = valid && conflicts.length === 0;
+    return { valid: ok, status: ok ? "ok" : "error", results, conflicts, authorsUsed: [...authorsUsed], requiredArtifacts };
   }
   toUint8Array() {
     return zipDocx(this.entries);
@@ -26876,7 +27600,240 @@ var DocxDocument = class {
   toBuffer() {
     return toBufferCompatible(this.toUint8Array());
   }
+  /**
+   * Applies operations to the document. Operations without `part` target the body (word/document.xml).
+   * An operation with `part` targets one header or footer part:
+   * `{ part: { kind: 'footer', type: 'default', section: 0 } | 'word/footer2.xml', target: { exactText }, ... }`.
+   * Discover parts with `inspect().headersFooters`.
+   */
   async applyOperations(operations, options = {}) {
+    const list = Array.isArray(operations) ? operations : [];
+    if (!list.some((operation) => operation && typeof operation === "object" && operation.part != null)) {
+      return this.applyBodyOperations(operations, options);
+    }
+    return this.applyOperationsWithParts(list, options);
+  }
+  async applyOperationsWithParts(operations, options = {}) {
+    const author = options.author || getDefaultAuthor();
+    const atomic = options.atomic === true;
+    const snapshotEntries = this.entries;
+    const snapshotBytes = this.originalBytes;
+    const total = operations.length;
+    const restore = () => {
+      this.entries = snapshotEntries;
+      this.originalBytes = snapshotBytes;
+    };
+    const original = () => ({
+      uint8Array: snapshotBytes,
+      toUint8Array: () => new Uint8Array(snapshotBytes),
+      buffer: toBufferCompatible(snapshotBytes),
+      toBuffer: () => toBufferCompatible(snapshotBytes)
+    });
+    const refuse = (error2, results2 = [], receipts2 = [], extra = {}) => ({
+      status: "error",
+      hasChanges: false,
+      written: false,
+      rolledBack: true,
+      results: results2,
+      receipts: receipts2,
+      executionOrder: [],
+      authorsUsed: [],
+      artifactsChanged: [],
+      error: normalizeErrorWithRecovery(error2),
+      retryPlan: createRetryPlan({ atomic: true, rolledBack: true, results: results2, receipts: receipts2, operationCount: total }),
+      validation: { originalIssues: [], generatedIssues: [] },
+      ...extra,
+      ...original()
+    });
+    if (options.expectedRevision) {
+      const precondition = await this.applyBodyOperations([], { expectedRevision: options.expectedRevision });
+      if (precondition.status === "error") return precondition;
+    }
+    const parts = discoverHeaderFooterParts({
+      documentXml: text(this.entries, "word/document.xml"),
+      relsXml: text(this.entries, "word/_rels/document.xml.rels"),
+      settingsXml: text(this.entries, "word/settings.xml")
+    });
+    const bodyOps = [];
+    const partOps = [];
+    for (let i2 = 0; i2 < operations.length; i2++) {
+      const operation = operations[i2];
+      if (!operation || typeof operation !== "object" || operation.part == null) {
+        bodyOps.push({ operation, origIndex: i2 });
+        continue;
+      }
+      if (COMMENT_OPERATION_TYPES.has(operation.type)) {
+        return refuse({ code: "COMMENT_IN_HEADER_FOOTER", message: `Operation ${i2 + 1}: Word does not support comments in headers or footers.`, operationIndex: i2 + 1 });
+      }
+      const resolved = resolvePartSelector(parts, operation.part);
+      if (resolved.error) return refuse({ ...resolved.error, message: `Operation ${i2 + 1}: ${resolved.error.message}`, operationIndex: i2 + 1 });
+      const { part: _selector, ...rest } = operation;
+      partOps.push({ operation: rest, origIndex: i2, part: resolved.part });
+    }
+    const results = [];
+    const receipts = [];
+    const executionOrder = [];
+    const authorsUsed = /* @__PURE__ */ new Set();
+    const originalIssues = [];
+    let anyChange = false;
+    let anyFailure = false;
+    let bodyResult = null;
+    if (bodyOps.length) {
+      bodyResult = await this.applyBodyOperations(bodyOps.map((item) => item.operation), { ...options, expectedRevision: void 0 });
+      const toOriginal = (index) => bodyOps[index - 1]?.origIndex + 1;
+      for (const result of bodyResult.results || []) {
+        results.push({
+          ...result,
+          index: toOriginal(result.index),
+          ...result.receipt ? { receipt: { ...result.receipt, operationIndex: toOriginal(result.receipt.operationIndex) } } : {}
+        });
+      }
+      for (const receipt of bodyResult.receipts || []) receipts.push({ ...receipt, operationIndex: toOriginal(receipt.operationIndex) });
+      for (const index of bodyResult.executionOrder || []) executionOrder.push(toOriginal(index));
+      for (const name of bodyResult.authorsUsed || []) authorsUsed.add(name);
+      originalIssues.push(...bodyResult.validation?.originalIssues || []);
+      if (bodyResult.status === "error" || bodyResult.rolledBack) {
+        anyFailure = true;
+        if (atomic) {
+          restore();
+          return { ...bodyResult, results, receipts, executionOrder, written: false, artifactsChanged: [], rolledBack: true, ...original() };
+        }
+      }
+      anyChange = bodyResult.hasChanges === true;
+    }
+    const working = cloneEntries(this.entries);
+    const zip = new MemoryZip(working);
+    const changedParts = /* @__PURE__ */ new Set();
+    const { expectedRevision: _ignored, ...runnerOptions } = options;
+    const failPart = (item, error2) => {
+      anyFailure = true;
+      const failure = normalizeErrorWithRecovery({ ...error2, operationIndex: item.origIndex + 1 });
+      results.push({ index: item.origIndex + 1, type: item.operation.type || "redline", status: "error", authorUsed: author, part: item.part.path, error: failure });
+    };
+    for (const item of partOps) {
+      const path = item.part.path;
+      const xml = text(working, path);
+      if (!xml) {
+        failPart(item, { code: "PART_NOT_FOUND", message: `Part '${path}' is referenced but missing from the package.` });
+        if (atomic) break;
+        continue;
+      }
+      const numberingText = text(working, "word/numbering.xml");
+      const outcome = await applyOperationsToDocumentXml(xml, [item.operation], author, { numberingIdState: createDynamicNumberingIdState(numberingText || void 0) }, {
+        ...runnerOptions,
+        atomic: true,
+        strictTargets: options.strictTargets !== false,
+        _existingCommentDetails: {}
+      });
+      const single = outcome.results?.[0];
+      if (outcome.rolledBack || outcome.status === "error") {
+        failPart(item, single?.error || outcome.error || { code: "OPERATION_FAILED", message: "Operation failed." });
+        if (atomic) break;
+        continue;
+      }
+      if (!outcome.hasChanges) {
+        results.push({ ...single, index: item.origIndex + 1, part: path });
+        continue;
+      }
+      if (countRevisionsInsideFields(outcome.documentXml) > countRevisionsInsideFields(xml)) {
+        failPart(item, { code: "FIELD_EDIT_REFUSED", message: `The edit would change a field (for example PAGE or NUMPAGES) in ${path}. Word recomputes fields; edit the text around them instead.` });
+        if (atomic) break;
+        continue;
+      }
+      const taken = /* @__PURE__ */ new Set();
+      for (const [name, data] of working) {
+        if (name === path || !(name === "word/document.xml" || isHeaderFooterPath(name))) continue;
+        for (const id of collectRevisionIds(textDecoder2.decode(data))) taken.add(id);
+      }
+      const renumbered = renumberCollidingRevisionIds(outcome.documentXml, taken);
+      working.set(path, textEncoder4.encode(renumbered.xml));
+      const describeReceipt = (receipt) => receipt?.revisionItems ? { ...receipt, revisionItems: receipt.revisionItems.map((revision) => ({ ...revision, id: renumbered.idMap.get(String(revision.id)) ?? revision.id, partName: path })) } : receipt;
+      if (outcome.numberingXmlParts?.length) {
+        await ensureNumberingArtifactsInZip(zip, outcome.numberingXmlParts, { mergeNumberingXml: mergeNumberingXmlBySchemaOrder });
+      }
+      changedParts.add(path);
+      anyChange = true;
+      results.push({
+        ...single,
+        index: item.origIndex + 1,
+        part: path,
+        partSections: item.part.appliesToSections,
+        ...single?.receipt ? { receipt: { ...describeReceipt(single.receipt), operationIndex: item.origIndex + 1 } } : {}
+      });
+      if (outcome.receipts?.[0]) receipts.push({ ...describeReceipt(outcome.receipts[0]), operationIndex: item.origIndex + 1 });
+      executionOrder.push(item.origIndex + 1);
+      for (const name of outcome.authorsUsed || []) authorsUsed.add(name);
+    }
+    const generatedIssues = [];
+    if (!(atomic && anyFailure)) {
+      for (const path of changedParts) {
+        const before = validateRedlineOoxml(text(this.entries, path)).issues.map((issue) => ({ source: path, ...issue }));
+        const after = validateRedlineOoxml(text(working, path)).issues.map((issue) => ({ source: path, ...issue }));
+        generatedIssues.push(...validationErrors(subtractValidationIssueMultiset(after, before)));
+      }
+      if (options.validate !== false && changedParts.size) {
+        try {
+          await validateDocxPackage(zip);
+        } catch (error2) {
+          generatedIssues.push({ source: "package", code: "PACKAGE_VALIDATION", severity: "error", message: error2.message });
+        }
+      }
+    }
+    if (atomic && anyFailure || generatedIssues.length) {
+      restore();
+      const error2 = generatedIssues.length ? { code: "PACKAGE_OPERATION_FAILED", message: `Applied operations introduced invalid markup (${[...new Set(generatedIssues.map((issue) => issue.code))].join(", ")}).`, issues: generatedIssues } : { code: "BATCH_OPERATION_FAILED", message: "Atomic batch rolled back because one or more operations failed." };
+      const rolledBackResults = results.map((result) => result.receipt ? { ...result, receipt: { ...result.receipt, committed: false, finalDisposition: "rolled_back" } } : result).sort((a, b) => a.index - b.index);
+      const rolledBackReceipts = receipts.map((receipt) => ({ ...receipt, committed: false, finalDisposition: "rolled_back" }));
+      return refuse(error2, rolledBackResults, rolledBackReceipts, { validation: { originalIssues, generatedIssues }, issues: generatedIssues });
+    }
+    results.sort((a, b) => a.index - b.index);
+    receipts.sort((a, b) => a.operationIndex - b.operationIndex);
+    const status = !anyFailure ? "ok" : anyChange ? "partial" : "error";
+    const failureError = anyFailure ? { error: normalizeErrorWithRecovery({ code: "BATCH_OPERATION_FAILED", message: "One or more operations failed; the others were applied." }) } : {};
+    if (!changedParts.size) {
+      const buf = toBufferCompatible(this.originalBytes);
+      return {
+        ...bodyResult || {},
+        results,
+        receipts,
+        executionOrder,
+        authorsUsed: [...authorsUsed],
+        status,
+        hasChanges: anyChange,
+        written: bodyResult?.written === true,
+        artifactsChanged: bodyResult?.artifactsChanged || [],
+        validation: { originalIssues, generatedIssues: [] },
+        ...failureError,
+        uint8Array: this.originalBytes,
+        toUint8Array: () => new Uint8Array(this.originalBytes),
+        buffer: buf,
+        toBuffer: () => toBufferCompatible(this.originalBytes)
+      };
+    }
+    this.entries = working;
+    const outputBytes = this.toUint8Array();
+    this.originalBytes = outputBytes;
+    const artifactsChanged = [...working].filter(([name, data]) => !snapshotEntries.has(name) || !areByteArraysEqual(data, snapshotEntries.get(name))).map(([name]) => name);
+    return {
+      ...bodyResult || {},
+      status,
+      hasChanges: true,
+      written: true,
+      results,
+      receipts,
+      executionOrder,
+      authorsUsed: [...authorsUsed],
+      artifactsChanged,
+      validation: { originalIssues, generatedIssues: [] },
+      ...failureError,
+      uint8Array: outputBytes,
+      toUint8Array: () => new Uint8Array(outputBytes),
+      buffer: toBufferCompatible(outputBytes),
+      inspection: this.inspect(),
+      toBuffer: () => toBufferCompatible(outputBytes)
+    };
+  }
+  async applyBodyOperations(operations, options = {}) {
     const failedApply = (error2) => {
       const results = [];
       const receipts = [];
@@ -26987,18 +27944,21 @@ var DocxDocument = class {
           toBuffer: () => toBufferCompatible(this.originalBytes)
         };
       }
-      working.set("word/document.xml", textEncoder4.encode(result.documentXml));
+      const bodyChanged = (result.results || []).some((item) => item?.status !== "error" && item?.operationType !== "comment_resolve");
+      if (bodyChanged) working.set("word/document.xml", textEncoder4.encode(result.documentXml));
       await ensureNumberingArtifactsInZip(zip, result.numberingXmlParts, { mergeNumberingXml: mergeNumberingXmlBySchemaOrder });
       const existingCommentsXml = text(working, "word/comments.xml");
       const commentsXmlForPackaging = result.commentsXml || existingCommentsXml;
       await ensureCommentsArtifactsInZip(zip, commentsXmlForPackaging, {
         replaceExisting: result.commentsXmlMode === "replace" || !result.commentsXml && !!existingCommentsXml
       });
-      const existingCommentsExtendedXml = text(working, "word/commentsExtended.xml");
-      const commentsExtendedXmlForPackaging = result.commentsExtendedXml || existingCommentsExtendedXml;
-      await ensureCommentsExtendedArtifactsInZip(zip, commentsExtendedXmlForPackaging, {
-        replaceExisting: result.commentsExtendedXmlMode === "replace" || !result.commentsExtendedXml && !!existingCommentsExtendedXml
-      });
+      if (result.commentsExtendedXml) {
+        await ensureCommentsExtendedArtifactsInZip(zip, result.commentsExtendedXml, {
+          replaceExisting: result.commentsExtendedXmlMode === "replace"
+        });
+      }
+      await repairKnownContentTypes(zip);
+      reconcileCommentSiblings(working);
       if (options.validate !== false) {
         const generated = validateRedlineOoxml(result.documentXml);
         const outputIssues = generated.issues.map((issue) => ({ source: "word/document.xml", ...issue }));
@@ -27067,13 +28027,25 @@ var DocxDocument = class {
     const transform = action === "accept" ? acceptTrackedChangesInOoxml : action === "reject" ? rejectTrackedChangesInOoxml : null;
     if (!transform) return packageFailure(this.originalBytes, "INVALID_ACTION", `Unknown revision action: ${action}`);
     const sourceBytes = this.originalBytes;
+    const originalEntries = this.entries;
     const working = cloneEntries(this.entries);
     const zip = new MemoryZip(working);
     const result = transform(text(working, "word/document.xml"), { author: options.author, allAuthors: options.allAuthors === true });
     if (result.status === "error" || result.error) {
       return packageFailure(sourceBytes, result.error?.code || "REVISION_OPERATION_FAILED", result.error?.message || "Revision operation failed.");
     }
-    if (!result.hasChanges) {
+    const partUpdates = /* @__PURE__ */ new Map();
+    for (const part of this.inspectHeadersFooters()) {
+      const partXml = text(working, part.path);
+      if (!partXml) continue;
+      const partResult = transform(partXml, { author: options.author, allAuthors: options.allAuthors === true });
+      if (partResult.status === "error" || partResult.error) {
+        return packageFailure(sourceBytes, partResult.error?.code || "REVISION_OPERATION_FAILED", `${part.path}: ${partResult.error?.message || "Revision operation failed."}`);
+      }
+      if (partResult.hasChanges) partUpdates.set(part.path, partResult.oxml);
+    }
+    const hasChanges = result.hasChanges || partUpdates.size > 0;
+    if (!hasChanges) {
       const buf = toBufferCompatible(sourceBytes);
       return {
         ...result,
@@ -27086,8 +28058,10 @@ var DocxDocument = class {
         toBuffer: () => toBufferCompatible(sourceBytes)
       };
     }
-    working.set("word/document.xml", textEncoder4.encode(result.oxml));
+    if (result.hasChanges) working.set("word/document.xml", textEncoder4.encode(result.oxml));
+    for (const [path, xml] of partUpdates) working.set(path, textEncoder4.encode(xml));
     try {
+      await repairKnownContentTypes(zip);
       if (options.validate !== false) await validateDocxPackage(zip);
     } catch (error2) {
       return packageFailure(sourceBytes, "PACKAGE_VALIDATION", error2.message);
@@ -27100,13 +28074,71 @@ var DocxDocument = class {
       ...result,
       status: "ok",
       written: true,
-      artifactsChanged: ["word/document.xml"],
+      hasChanges: true,
+      artifactsChanged: [...working].filter(([name, data]) => !originalEntries.has(name) || !areByteArraysEqual(data, originalEntries.get(name))).map(([name]) => name),
       uint8Array: outputBytes,
       toUint8Array: () => new Uint8Array(outputBytes),
       buffer: outputBuf,
       toBuffer: () => toBufferCompatible(outputBytes)
     };
   }
+  /**
+   * Resolves (or reopens) the comment thread containing `commentId`.
+   * Resolved is a thread-level state in Word, so the root and every reply are updated together.
+   */
+  async resolveComment(commentId, options = {}) {
+    const sourceBytes = this.originalBytes;
+    const working = cloneEntries(this.entries);
+    const resolved = options.resolved !== false;
+    const noChange = (extra) => {
+      const buf = toBufferCompatible(sourceBytes);
+      return {
+        status: "ok",
+        hasChanges: false,
+        written: false,
+        artifactsChanged: [],
+        ...extra,
+        uint8Array: sourceBytes,
+        toUint8Array: () => new Uint8Array(sourceBytes),
+        buffer: buf,
+        toBuffer: () => toBufferCompatible(sourceBytes)
+      };
+    };
+    const result = applyThreadResolutionToParts({
+      commentsXml: text(working, "word/comments.xml"),
+      commentsExtendedXml: text(working, "word/commentsExtended.xml"),
+      commentId,
+      resolved
+    });
+    if (result.status === "error") return packageFailure(sourceBytes, result.error.code, result.error.message);
+    if (!result.hasChanges) return noChange({ resolved, threadRootId: result.threadRootId, commentIds: result.commentIds });
+    const zip = new MemoryZip(working);
+    try {
+      if (result.commentsXml) working.set("word/comments.xml", textEncoder4.encode(result.commentsXml));
+      await ensureCommentsExtendedArtifactsInZip(zip, result.commentsExtendedXml, { replaceExisting: true });
+      await repairKnownContentTypes(zip);
+      if (options.validate !== false) await validateDocxPackage(zip);
+    } catch (error2) {
+      return packageFailure(sourceBytes, "PACKAGE_VALIDATION", error2.message);
+    }
+    const artifactsChanged = [...working].filter(([name, data]) => !this.entries.has(name) || !areByteArraysEqual(data, this.entries.get(name))).map(([name]) => name);
+    this.entries = working;
+    const outputBytes = this.toUint8Array();
+    this.originalBytes = outputBytes;
+    return {
+      status: "ok",
+      hasChanges: true,
+      written: true,
+      resolved,
+      threadRootId: result.threadRootId,
+      commentIds: result.commentIds,
+      artifactsChanged,
+      uint8Array: outputBytes,
+      toUint8Array: () => new Uint8Array(outputBytes),
+      buffer: toBufferCompatible(outputBytes),
+      toBuffer: () => toBufferCompatible(outputBytes)
+    };
+  }
   async deleteComments(options = {}) {
     const sourceBytes = this.originalBytes;
     const working = cloneEntries(this.entries);
@@ -27130,7 +28162,13 @@ var DocxDocument = class {
     if (!parsed.doc || parsed.error) {
       return packageFailure(sourceBytes, "PARSE_ERROR", parsed.error?.message || "Could not parse comments.xml.");
     }
-    const matches = (comment) => options.allAuthors === true || (comment.getAttribute("w:author") || comment.getAttribute("author")) === options.author;
+    const requestedIds = Array.isArray(options.ids) ? new Set(options.ids.map(String)) : null;
+    if (requestedIds) {
+      const known = new Set(Array.from(parsed.doc.getElementsByTagNameNS("*", "comment")).map((node) => node.getAttribute("w:id") || node.getAttribute("id")));
+      const missing = [...requestedIds].filter((id) => !known.has(id));
+      if (missing.length) return packageFailure(sourceBytes, "COMMENT_NOT_FOUND", `Comment id(s) not found: ${missing.join(", ")}.`);
+    }
+    const matches = (comment) => requestedIds ? requestedIds.has(comment.getAttribute("w:id") || comment.getAttribute("id")) : options.allAuthors === true || (comment.getAttribute("w:author") || comment.getAttribute("author")) === options.author;
     const ids = new Set(
       Array.from(parsed.doc.getElementsByTagNameNS("*", "comment")).filter(matches).map((node) => node.getAttribute("w:id") || node.getAttribute("id")).filter(Boolean)
     );
@@ -27159,9 +28197,8 @@ var DocxDocument = class {
       const idByParaId = /* @__PURE__ */ new Map();
       for (const comment of Array.from(parsed.doc.getElementsByTagNameNS("*", "comment"))) {
         const id = comment.getAttribute("w:id") || comment.getAttribute("id");
-        const paragraph = Array.from(comment.getElementsByTagNameNS("*", "p"))[0];
-        const paraId = paragraph?.getAttribute("w14:paraId") || paragraph?.getAttribute("paraId");
-        if (paraId) idByParaId.set(paraId.toUpperCase(), id);
+        const paraId = commentParaId(comment);
+        if (paraId) idByParaId.set(paraId, id);
       }
       for (const [paraId, id] of idByParaId) {
         if (ids.has(id)) removedParaIds.add(paraId);
@@ -27180,8 +28217,8 @@ var DocxDocument = class {
         }
       }
     }
-    const commentsResult = deleteCommentsByAuthorInOoxml(commentsXml, { author: options.author, allAuthors: options.allAuthors === true });
-    const remainingParsed = parseOoxmlSafe(commentsResult.oxml, "application/xml");
+    const remainingXml = requestedIds ? commentsXml : deleteCommentsByAuthorInOoxml(commentsXml, { author: options.author, allAuthors: options.allAuthors === true }).oxml;
+    const remainingParsed = parseOoxmlSafe(remainingXml, "application/xml");
     if (!remainingParsed.doc || remainingParsed.error) {
       return packageFailure(sourceBytes, "PARSE_ERROR", remainingParsed.error?.message || "Could not parse updated comments.xml.");
     }
@@ -27217,10 +28254,14 @@ var DocxDocument = class {
     }
     working.set("word/document.xml", textEncoder4.encode(serializer.serializeToString(documentParsed.doc)));
     try {
-      if (options.validate !== false) await validateDocxPackage(new MemoryZip(working));
+      reconcileCommentSiblings(working);
+      const finalZip = new MemoryZip(working);
+      await repairKnownContentTypes(finalZip);
+      if (options.validate !== false) await validateDocxPackage(finalZip);
     } catch (error2) {
       return packageFailure(sourceBytes, "PACKAGE_VALIDATION", error2.message);
     }
+    const artifactsChanged = [...working].filter(([name, data]) => !this.entries.has(name) || !areByteArraysEqual(data, this.entries.get(name))).map(([name]) => name);
     this.entries = working;
     const outputBytes = this.toUint8Array();
     this.originalBytes = outputBytes;
@@ -27231,7 +28272,7 @@ var DocxDocument = class {
       written: true,
       commentsRemoved: ids.size,
       referencesRemoved,
-      artifactsChanged: ["word/document.xml", "word/comments.xml", ...extendedParsed?.doc ? ["word/commentsExtended.xml"] : []],
+      artifactsChanged,
       uint8Array: outputBytes,
       toUint8Array: () => new Uint8Array(outputBytes),
       buffer: outputBuf,