@ansonlai/docx-redline-js 0.1.3 → 0.1.4

package/AGENTS.md

@@ -74,6 +74,30 @@ const result = injectCommentsIntoOoxml(paragraphOoxml, [
 ]);
 ```
 
+### Accept tracked changes from one user (or all users)
+
+```js
+import { acceptTrackedChangesInOoxml } from '@ansonlai/docx-redline-js';
+const acceptedMine = acceptTrackedChangesInOoxml(documentXml, { author: 'Agent' });
+const acceptedAll = acceptTrackedChangesInOoxml(documentXml, { allAuthors: true });
+```
+
+### Reject tracked changes from one user (or all users)
+
+```js
+import { rejectTrackedChangesInOoxml } from '@ansonlai/docx-redline-js';
+const rejectedMine = rejectTrackedChangesInOoxml(documentXml, { author: 'Agent' });
+const rejectedAll = rejectTrackedChangesInOoxml(documentXml, { allAuthors: true });
+```
+
+### Delete comments from one user (or all users)
+
+```js
+import { deleteCommentsByAuthorInOoxml } from '@ansonlai/docx-redline-js';
+const removedMine = deleteCommentsByAuthorInOoxml(packageOrDocumentOoxml, { author: 'Agent' });
+const removedAll = deleteCommentsByAuthorInOoxml(packageOrDocumentOoxml, { allAuthors: true });
+```
+
 ### Apply multiple operations to full document XML
 
 ```js
@@ -129,6 +153,7 @@ services/
   standalone-docx-plumbing.js
   numbering-helpers.js
   comment-engine.js
+  revision-comment-management.js
   table-reconciliation.js
   package-builder.js
 orchestration/
@@ -167,10 +192,22 @@ import { wrapInDocumentFragment } from '@ansonlai/docx-redline-js';
 const wrapped = wrapInDocumentFragment(rawOoxml, { includeNumbering: true, numberingXml });
 ```
 
+### Output shape guardrail (important for packaging)
+
+When consuming `result.oxml`, do not assume the payload is always safe to write
+directly into `word/document.xml`.
+
+- Paragraph/range/table APIs can return a fragment, `<w:document>`, or package payload (`<pkg:package>`).
+- `applyOperationToDocumentXml(...).documentXml` is the document-safe path when you need a full `word/document.xml` replacement.
+- Use `extractReplacementNodesFromOoxml(payload)` to normalize unknown payloads.
+- If `sourceType === 'package'` or the payload starts with `<pkg:package`, do not write it into `word/document.xml` as-is.
+
 ## Gotchas
 
 1. Call `configureXmlProvider` first in Node.js.
 2. `applyRedlineToOxml` is async.
 3. Paragraph APIs expect paragraph-level OOXML, not full `word/document.xml` in all cases.
 4. List operations may return `numberingXml` that must be merged into package parts.
-5. `useNativeApi: true` means standalone mode cannot fully handle that operation path.
+5. `useNativeApi: true` means standalone mode cannot fully handle that operation path.
+6. `deleteCommentsByAuthorInOoxml` removes matching `comments.xml` entries and linked comment anchors/references in the document.
+7. If output begins with `<pkg:package`, treat it as package-level OOXML and normalize it before writing anything back to `word/document.xml`.

package/ARCHITECTURE.md

@@ -38,6 +38,7 @@ No Word add-in entrypoints or host-specific integration layers are part of this
 ├── pipeline/
 ├── services/
 │   ├── numbering-helpers.js
+│   ├── revision-comment-management.js
 │   ├── standalone-docx-plumbing.js
 │   └── standalone-operation-runner.js
 └── index.js
@@ -67,6 +68,8 @@ No Word add-in entrypoints or host-specific integration layers are part of this
   - Dynamic numbering ID allocation, numbering payload remapping, and schema-order-safe numbering merges.
 - `services/standalone-docx-plumbing.js`
   - Package-level extraction/wiring/validation for `word/document.xml`, `word/numbering.xml`, and `word/comments.xml`.
+- `services/revision-comment-management.js`
+  - OOXML transforms for accepting/rejecting tracked changes by author/all-authors and deleting comments by author/all-authors.
 - `services/standalone-operation-runner.js`
   - Host-agnostic operation bridge for `redline`, `highlight`, and `comment` workflows.
 - `orchestration/*`
@@ -79,7 +82,8 @@ No Word add-in entrypoints or host-specific integration layers are part of this
 3. Caller invokes reconciliation APIs (`applyRedlineToOxml`, operation runner, ingestion/export helpers).
 4. `engine/oxml-engine.js` routes to format, table, list, surgical, or reconstruction flows.
 5. Pipeline/services return OOXML and optional package artifacts (`numberingXml`, comments payloads).
-6. Caller writes resulting XML back to package/document boundaries.
+6. Optional revision/comment management transforms can accept/reject revisions or delete comments by author.
+7. Caller writes resulting XML back to package/document boundaries.
 
 ## Public Surfaces
 
@@ -115,4 +119,5 @@ Use this sequence to understand or modify behavior without reading everything:
 2. Follow exports into `engine/oxml-engine.js` or relevant `services/*` module.
 3. For targeting bugs, inspect `core/paragraph-targeting.js`, `core/list-targeting.js`, and `core/table-targeting.js`.
 4. For package wiring issues, inspect `services/standalone-docx-plumbing.js`.
-5. For numbering/list issues, inspect `services/numbering-helpers.js` and orchestration list-fallback modules.
+5. For revision/comment cleanup behavior, inspect `services/revision-comment-management.js`.
+6. For numbering/list issues, inspect `services/numbering-helpers.js` and orchestration list-fallback modules.

package/README.md

@@ -11,6 +11,8 @@ Converts AI-generated or programmatic text/markdown edits into valid Office Open
 - Lists: generate and edit real Word lists (`w:numPr`) from markdown
 - Tables: virtual-grid diffing for cell-level edits with merge safety
 - Comments: inject OOXML comments anchored to text ranges
+- Revision management: accept/reject tracked changes by author or for all authors
+- Comment management: delete comments by author or for all authors
 - Highlights: apply highlight colors to runs
 - Markdown and OOXML conversion in both directions
 - Package plumbing helpers for numbering.xml, comments.xml, content types, and relationships
@@ -125,6 +127,9 @@ const result = await applyRedlineToOxml(oxml, original, modified, {
 | Function | Purpose |
 |----------|---------|
 | `injectCommentsIntoOoxml(oxml, comments, options)` | Add comments anchored to text ranges. |
+| `acceptTrackedChangesInOoxml(oxml, { author?, allAuthors? })` | Accept `w:ins` / `w:del` / `*PrChange` revisions for one author or all authors. |
+| `rejectTrackedChangesInOoxml(oxml, { author?, allAuthors? })` | Reject `w:ins` / `w:del` / `*PrChange` revisions for one author or all authors. |
+| `deleteCommentsByAuthorInOoxml(oxml, { author?, allAuthors? })` | Delete comments and matching anchors/references for one author or all authors. |
 | `generateTableOoxml(headers, rows, options)` | Generate a `w:tbl` from tabular data. |
 | `createDynamicNumberingIdState(numberingXml)` | Allocate numbering IDs without collisions. |
 | `ensureNumberingArtifactsInZip(zip, numberingXml)` | Merge numbering artifacts into a `.docx` package. |
@@ -140,6 +145,26 @@ import { applyOperationToDocumentXml } from '@ansonlai/docx-redline-js/services/
 import { getParagraphText } from '@ansonlai/docx-redline-js/core/paragraph-targeting.js';
 ```
 
+### Output Shape Matrix
+
+Different APIs return different OOXML shapes. Use this as a packaging safety check.
+
+| API | Typical input scope | Output field | Possible root/output shape | Safe to write directly into `word/document.xml` |
+|-----|----------------------|--------------|----------------------------|--------------------------------------------------|
+| `applyRedlineToOxml(...)` | Paragraph, range, or table-scope OOXML | `result.oxml` | Fragment, `<w:document>`, or package payload (`<pkg:package>`) | No. Inspect first. |
+| `applyRedlineToOxmlWithListFallback(...)` | Paragraph or range-scope OOXML | `result.oxml` | Fragment, `<w:document>`, or package payload (`<pkg:package>`) | No. Inspect first. |
+| `reconcileMarkdownTableOoxml(...)` | Table or paragraph-scope OOXML | `result.oxml` | Same shapes as `applyRedlineToOxml(...)` for the supplied scope | No. Inspect first. |
+| `applyOperationToDocumentXml(...)` | Full `word/document.xml` string | `result.documentXml` | `<w:document>` | Yes. This is the document-safe helper. |
+| `extractReplacementNodesFromOoxml(...)` | Any OOXML payload | `{ replacementNodes, numberingXml, sourceType }` | Normalized to `fragment`, `document`, or `package` | Yes. Use this when consuming `result.oxml`. |
+
+### Do / Don't for Packaging
+
+- Do use `applyOperationToDocumentXml(...).documentXml` when your intent is to replace `word/document.xml`.
+- Do use `extractReplacementNodesFromOoxml(...)` when you are consuming `result.oxml` from paragraph/range/table APIs.
+- Do merge numbering/comments artifacts with `ensureNumberingArtifactsInZip(...)` and `ensureCommentsArtifactsInZip(...)` when those parts are present.
+- Don't write payloads that start with `<pkg:package` directly into `word/document.xml`.
+- Don't assume every `result.oxml` payload is a raw paragraph fragment.
+
 ## Working With `.docx` Files
 
 This package operates on OOXML strings (XML parts inside `.docx` zip archives), not raw `.docx` binaries.
@@ -155,18 +180,40 @@ Typical flow:
 ```js
 import JSZip from 'jszip';
 import {
-  configureXmlProvider,
   applyRedlineToOxml,
+  extractReplacementNodesFromOoxml,
   ensureNumberingArtifactsInZip,
   validateDocxPackage
 } from '@ansonlai/docx-redline-js';
+import { applyOperationToDocumentXml } from '@ansonlai/docx-redline-js/services/standalone-operation-runner.js';
 
 const zip = await JSZip.loadAsync(docxBuffer);
 const documentXml = await zip.file('word/document.xml').async('string');
 
-// Apply edits with applyRedlineToOxml(...)
-// Merge artifacts with ensureNumberingArtifactsInZip(...) as needed
+const opResult = await applyOperationToDocumentXml(
+  documentXml,
+  { type: 'redline', target: 'old text', modified: 'new text' },
+  'Editor'
+);
+
+// applyOperationToDocumentXml(...) returns a full w:document payload.
+zip.file('word/document.xml', opResult.documentXml);
+
+const fragmentResult = await applyRedlineToOxml(
+  paragraphOoxml,
+  'Item text',
+  '1. Item text',
+  { generateRedlines: true, author: 'Editor' }
+);
+const normalized = extractReplacementNodesFromOoxml(fragmentResult.oxml);
+
+// If sourceType === 'package', merge extracted content/artifacts instead of
+// writing the raw pkg:package payload into word/document.xml.
+if (normalized.numberingXml) {
+  await ensureNumberingArtifactsInZip(zip, normalized.numberingXml);
+}
 
+await validateDocxPackage(zip);
 const output = await zip.generateAsync({ type: 'nodebuffer' });
 ```
 

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

@@ -1,4 +1,4 @@
-// @ansonlai/docx-redline-js v0.1.3 — https://github.com/AnsonLai/docx-redline-js
+// @ansonlai/docx-redline-js v0.1.4 — https://github.com/AnsonLai/docx-redline-js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -7901,6 +7901,306 @@ function injectCommentsIntoPackage2(packageOxml, commentsXml) {
   return injectCommentsIntoPackage(packageOxml, commentsXml);
 }
 
+// services/revision-comment-management.js
+function getAttributeByLocalName(node, localName) {
+  if (!node || !node.attributes) return "";
+  for (const attr of Array.from(node.attributes)) {
+    if ((attr.localName || "").toLowerCase() === localName.toLowerCase()) {
+      return String(attr.value || "");
+    }
+  }
+  return String(
+    node.getAttribute?.(`w:${localName}`) || node.getAttribute?.(localName) || ""
+  );
+}
+function normalizeAuthor(author) {
+  return typeof author === "string" ? author.trim().toLowerCase() : "";
+}
+function isElement(node) {
+  return !!node && node.nodeType === 1;
+}
+function isWordElement4(node, localName) {
+  return isElement(node) && node.namespaceURI === NS_W && String(node.localName || "").toLowerCase() === localName.toLowerCase();
+}
+function getWordElementsByLocalName(xmlDoc, localName) {
+  return Array.from(xmlDoc.getElementsByTagNameNS(NS_W, localName));
+}
+function resolveAuthorFilter(options = {}) {
+  if (options?.allAuthors === true) {
+    return { valid: true, allAuthors: true, normalizedAuthor: "" };
+  }
+  const normalizedAuthor = normalizeAuthor(options?.author);
+  if (!normalizedAuthor) {
+    return {
+      valid: false,
+      allAuthors: false,
+      normalizedAuthor: "",
+      warning: "No author provided. Pass { author } or set { allAuthors: true }."
+    };
+  }
+  return { valid: true, allAuthors: false, normalizedAuthor };
+}
+function authorMatchesNode(node, filter) {
+  if (filter.allAuthors) return true;
+  const nodeAuthor = normalizeAuthor(getAttributeByLocalName(node, "author"));
+  return !!nodeAuthor && nodeAuthor === filter.normalizedAuthor;
+}
+function parseXmlWithWarnings(oxml, parseFailurePrefix) {
+  const parser = createParser();
+  const xmlDoc = parser.parseFromString(oxml, "application/xml");
+  const parseError = getXmlParseError(xmlDoc);
+  if (parseError) {
+    return {
+      xmlDoc: null,
+      serializer: null,
+      warning: `${parseFailurePrefix}: ${parseError.textContent || "parse error"}`
+    };
+  }
+  return { xmlDoc, serializer: createSerializer(), warning: null };
+}
+function removeNode(node) {
+  if (node?.parentNode) {
+    node.parentNode.removeChild(node);
+    return true;
+  }
+  return false;
+}
+function unwrapNode(node) {
+  const parent = node?.parentNode;
+  if (!parent) return false;
+  while (node.firstChild) {
+    parent.insertBefore(node.firstChild, node);
+  }
+  parent.removeChild(node);
+  return true;
+}
+function isTableRowRevisionMarker(node) {
+  const parent = node?.parentNode;
+  return isWordElement4(parent, "trPr") && isWordElement4(parent?.parentNode, "tr");
+}
+function acceptTrackedChangesInOoxml(oxml, options = {}) {
+  const warnings = [];
+  const filter = resolveAuthorFilter(options);
+  if (!filter.valid) {
+    return { oxml, hasChanges: false, acceptedCount: 0, warnings: [filter.warning] };
+  }
+  const parseResult = parseXmlWithWarnings(oxml, "Failed to parse OOXML");
+  if (!parseResult.xmlDoc) {
+    return { oxml, hasChanges: false, acceptedCount: 0, warnings: [parseResult.warning] };
+  }
+  const { xmlDoc, serializer } = parseResult;
+  let acceptedCount = 0;
+  for (const insNode of getWordElementsByLocalName(xmlDoc, "ins")) {
+    if (!insNode.parentNode || !authorMatchesNode(insNode, filter)) continue;
+    if (isTableRowRevisionMarker(insNode)) {
+      if (removeNode(insNode)) acceptedCount += 1;
+      continue;
+    }
+    if (unwrapNode(insNode)) acceptedCount += 1;
+  }
+  for (const delNode of getWordElementsByLocalName(xmlDoc, "del")) {
+    if (!delNode.parentNode || !authorMatchesNode(delNode, filter)) continue;
+    if (isTableRowRevisionMarker(delNode)) {
+      const rowNode = delNode.parentNode?.parentNode;
+      if (removeNode(rowNode)) acceptedCount += 1;
+      continue;
+    }
+    if (removeNode(delNode)) acceptedCount += 1;
+  }
+  const changeTags = ["rPrChange", "pPrChange", "tblPrChange", "trPrChange", "tcPrChange"];
+  for (const localName of changeTags) {
+    for (const changeNode of getWordElementsByLocalName(xmlDoc, localName)) {
+      if (!changeNode.parentNode || !authorMatchesNode(changeNode, filter)) continue;
+      if (removeNode(changeNode)) acceptedCount += 1;
+    }
+  }
+  return {
+    oxml: serializer.serializeToString(xmlDoc),
+    hasChanges: acceptedCount > 0,
+    acceptedCount,
+    warnings
+  };
+}
+function convertDeletionTextNodes(xmlDoc, delNode) {
+  for (const delTextNode of Array.from(delNode.getElementsByTagNameNS(NS_W, "delText"))) {
+    const normalText = xmlDoc.createElementNS(NS_W, "w:t");
+    const spaceValue = delTextNode.getAttribute("xml:space");
+    if (spaceValue) {
+      normalText.setAttribute("xml:space", spaceValue);
+    }
+    while (delTextNode.firstChild) {
+      normalText.appendChild(delTextNode.firstChild);
+    }
+    delTextNode.parentNode?.replaceChild(normalText, delTextNode);
+  }
+}
+function rejectPropertyChangeNode(changeNode, localName) {
+  const parent = changeNode?.parentNode;
+  if (!parent) return false;
+  const baseLocalName = localName.endsWith("Change") ? localName.slice(0, -"Change".length) : "";
+  if (!baseLocalName || String(parent.localName || "").toLowerCase() !== baseLocalName.toLowerCase() || parent.namespaceURI !== NS_W) {
+    return removeNode(changeNode);
+  }
+  const historicalNode = Array.from(changeNode.childNodes || []).find(
+    (child) => child.nodeType === 1 && child.namespaceURI === NS_W && String(child.localName || "").toLowerCase() === baseLocalName.toLowerCase()
+  );
+  if (!historicalNode) {
+    return removeNode(changeNode);
+  }
+  const toAppend = Array.from(historicalNode.childNodes || []);
+  while (parent.firstChild) {
+    parent.removeChild(parent.firstChild);
+  }
+  for (const node of toAppend) {
+    const clone = xmlDocImportNode(parent.ownerDocument, node);
+    parent.appendChild(clone);
+  }
+  return true;
+}
+function xmlDocImportNode(xmlDoc, node) {
+  if (xmlDoc && typeof xmlDoc.importNode === "function") {
+    return xmlDoc.importNode(node, true);
+  }
+  return node.cloneNode(true);
+}
+function rejectTrackedChangesInOoxml(oxml, options = {}) {
+  const warnings = [];
+  const filter = resolveAuthorFilter(options);
+  if (!filter.valid) {
+    return { oxml, hasChanges: false, rejectedCount: 0, warnings: [filter.warning] };
+  }
+  const parseResult = parseXmlWithWarnings(oxml, "Failed to parse OOXML");
+  if (!parseResult.xmlDoc) {
+    return { oxml, hasChanges: false, rejectedCount: 0, warnings: [parseResult.warning] };
+  }
+  const { xmlDoc, serializer } = parseResult;
+  let rejectedCount = 0;
+  for (const insNode of getWordElementsByLocalName(xmlDoc, "ins")) {
+    if (!insNode.parentNode || !authorMatchesNode(insNode, filter)) continue;
+    if (isTableRowRevisionMarker(insNode)) {
+      const rowNode = insNode.parentNode?.parentNode;
+      if (removeNode(rowNode)) rejectedCount += 1;
+      continue;
+    }
+    if (removeNode(insNode)) rejectedCount += 1;
+  }
+  for (const delNode of getWordElementsByLocalName(xmlDoc, "del")) {
+    if (!delNode.parentNode || !authorMatchesNode(delNode, filter)) continue;
+    if (isTableRowRevisionMarker(delNode)) {
+      if (removeNode(delNode)) rejectedCount += 1;
+      continue;
+    }
+    convertDeletionTextNodes(xmlDoc, delNode);
+    if (unwrapNode(delNode)) rejectedCount += 1;
+  }
+  const changeTags = ["rPrChange", "pPrChange", "tblPrChange", "trPrChange", "tcPrChange"];
+  for (const localName of changeTags) {
+    for (const changeNode of getWordElementsByLocalName(xmlDoc, localName)) {
+      if (!changeNode.parentNode || !authorMatchesNode(changeNode, filter)) continue;
+      if (rejectPropertyChangeNode(changeNode, localName)) rejectedCount += 1;
+    }
+  }
+  return {
+    oxml: serializer.serializeToString(xmlDoc),
+    hasChanges: rejectedCount > 0,
+    rejectedCount,
+    warnings
+  };
+}
+function collectCommentTargetIds(xmlDoc, filter) {
+  const targetIds = /* @__PURE__ */ new Set();
+  const commentNodes = getWordElementsByLocalName(xmlDoc, "comment");
+  for (const commentNode of commentNodes) {
+    if (!authorMatchesNode(commentNode, filter)) continue;
+    const id = getAttributeByLocalName(commentNode, "id");
+    if (id) targetIds.add(id);
+  }
+  return { targetIds, commentNodes };
+}
+function removeCommentNodesById(commentNodes, targetIds) {
+  let removed = 0;
+  for (const commentNode of commentNodes) {
+    const id = getAttributeByLocalName(commentNode, "id");
+    if (!id || !targetIds.has(id)) continue;
+    if (removeNode(commentNode)) removed += 1;
+  }
+  return removed;
+}
+function runIsOnlyCommentReference(runNode) {
+  if (!isWordElement4(runNode, "r")) return false;
+  const meaningfulChildren = Array.from(runNode.childNodes || []).filter((child) => {
+    if (child.nodeType === 3) return String(child.nodeValue || "").trim().length > 0;
+    if (child.nodeType !== 1) return false;
+    if (child.namespaceURI !== NS_W) return true;
+    const local = String(child.localName || "").toLowerCase();
+    return local !== "rpr" && local !== "commentreference";
+  });
+  return meaningfulChildren.length === 0;
+}
+function removeCommentAnchors(xmlDoc, targetIds) {
+  let removed = 0;
+  const anchorTags = ["commentRangeStart", "commentRangeEnd", "commentReference"];
+  for (const localName of anchorTags) {
+    for (const node of getWordElementsByLocalName(xmlDoc, localName)) {
+      if (!node.parentNode) continue;
+      const id = getAttributeByLocalName(node, "id");
+      if (!id || !targetIds.has(id)) continue;
+      if (localName === "commentReference" && runIsOnlyCommentReference(node.parentNode)) {
+        if (removeNode(node.parentNode)) {
+          removed += 1;
+        }
+        continue;
+      }
+      if (removeNode(node)) {
+        removed += 1;
+      }
+    }
+  }
+  return removed;
+}
+function deleteCommentsByAuthorInOoxml(oxml, options = {}) {
+  const warnings = [];
+  const filter = resolveAuthorFilter(options);
+  if (!filter.valid) {
+    return {
+      oxml,
+      hasChanges: false,
+      commentsRemoved: 0,
+      referencesRemoved: 0,
+      warnings: [filter.warning]
+    };
+  }
+  const parseResult = parseXmlWithWarnings(oxml, "Failed to parse OOXML");
+  if (!parseResult.xmlDoc) {
+    return {
+      oxml,
+      hasChanges: false,
+      commentsRemoved: 0,
+      referencesRemoved: 0,
+      warnings: [parseResult.warning]
+    };
+  }
+  const { xmlDoc, serializer } = parseResult;
+  const { targetIds, commentNodes } = collectCommentTargetIds(xmlDoc, filter);
+  if (filter.allAuthors) {
+    for (const localName of ["commentRangeStart", "commentRangeEnd", "commentReference"]) {
+      for (const node of getWordElementsByLocalName(xmlDoc, localName)) {
+        const id = getAttributeByLocalName(node, "id");
+        if (id) targetIds.add(id);
+      }
+    }
+  }
+  const commentsRemoved = removeCommentNodesById(commentNodes, targetIds);
+  const referencesRemoved = removeCommentAnchors(xmlDoc, targetIds);
+  return {
+    oxml: serializer.serializeToString(xmlDoc),
+    hasChanges: commentsRemoved > 0 || referencesRemoved > 0,
+    commentsRemoved,
+    referencesRemoved,
+    warnings
+  };
+}
+
 // engine/formatting-removal.js
 function removeFormattingFromRPr(rPr, formatTypes = ["all"]) {
   if (!rPr) return null;
@@ -8714,6 +9014,7 @@ export {
   RoutePlanKind,
   RunKind,
   WORD_MAIN_NS,
+  acceptTrackedChangesInOoxml,
   applyFormattingRemovalToOoxml,
   applyHighlightToOoxml,
   applyRedlineToOxml2 as applyRedlineToOxml,
@@ -8730,6 +9031,7 @@ export {
   configureLogger,
   configureXmlProvider,
   createDynamicNumberingIdState,
+  deleteCommentsByAuthorInOoxml,
   enforceListBindingOnParagraphNodes,
   ensureCommentsArtifactsInZip,
   ensureNumberingArtifactsInZip,
@@ -8775,6 +9077,7 @@ export {
   preprocessMarkdown,
   reconcileMarkdownTableOoxml,
   recordSingleLineListFallbackExplicitSequence,
+  rejectTrackedChangesInOoxml,
   remapNumberingPayloadForDocument,
   removeFormattingFromRPr,
   reserveNextNumberingId,