bun-docx 0.6.1 → 0.7.0

package/dist/index.js

@@ -13570,36 +13570,81 @@ var init_xml_node = __esm(() => {
 });
 
 // src/core/parser/run-ops.ts
+function isSubtractiveTrackedChangeWrapper(tag) {
+  return tag === "w:del" || tag === "w:moveFrom";
+}
 function runTextLength(run) {
   let total = 0;
   for (const child of run.children) {
     if (child.tag === "w:t")
       total += child.collectText().length;
+    else if (SINGLE_CHAR_TAGS.has(child.tag))
+      total += 1;
   }
   return total;
 }
 function sliceRun(run, start, end) {
   const sliced = new XmlNode2("w:r", { ...run.attributes });
-  let consumed = 0;
+  let offset = 0;
   for (const child of run.children) {
-    if (child.tag === "w:t") {
+    if (child.tag === "w:rPr") {
+      sliced.children.push(child.clone());
+      continue;
+    }
+    if (child.tag === "w:t" || child.tag === "w:delText") {
       const text = child.collectText();
-      const localStart = Math.max(0, start - consumed);
-      const localEnd = Math.min(text.length, end - consumed);
+      const localStart = Math.max(0, start - offset);
+      const localEnd = Math.min(text.length, end - offset);
       if (localStart < localEnd) {
-        const slicedText = new XmlNode2("w:t", { "xml:space": "preserve" });
+        const slicedText = new XmlNode2(child.tag, { "xml:space": "preserve" });
         slicedText.children.push(XmlNode2.textNode(text.slice(localStart, localEnd)));
         sliced.children.push(slicedText);
       }
-      consumed += text.length;
+      offset += text.length;
       continue;
     }
-    sliced.children.push(child.clone());
+    if (SINGLE_CHAR_TAGS.has(child.tag)) {
+      if (offset >= start && offset < end) {
+        sliced.children.push(child.clone());
+      }
+      offset += 1;
+      continue;
+    }
+    if (offset >= start && offset < end) {
+      sliced.children.push(child.clone());
+    }
   }
   return sliced;
 }
+function isRunBearingWrapper(tag) {
+  return RUN_BEARING_WRAPPER_TAGS.has(tag);
+}
+function sumRunBearingTextLength(children) {
+  let total = 0;
+  for (const child of children) {
+    if (child.tag === "w:r") {
+      total += runTextLength(child);
+      continue;
+    }
+    if (isRunBearingWrapper(child.tag)) {
+      total += sumRunBearingTextLength(child.children);
+    }
+  }
+  return total;
+}
+var SINGLE_CHAR_TAGS, RUN_BEARING_WRAPPER_TAGS;
 var init_run_ops = __esm(() => {
   init_xml_node();
+  SINGLE_CHAR_TAGS = new Set(["w:noBreakHyphen", "w:softHyphen", "w:sym"]);
+  RUN_BEARING_WRAPPER_TAGS = new Set([
+    "w:ins",
+    "w:del",
+    "w:moveFrom",
+    "w:moveTo",
+    "w:hyperlink",
+    "w:fldSimple",
+    "w:smartTag"
+  ]);
 });
 
 // src/core/parser/index.ts
@@ -13760,6 +13805,311 @@ var init_package = __esm(() => {
   };
 });
 
+// src/core/ast/sym.ts
+function decodeSym(font, charHex) {
+  const codepoint = Number.parseInt(charHex, 16);
+  if (!Number.isFinite(codepoint))
+    return "";
+  const fontKey = font.toLowerCase().trim();
+  const table = TABLES.get(fontKey);
+  if (table) {
+    const mapped = table.get(codepoint);
+    if (mapped !== undefined)
+      return mapped;
+  }
+  if (table && codepoint >= 61440 && codepoint <= 61695) {
+    const aliased = table.get(codepoint - 61440);
+    if (aliased !== undefined)
+      return aliased;
+  }
+  if (table && codepoint >= 32 && codepoint <= 255) {
+    const aliased = table.get(codepoint + 61440);
+    if (aliased !== undefined)
+      return aliased;
+  }
+  try {
+    return String.fromCodePoint(codepoint);
+  } catch {
+    return "";
+  }
+}
+var SYMBOL, WINGDINGS, WINGDINGS_2, WEBDINGS, ZAPF_DINGBATS, TABLES;
+var init_sym = __esm(() => {
+  SYMBOL = [
+    [33, "!"],
+    [34, "\u2200"],
+    [35, "#"],
+    [36, "\u2203"],
+    [37, "%"],
+    [38, "&"],
+    [39, "\u220B"],
+    [40, "("],
+    [41, ")"],
+    [42, "\u2217"],
+    [43, "+"],
+    [44, ","],
+    [45, "\u2212"],
+    [46, "."],
+    [47, "/"],
+    [48, "0"],
+    [49, "1"],
+    [50, "2"],
+    [51, "3"],
+    [52, "4"],
+    [53, "5"],
+    [54, "6"],
+    [55, "7"],
+    [56, "8"],
+    [57, "9"],
+    [58, ":"],
+    [59, ";"],
+    [60, "<"],
+    [61, "="],
+    [62, ">"],
+    [63, "?"],
+    [64, "\u2245"],
+    [65, "\u0391"],
+    [66, "\u0392"],
+    [67, "\u03A7"],
+    [68, "\u0394"],
+    [69, "\u0395"],
+    [70, "\u03A6"],
+    [71, "\u0393"],
+    [72, "\u0397"],
+    [73, "\u0399"],
+    [74, "\u03D1"],
+    [75, "\u039A"],
+    [76, "\u039B"],
+    [77, "\u039C"],
+    [78, "\u039D"],
+    [79, "\u039F"],
+    [80, "\u03A0"],
+    [81, "\u0398"],
+    [82, "\u03A1"],
+    [83, "\u03A3"],
+    [84, "\u03A4"],
+    [85, "\u03A5"],
+    [86, "\u03C2"],
+    [87, "\u03A9"],
+    [88, "\u039E"],
+    [89, "\u03A8"],
+    [90, "\u0396"],
+    [91, "["],
+    [92, "\u2234"],
+    [93, "]"],
+    [94, "\u22A5"],
+    [95, "_"],
+    [96, "\u203E"],
+    [97, "\u03B1"],
+    [98, "\u03B2"],
+    [99, "\u03C7"],
+    [100, "\u03B4"],
+    [101, "\u03B5"],
+    [102, "\u03C6"],
+    [103, "\u03B3"],
+    [104, "\u03B7"],
+    [105, "\u03B9"],
+    [106, "\u03D5"],
+    [107, "\u03BA"],
+    [108, "\u03BB"],
+    [109, "\u03BC"],
+    [110, "\u03BD"],
+    [111, "\u03BF"],
+    [112, "\u03C0"],
+    [113, "\u03B8"],
+    [114, "\u03C1"],
+    [115, "\u03C3"],
+    [116, "\u03C4"],
+    [117, "\u03C5"],
+    [118, "\u03D6"],
+    [119, "\u03C9"],
+    [120, "\u03BE"],
+    [121, "\u03C8"],
+    [122, "\u03B6"],
+    [123, "{"],
+    [124, "|"],
+    [125, "}"],
+    [126, "\u223C"],
+    [160, "\u20AC"],
+    [161, "\u03D2"],
+    [162, "\u2032"],
+    [163, "\u2264"],
+    [164, "\u2044"],
+    [165, "\u221E"],
+    [166, "\u0192"],
+    [167, "\u2663"],
+    [168, "\u2666"],
+    [169, "\u2665"],
+    [170, "\u2660"],
+    [171, "\u2194"],
+    [172, "\u2190"],
+    [173, "\u2191"],
+    [174, "\u2192"],
+    [175, "\u2193"],
+    [176, "\xB0"],
+    [177, "\xB1"],
+    [178, "\u2033"],
+    [179, "\u2265"],
+    [180, "\xD7"],
+    [181, "\u221D"],
+    [182, "\u2202"],
+    [183, "\u2022"],
+    [184, "\xF7"],
+    [185, "\u2260"],
+    [186, "\u2261"],
+    [187, "\u2248"],
+    [188, "\u2026"],
+    [189, "|"],
+    [190, "\u2014"],
+    [191, "\u21B5"],
+    [192, "\u2135"],
+    [193, "\u2111"],
+    [194, "\u211C"],
+    [195, "\u2118"],
+    [196, "\u2297"],
+    [197, "\u2295"],
+    [198, "\u2205"],
+    [199, "\u2229"],
+    [200, "\u222A"],
+    [201, "\u2283"],
+    [202, "\u2287"],
+    [203, "\u2284"],
+    [204, "\u2282"],
+    [205, "\u2286"],
+    [206, "\u2208"],
+    [207, "\u2209"],
+    [208, "\u2220"],
+    [209, "\u2207"],
+    [210, "\xAE"],
+    [211, "\xA9"],
+    [212, "\u2122"],
+    [213, "\u220F"],
+    [214, "\u221A"],
+    [215, "\xB7"],
+    [216, "\xAC"],
+    [217, "\u2227"],
+    [218, "\u2228"],
+    [219, "\u21D4"],
+    [220, "\u21D0"],
+    [221, "\u21D1"],
+    [222, "\u21D2"],
+    [223, "\u21D3"],
+    [224, "\u25CA"],
+    [225, "\u27E8"],
+    [229, "\u2211"],
+    [241, "\u27E9"],
+    [242, "\u222B"]
+  ];
+  WINGDINGS = [
+    [61474, "\u2702"],
+    [61479, "\u260E"],
+    [61480, "\u2706"],
+    [61481, "\u2709"],
+    [61501, "\u231B"],
+    [61514, "\u263A"],
+    [61515, "\uD83D\uDE10"],
+    [61516, "\u2639"],
+    [61519, "\u2620"],
+    [61520, "\uD83C\uDFF3"],
+    [61521, "\uD83C\uDFF4"],
+    [61528, "\u261C"],
+    [61529, "\u261E"],
+    [61530, "\u261D"],
+    [61531, "\u261F"],
+    [61548, "\u2751"],
+    [61549, "\u2752"],
+    [61550, "\u25AA"],
+    [61551, "\u25A1"],
+    [61553, "\u25C6"],
+    [61555, "\u25CF"],
+    [61556, "\u25A0"],
+    [61557, "\u25CF"],
+    [61558, "\u25C6"],
+    [61559, "\u2756"],
+    [61607, "\u25AA"],
+    [61608, "\u25AB"],
+    [61664, "\u2190"],
+    [61665, "\u2192"],
+    [61666, "\u2191"],
+    [61667, "\u2193"],
+    [61668, "\u2196"],
+    [61669, "\u2197"],
+    [61670, "\u2198"],
+    [61671, "\u2199"],
+    [61672, "\u2194"],
+    [61673, "\u2195"],
+    [61690, "\u2713"],
+    [61691, "\u2713"],
+    [61692, "\u2713"],
+    [61693, "\u2717"],
+    [61694, "\u2717"]
+  ];
+  WINGDINGS_2 = [
+    [61520, "\u25B6"],
+    [61521, "\u25C0"],
+    [61522, "\u25B2"],
+    [61523, "\u25BC"],
+    [61656, "\u2752"],
+    [61657, "\u2610"],
+    [61691, "\u2611"],
+    [61692, "\u2612"],
+    [61693, "\u2713"],
+    [61694, "\u2717"],
+    [61695, "\u2718"]
+  ];
+  WEBDINGS = [
+    [61473, "\uD83D\uDD77"],
+    [61476, "\uD83D\uDC41"],
+    [61477, "\uD83D\uDC42"],
+    [61490, "\uD83C\uDF10"],
+    [61497, "\u2709"],
+    [61500, "\uD83D\uDCC5"],
+    [61504, "\uD83C\uDFE0"],
+    [61514, "\uD83D\uDCDE"],
+    [61528, "\uD83D\uDD0D"],
+    [61543, "\uD83D\uDD12"],
+    [61544, "\uD83D\uDD13"],
+    [61560, "\u270F"],
+    [61604, "\u2605"]
+  ];
+  ZAPF_DINGBATS = [
+    [33, "\u2701"],
+    [34, "\u2702"],
+    [35, "\u2703"],
+    [36, "\u2704"],
+    [43, "\u271A"],
+    [51, "\u2713"],
+    [52, "\u2714"],
+    [53, "\u2715"],
+    [54, "\u2716"],
+    [55, "\u2717"],
+    [56, "\u2718"],
+    [57, "\u2719"],
+    [58, "\u271A"],
+    [59, "\u271B"],
+    [60, "\u271C"],
+    [74, "\u2740"],
+    [75, "\u2741"],
+    [76, "\u2742"],
+    [77, "\u2743"],
+    [78, "\u2744"],
+    [79, "\u2745"],
+    [108, "\u25CF"],
+    [110, "\u25A0"],
+    [113, "\u25C6"]
+  ];
+  TABLES = new Map([
+    ["symbol", new Map(SYMBOL)],
+    ["wingdings", new Map(WINGDINGS)],
+    ["wingdings 2", new Map(WINGDINGS_2)],
+    ["wingdings 3", new Map(WINGDINGS_2)],
+    ["webdings", new Map(WEBDINGS)],
+    ["zapfdingbats", new Map(ZAPF_DINGBATS)],
+    ["zapf dingbats", new Map(ZAPF_DINGBATS)],
+    ["itc zapf dingbats", new Map(ZAPF_DINGBATS)]
+  ]);
+});
+
 // src/core/ast/read.ts
 function buildDoc(view, path) {
   readRelationships(view);
@@ -13775,6 +14125,7 @@ function buildDoc(view, path) {
   const state = {
     imageIndex: 0,
     hyperlinkIndex: 0,
+    trackedChangeIndex: 0,
     commentAnchors: new Map,
     openComments: new Map
   };
@@ -13870,8 +14221,8 @@ function walkRunContainer(context, container, trackedChange, hyperlink) {
       continue;
     }
     if (child.tag === "w:r") {
-      const run = readRun(context.view, child, context.activeComments, trackedChange, hyperlink, context.state);
-      if (run) {
+      const runs = readRun(context.view, child, context.activeComments, trackedChange, hyperlink, context.state);
+      for (const run of runs) {
         if (run.type === "text")
           context.offsetRef.value += run.text.length;
         context.paragraph.runs.push(run);
@@ -13900,19 +14251,30 @@ function walkRunContainer(context, container, trackedChange, hyperlink) {
       }
       continue;
     }
-    if (child.tag === "w:ins" || child.tag === "w:del") {
+    if (child.tag === "w:ins" || child.tag === "w:del" || child.tag === "w:moveFrom" || child.tag === "w:moveTo") {
+      const trackedChangeId = `tc${context.state.trackedChangeIndex++}`;
       const change = {
-        kind: child.tag === "w:ins" ? "ins" : "del",
+        id: trackedChangeId,
+        kind: TRACKED_CHANGE_KIND_BY_TAG[child.tag],
         author: child.getAttribute("w:author") ?? "",
         date: child.getAttribute("w:date") ?? "",
         revisionId: child.getAttribute("w:id") ?? ""
       };
+      context.view.trackedChangeReferences.set(trackedChangeId, {
+        node: child,
+        parent: container.children,
+        blockId: context.blockId
+      });
       walkRunContainer(context, child, change, hyperlink);
       continue;
     }
     if (child.tag === "w:hyperlink") {
       const link = readHyperlinkProperties(context.view, child, container.children, context.state);
       walkRunContainer(context, child, trackedChange, link);
+      continue;
+    }
+    if (child.tag === "w:fldSimple" || child.tag === "w:smartTag") {
+      walkRunContainer(context, child, trackedChange, hyperlink);
     }
   }
 }
@@ -13967,48 +14329,83 @@ function applyParagraphProperties(paragraph, paragraphProperties) {
 }
 function readRun(view, node, activeComments, trackedChange, hyperlink, state) {
   const runProperties = node.findChild("w:rPr");
+  const out = [];
+  let pendingText = "";
+  function flushText() {
+    if (pendingText.length === 0)
+      return;
+    const run = { type: "text", text: pendingText };
+    if (runProperties)
+      applyRunProperties(run, runProperties);
+    if (activeComments.size > 0)
+      run.comments = [...activeComments];
+    if (trackedChange)
+      run.trackedChange = trackedChange;
+    if (hyperlink)
+      run.hyperlink = hyperlink;
+    out.push(run);
+    pendingText = "";
+  }
   for (const child of node.children) {
+    if (child.tag === "w:rPr")
+      continue;
+    if (child.tag === "w:t" || child.tag === "w:delText") {
+      pendingText += child.collectText();
+      continue;
+    }
+    if (child.tag === "w:noBreakHyphen") {
+      pendingText += "\u2011";
+      continue;
+    }
+    if (child.tag === "w:softHyphen") {
+      pendingText += "\xAD";
+      continue;
+    }
+    if (child.tag === "w:sym") {
+      const font = child.getAttribute("w:font") ?? "";
+      const charHex = child.getAttribute("w:char") ?? "";
+      pendingText += decodeSym(font, charHex);
+      continue;
+    }
     if (child.tag === "w:drawing") {
+      flushText();
       const drawing = readDrawing(view, child, state);
       if (drawing)
-        return drawing;
+        out.push(drawing);
+      continue;
     }
-    if (child.tag === "w:br") {
-      const kind = child.getAttribute("w:type") ?? "line";
-      return { type: "break", kind };
+    if (child.tag === "w:pict" || child.tag === "w:object") {
+      flushText();
+      out.push({ type: "chart", kind: "drawing" });
+      continue;
     }
-    if (child.tag === "w:tab") {
-      return { type: "tab" };
+    if (child.tag === "w:br" || child.tag === "w:cr") {
+      flushText();
+      const kind = child.tag === "w:cr" ? "line" : child.getAttribute("w:type") ?? "line";
+      out.push({ type: "break", kind });
+      continue;
+    }
+    if (child.tag === "w:tab" || child.tag === "w:ptab") {
+      flushText();
+      out.push({ type: "tab" });
+      continue;
     }
     if (child.tag === "w:footnoteReference") {
+      flushText();
       const id = child.getAttribute("w:id");
       if (id)
-        return { type: "footnoteRef", kind: "footnote", id: `fn${id}` };
+        out.push({ type: "footnoteRef", kind: "footnote", id: `fn${id}` });
+      continue;
     }
     if (child.tag === "w:endnoteReference") {
+      flushText();
       const id = child.getAttribute("w:id");
       if (id)
-        return { type: "footnoteRef", kind: "endnote", id: `en${id}` };
-    }
-  }
-  let combinedText = "";
-  for (const child of node.children) {
-    if (child.tag === "w:t" || child.tag === "w:delText") {
-      combinedText += child.collectText();
+        out.push({ type: "footnoteRef", kind: "endnote", id: `en${id}` });
     }
   }
-  if (combinedText.length === 0)
-    return null;
-  const run = { type: "text", text: combinedText };
-  if (runProperties)
-    applyRunProperties(run, runProperties);
-  if (activeComments.size > 0)
-    run.comments = [...activeComments];
-  if (trackedChange)
-    run.trackedChange = trackedChange;
-  if (hyperlink)
-    run.hyperlink = hyperlink;
-  return run;
+  flushText();
+  return out;
 }
 function readDrawing(view, drawing, state) {
   const image = readImageFromDrawing(view, drawing, state);
@@ -14307,9 +14704,16 @@ function readNotes(tree, rootTag, itemTag, idPrefix) {
   }
   return out;
 }
-var RELATIONSHIP_NAMESPACE_IMAGE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image", RELATIONSHIP_NAMESPACE_HYPERLINK = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink";
+var RELATIONSHIP_NAMESPACE_IMAGE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image", RELATIONSHIP_NAMESPACE_HYPERLINK = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink", TRACKED_CHANGE_KIND_BY_TAG;
 var init_read = __esm(() => {
   init_parser();
+  init_sym();
+  TRACKED_CHANGE_KIND_BY_TAG = {
+    "w:ins": "ins",
+    "w:del": "del",
+    "w:moveFrom": "moveFrom",
+    "w:moveTo": "moveTo"
+  };
 });
 
 // src/core/ast/doc-view.ts
@@ -14341,7 +14745,8 @@ async function openDocView(path) {
     imagesByRelationshipId: new Map,
     imageById: new Map,
     hyperlinksByRelationshipId: new Map,
-    hyperlinkById: new Map
+    hyperlinkById: new Map,
+    trackedChangeReferences: new Map
   };
   view.doc = buildDoc(view, pkg.path);
   return view;
@@ -14420,6 +14825,30 @@ function paragraphText(paragraph) {
   }
   return out;
 }
+function paragraphTextAccepted(paragraph) {
+  let out = "";
+  for (const run of paragraph.runs) {
+    if (run.type !== "text")
+      continue;
+    const kind = run.trackedChange?.kind;
+    if (kind === "del" || kind === "moveFrom")
+      continue;
+    out += run.text;
+  }
+  return out;
+}
+function paragraphTextBaseline(paragraph) {
+  let out = "";
+  for (const run of paragraph.runs) {
+    if (run.type !== "text")
+      continue;
+    const kind = run.trackedChange?.kind;
+    if (kind === "ins" || kind === "moveTo")
+      continue;
+    out += run.text;
+  }
+  return out;
+}
 function flattenParagraphs(blocks) {
   const out = [];
   for (const block of blocks) {
@@ -14475,6 +14904,13 @@ function parseLocator(input) {
   if (linkMatch) {
     return { kind: "hyperlink", hyperlinkId: `link${linkMatch[1]}` };
   }
+  const trackedChangeMatch = trimmed.match(TRACKED_CHANGE_RE);
+  if (trackedChangeMatch) {
+    return {
+      kind: "trackedChange",
+      trackedChangeId: `tc${trackedChangeMatch[1]}`
+    };
+  }
   const cellMatch = trimmed.match(CELL_RE);
   if (cellMatch) {
     const [, tableIndex, rowIndex, columnIndex, rest] = cellMatch;
@@ -14523,7 +14959,7 @@ function validateOffsets(input, start, end, crossBlock) {
     throw new LocatorParseError(input, "end offset precedes start");
   }
 }
-var LocatorParseError, BLOCK_RE, SPAN_RE, RANGE_RE, COMMENT_RE, IMAGE_RE, LINK_RE, CELL_RE;
+var LocatorParseError, BLOCK_RE, SPAN_RE, RANGE_RE, COMMENT_RE, IMAGE_RE, LINK_RE, TRACKED_CHANGE_RE, CELL_RE;
 var init_parse = __esm(() => {
   LocatorParseError = class LocatorParseError extends Error {
     input;
@@ -14539,6 +14975,7 @@ var init_parse = __esm(() => {
   COMMENT_RE = /^c(\d+)$/;
   IMAGE_RE = /^img(\d+)$/;
   LINK_RE = /^link(\d+)$/;
+  TRACKED_CHANGE_RE = /^tc(\d+)$/;
   CELL_RE = /^t(\d+):r(\d+)c(\d+)(?::(.+))?$/;
 });
 
@@ -14658,7 +15095,7 @@ function convertTextToDelText(node) {
 function computeMaxRevisionId(view) {
   let max = -1;
   walkXml(view.documentTree, (node) => {
-    if (node.tag !== "w:ins" && node.tag !== "w:del")
+    if (node.tag !== "w:ins" && node.tag !== "w:del" && node.tag !== "w:moveFrom" && node.tag !== "w:moveTo")
       return;
     const idAttr = node.getAttribute("w:id");
     if (!idAttr)
@@ -14946,6 +15383,7 @@ function exitCodeFor(code) {
     case "COMMENT_NOT_FOUND":
     case "IMAGE_NOT_FOUND":
     case "HYPERLINK_NOT_FOUND":
+    case "TRACKED_CHANGE_NOT_FOUND":
     case "MATCH_NOT_FOUND":
       return EXIT.NOT_FOUND;
     case "NOT_A_ZIP":
@@ -15065,18 +15503,7 @@ function ensureCommentsExtPart(view) {
   return root;
 }
 function paragraphTextLength(paragraph) {
-  return sumTextLength(paragraph.children);
-}
-function sumTextLength(children) {
-  let total = 0;
-  for (const child of children) {
-    if (child.tag === "w:r")
-      total += runTextLength(child);
-    else if (child.tag === "w:ins" || child.tag === "w:del" || child.tag === "w:hyperlink") {
-      total += sumTextLength(child.children);
-    }
-  }
-  return total;
+  return sumRunBearingTextLength(paragraph.children);
 }
 function addCommentMarkersToParagraph(paragraph, commentId, span) {
   const total = paragraphTextLength(paragraph);
@@ -15121,7 +15548,7 @@ function addCommentMarkersAroundRun(paragraph, target, commentId) {
         children.splice(index, 1, commentRangeStartMarker(commentId), target, commentRangeEndMarker(commentId), commentReferenceRun(commentId));
         return true;
       }
-      if (child && (child.tag === "w:ins" || child.tag === "w:del" || child.tag === "w:hyperlink")) {
+      if (child && isRunBearingWrapper(child.tag)) {
         if (walk(child))
           return true;
       }
@@ -15137,7 +15564,7 @@ function findElementOffsetsInParagraph(paragraph, target) {
     for (const child of children) {
       if (child === target) {
         const start = cursor;
-        cursor += sumTextLength([child]);
+        cursor += sumRunBearingTextLength([child]);
         result = { start, end: cursor };
         return true;
       }
@@ -15145,7 +15572,7 @@ function findElementOffsetsInParagraph(paragraph, target) {
         cursor += runTextLength(child);
         continue;
       }
-      if (child.tag === "w:ins" || child.tag === "w:del" || child.tag === "w:hyperlink") {
+      if (isRunBearingWrapper(child.tag)) {
         if (walk(child.children))
           return true;
       }
@@ -15286,7 +15713,7 @@ function walkAndPlace(children, pending, state) {
       state.offset = runEnd;
       continue;
     }
-    if (child.tag === "w:ins" || child.tag === "w:del" || child.tag === "w:hyperlink") {
+    if (isRunBearingWrapper(child.tag)) {
       flushAtCurrentOffset(result, pending, state);
       const innerChildren = walkAndPlace(child.children, pending, state);
       const wrapper = new XmlNode2(child.tag, { ...child.attributes });
@@ -16794,10 +17221,9 @@ function trackedChangesOverlapping(paragraph, start, end) {
     const change = run10.trackedChange;
     if (!change)
       continue;
-    const key = `${change.kind}:${change.revisionId}:${change.author}`;
-    if (seen.has(key))
+    if (seen.has(change.id))
       continue;
-    seen.add(key);
+    seen.add(change.id);
     out.push(change);
   }
   return out;
@@ -16955,20 +17381,8 @@ function wrapSpanInHyperlink(paragraph, span, relationshipId) {
       }
       continue;
     }
-    if (child.tag === "w:hyperlink") {
-      const hyperlinkLength = sumInnerRunLengths(child);
-      const hyperlinkStart = offset;
-      const hyperlinkEnd = offset + hyperlinkLength;
-      offset = hyperlinkEnd;
-      if (hyperlinkEnd <= span.start || hyperlinkStart >= span.end) {
-        placeWrapper();
-        newChildren.push(child);
-        continue;
-      }
-      throw new HyperlinkWrapError(`Span ${span.start}-${span.end} overlaps an existing hyperlink at ${hyperlinkStart}-${hyperlinkEnd}; nested hyperlinks are not allowed`);
-    }
-    if (child.tag === "w:ins" || child.tag === "w:del") {
-      const innerLength = sumInnerRunLengths(child);
+    if (isRunBearingWrapper(child.tag)) {
+      const innerLength = sumRunBearingTextLength(child.children);
       const wrapperStart = offset;
       const wrapperEnd = offset + innerLength;
       offset = wrapperEnd;
@@ -16977,27 +17391,28 @@ function wrapSpanInHyperlink(paragraph, span, relationshipId) {
         newChildren.push(child);
         continue;
       }
-      throw new HyperlinkWrapError(`Span ${span.start}-${span.end} crosses a tracked-change wrapper at ${wrapperStart}-${wrapperEnd}; resolve or accept the change first`);
+      throw new HyperlinkWrapError(messageForOverlap(child.tag, span));
     }
     newChildren.push(child);
   }
   placeWrapper();
   paragraph.children = newChildren;
 }
+function messageForOverlap(tag, span) {
+  if (tag === "w:hyperlink") {
+    return `Span ${span.start}-${span.end} overlaps an existing hyperlink; nested hyperlinks are not allowed`;
+  }
+  if (tag === "w:ins" || tag === "w:del" || tag === "w:moveFrom" || tag === "w:moveTo") {
+    return `Span ${span.start}-${span.end} crosses a tracked-change wrapper (${tag}); resolve or accept the change first`;
+  }
+  return `Span ${span.start}-${span.end} crosses a ${tag} wrapper; cannot wrap a hyperlink across it`;
+}
 function hyperlinkWrapper(relationshipId, runs) {
   return /* @__PURE__ */ jsxDEV(w.hyperlink, {
     "r:id": relationshipId,
     children: runs
   }, undefined, false, undefined, this);
 }
-function sumInnerRunLengths(wrapper) {
-  let total = 0;
-  for (const inner of wrapper.children) {
-    if (inner.tag === "w:r")
-      total += runTextLength(inner);
-  }
-  return total;
-}
 var HyperlinkWrapError;
 var init_wrap = __esm(() => {
   init_jsx();
@@ -17131,7 +17546,9 @@ Optional:
   -h, --help        Show this help
 
 The span must lie inside a single paragraph and must not overlap an existing
-hyperlink or a tracked-change wrapper.
+hyperlink, a tracked-change wrapper (<w:ins>/<w:del>/<w:moveFrom>/<w:moveTo>),
+or any other run-bearing wrapper that we model. Resolve or accept the
+wrapper first, then add the hyperlink.
 
 When track-changes is on, an audit comment is anchored to the wrapped span
 since OOXML has no native tracked-change form for hyperlink edits.
@@ -18168,12 +18585,22 @@ export type Footnote = {
 };
 
 export type TrackedChange = {
-	kind: "ins" | "del";
+	id: string;
+	kind: TrackedChangeKind;
 	author: string;
 	date: string;
 	revisionId: string;
 };
 
+/** OOXML revision-tracking wrappers we surface in the AST.
+ *  - \`ins\` / \`del\`: <w:ins> / <w:del> \u2014 inserted / deleted runs.
+ *  - \`moveFrom\` / \`moveTo\`: <w:moveFrom> / <w:moveTo> \u2014 origin / destination
+ *    of a tracked move. moveFrom behaves like a delete (text leaves this
+ *    location, stored as <w:delText> internally); moveTo behaves like an
+ *    insert (text arrives at this location).
+ */
+export type TrackedChangeKind = "ins" | "del" | "moveFrom" | "moveTo";
+
 export type Comment = {
 	id: string;
 	author: string;
@@ -18330,9 +18757,10 @@ var init_schema = __esm(() => {
           comments: { type: "array", items: { type: "string" } },
           trackedChange: {
             type: "object",
-            required: ["kind", "author", "date", "revisionId"],
+            required: ["id", "kind", "author", "date", "revisionId"],
             properties: {
-              kind: { enum: ["ins", "del"] },
+              id: { type: "string" },
+              kind: { enum: ["ins", "del", "moveFrom", "moveTo"] },
               author: { type: "string" },
               date: { type: "string" },
               revisionId: { type: "string" }
@@ -18538,6 +18966,8 @@ Entity locators:
   cN              Comment id (e.g., c0)
   imgN            Image id (e.g., img2)
   linkN           Hyperlink id (e.g., link0)
+  tcN             Tracked change id (e.g., tc0) \u2014 the Nth revision wrapper
+                  (<w:ins>/<w:del>/<w:moveFrom>/<w:moveTo>) in document order
   tN:rRcC         Cell at row R, column C of table tN
 
 Examples:
@@ -18547,6 +18977,7 @@ Examples:
   c1              -> comment c1
   img0            -> image img0
   link0           -> hyperlink link0
+  tc0             -> first tracked change in the document
   t0:r1c2         -> cell at row 1, col 2 of table t0
   t0:r1c2:p0      -> first paragraph of that cell
   t0:r1c2:p0:5-10 -> chars 5..10 of that paragraph
@@ -18580,6 +19011,7 @@ var init_locators2 = __esm(() => {
       comment: { syntax: "cN", example: "c1" },
       image: { syntax: "imgN", example: "img0" },
       hyperlink: { syntax: "linkN", example: "link0" },
+      trackedChange: { syntax: "tcN", example: "tc0" },
       cell: { syntax: "tN:rRcC", example: "t0:r1c2" },
       nestedCell: { syntax: "tN:rRcC:pK", example: "t0:r1c2:p0" }
     },
@@ -19001,7 +19433,8 @@ function renderMarkdown(doc, options = {}) {
     options,
     commentIndex,
     referencedFootnoteIds: new Set,
-    referencedEndnoteIds: new Set
+    referencedEndnoteIds: new Set,
+    referencedTrackedChanges: new Map
   };
   const parts = [];
   for (const block of blocks) {
@@ -19021,6 +19454,9 @@ function renderMarkdown(doc, options = {}) {
   const endnoteDefs = renderNoteDefinitions(doc.endnotes, ctx.referencedEndnoteIds);
   if (endnoteDefs.length > 0)
     definitions.push(endnoteDefs);
+  const trackedChangeDefs = renderTrackedChangeFootnotes(ctx.referencedTrackedChanges);
+  if (trackedChangeDefs.length > 0)
+    definitions.push(trackedChangeDefs);
   if (definitions.length > 0)
     parts.push(definitions.join(`
 `));
@@ -19038,8 +19474,18 @@ function emptyCommentIndex() {
     orderedIds: []
   };
 }
+function isRunVisible(run25, view) {
+  const kind = run25.trackedChange?.kind;
+  if (!kind)
+    return true;
+  if (view === "accepted" && (kind === "del" || kind === "moveFrom"))
+    return false;
+  if (view === "baseline" && (kind === "ins" || kind === "moveTo"))
+    return false;
+  return true;
+}
 function buildCommentIndex(blocks, options) {
-  const showChanges = options.showChanges ?? false;
+  const view = options.view ?? "current";
   const lastSlot = new Map;
   const spanText = new Map;
   const orderedIds = [];
@@ -19047,7 +19493,7 @@ function buildCommentIndex(blocks, options) {
     paragraph.runs.forEach((run25, index) => {
       if (run25.type !== "text")
         return;
-      if (!showChanges && run25.trackedChange?.kind === "del")
+      if (!isRunVisible(run25, view))
         return;
       for (const commentId of run25.comments ?? []) {
         if (!spanText.has(commentId))
@@ -19111,12 +19557,11 @@ function headingLevelFor(style) {
   return parsed;
 }
 function renderRuns(paragraphId, runs, ctx) {
-  const showChanges = ctx.options.showChanges ?? false;
+  const view = ctx.options.view ?? "current";
   const visibleEntries = [];
   runs.forEach((run25, index) => {
-    if (!showChanges && run25.type === "text" && run25.trackedChange?.kind === "del") {
+    if (run25.type === "text" && !isRunVisible(run25, view))
       return;
-    }
     visibleEntries.push({ run: run25, originalIndex: index });
   });
   let out = "";
@@ -19139,7 +19584,15 @@ function renderRuns(paragraphId, runs, ctx) {
         lookahead++;
       }
       const segment = visibleEntries.slice(cursor, lookahead);
-      out += renderTextSegment(segment.map((entry2) => entry2.run), showChanges);
+      const segmentRuns = segment.map((entry2) => entry2.run);
+      out += renderTextSegment(segmentRuns, view);
+      if (view === "current") {
+        for (const segmentRun of segmentRuns) {
+          if (segmentRun.trackedChange) {
+            ctx.referencedTrackedChanges.set(segmentRun.trackedChange.id, segmentRun.trackedChange);
+          }
+        }
+      }
       out += commentEndingsFor(paragraphId, segment, ctx.commentIndex);
       cursor = lookahead;
       continue;
@@ -19182,7 +19635,7 @@ function commentEndingsFor(paragraphId, segment, commentIndex) {
   return out;
 }
 function sameDecoration(a2, b) {
-  return (a2.bold ?? false) === (b.bold ?? false) && (a2.italic ?? false) === (b.italic ?? false) && (a2.strike ?? false) === (b.strike ?? false) && (a2.underline ?? "") === (b.underline ?? "") && (a2.color ?? "") === (b.color ?? "") && (a2.highlight ?? "") === (b.highlight ?? "") && a2.hyperlink?.id === b.hyperlink?.id && a2.trackedChange?.kind === b.trackedChange?.kind && sameCommentSet(a2.comments, b.comments);
+  return (a2.bold ?? false) === (b.bold ?? false) && (a2.italic ?? false) === (b.italic ?? false) && (a2.strike ?? false) === (b.strike ?? false) && (a2.underline ?? "") === (b.underline ?? "") && (a2.color ?? "") === (b.color ?? "") && (a2.highlight ?? "") === (b.highlight ?? "") && a2.hyperlink?.id === b.hyperlink?.id && a2.trackedChange?.id === b.trackedChange?.id && sameCommentSet(a2.comments, b.comments);
 }
 function sameCommentSet(left, right) {
   const a2 = left ?? [];
@@ -19195,7 +19648,7 @@ function sameCommentSet(left, right) {
   }
   return true;
 }
-function renderTextSegment(runs, showChanges) {
+function renderTextSegment(runs, view) {
   const text = runs.map((run25) => run25.text).join("");
   if (text.length === 0)
     return "";
@@ -19221,11 +19674,17 @@ function renderTextSegment(runs, showChanges) {
     const target = first.hyperlink.url ?? `#${first.hyperlink.anchor ?? ""}`;
     out = `[${out}](${target})`;
   }
-  if (showChanges && first.trackedChange) {
-    out = `<${first.trackedChange.kind}>${out}</${first.trackedChange.kind}>`;
+  if (view === "current" && first.trackedChange) {
+    const marker = criticMarkerFor(first.trackedChange.kind);
+    out = `{${marker}${out}${marker}}[^${first.trackedChange.id}]`;
   }
   return out;
 }
+function criticMarkerFor(kind) {
+  if (kind === "ins" || kind === "moveTo")
+    return "++";
+  return "--";
+}
 function colorAttrFor(value) {
   if (!value)
     return null;
@@ -19330,6 +19789,32 @@ function renderNoteDefinitions(notes, referenced) {
   return lines.join(`
 `);
 }
+function renderTrackedChangeFootnotes(referenced) {
+  if (referenced.size === 0)
+    return "";
+  const sorted = [...referenced.values()].sort((a2, b) => trackedChangeIdCompare(a2.id, b.id));
+  const lines = [];
+  for (const change of sorted) {
+    const kind = trackedChangeLabelFor(change.kind);
+    const author = change.author || "unknown";
+    const meta = change.date ? `${author} (${change.date})` : author;
+    lines.push(`[^${change.id}]: ${kind} by ${meta}`);
+  }
+  return lines.join(`
+`);
+}
+function trackedChangeLabelFor(kind) {
+  if (kind === "ins")
+    return "insertion";
+  if (kind === "del")
+    return "deletion";
+  if (kind === "moveTo")
+    return "moveTo";
+  return "moveFrom";
+}
+function trackedChangeIdCompare(left, right) {
+  return numericIdCompare(left, right, /^tc(\d+)$/);
+}
 function noteIdCompare(left, right) {
   return numericIdCompare(left, right, /(\d+)$/);
 }
@@ -19395,6 +19880,7 @@ function blockIdForLocator(input, position) {
     case "comment":
     case "image":
     case "hyperlink":
+    case "trackedChange":
       throw new MarkdownLocatorError(input, `--${position} does not accept a ${parsed.kind} locator \u2014 use a paragraph or table locator`);
   }
 }
@@ -19427,7 +19913,8 @@ async function run25(args) {
         markdown: { type: "boolean" },
         from: { type: "string" },
         to: { type: "string" },
-        changes: { type: "boolean" },
+        accepted: { type: "boolean" },
+        baseline: { type: "boolean" },
         comments: { type: "boolean" },
         help: { type: "boolean", short: "h" }
       }
@@ -19445,20 +19932,25 @@ async function run25(args) {
   const markdown = Boolean(parsed.values.markdown);
   const from = parsed.values.from;
   const to = parsed.values.to;
-  const showChanges = Boolean(parsed.values.changes);
+  const accepted = Boolean(parsed.values.accepted);
+  const baseline = Boolean(parsed.values.baseline);
   const showComments = Boolean(parsed.values.comments);
-  if (!markdown && (from || to || showChanges || showComments)) {
-    return fail("USAGE", "--from, --to, --changes, and --comments require --markdown", HELP25);
+  if (!markdown && (from || to || accepted || baseline || showComments)) {
+    return fail("USAGE", "--from, --to, --accepted, --baseline, and --comments require --markdown", HELP25);
   }
-  const view = await openOrFail(path);
-  if (typeof view === "number")
-    return view;
+  if (accepted && baseline) {
+    return fail("USAGE", "--accepted and --baseline are mutually exclusive", HELP25);
+  }
+  const view = accepted ? "accepted" : baseline ? "baseline" : "current";
+  const docView = await openOrFail(path);
+  if (typeof docView === "number")
+    return docView;
   if (markdown) {
     try {
-      const rendered = renderMarkdown(view.doc, {
+      const rendered = renderMarkdown(docView.doc, {
         from,
         to,
-        showChanges,
+        view,
         showComments
       });
       await writeStdout(rendered);
@@ -19470,8 +19962,8 @@ async function run25(args) {
       throw err;
     }
   }
-  await enrichImageHashes(view);
-  await respond(view.doc);
+  await enrichImageHashes(docView);
+  await respond(docView.doc);
   return EXIT.OK;
 }
 var HELP25 = `docx read \u2014 print AST as JSON, or render document body as Markdown
@@ -19490,8 +19982,18 @@ Options:
                     Accepts pN, tN, tN:rRcC[:pK[:S-E]], pN:S-E, pN:S-pM:E.
                     Cell/span/range locators collapse to their enclosing
                     top-level block (the table or paragraph).
-  --changes         With --markdown, render tracked insertions/deletions as
-                    <ins>/<del> instead of producing the accepted view.
+  --accepted        With --markdown, render the post-accept view: drop
+                    subtractive wrappers (<w:del>, <w:moveFrom>), inline
+                    additive wrappers (<w:ins>, <w:moveTo>) as plain text,
+                    no markers/refs.
+  --baseline        With --markdown, render the pre-change view: drop
+                    additive wrappers (<w:ins>, <w:moveTo>), inline
+                    subtractive wrappers (<w:del>, <w:moveFrom>) as plain
+                    text, no markers/refs. Mutually exclusive with --accepted.
+                    Default --markdown shows all four: additive wrappers as
+                    {++text++}[^tcN] and subtractive as {--text--}[^tcN]
+                    (CriticMarkup); the [^tcN] footnote spells out the kind
+                    (insertion / deletion / moveTo / moveFrom).
   --comments        With --markdown, append [^cN] after each commented span
                     and emit a footnote definition for each comment at the
                     end of the output (author, date, body).
@@ -19501,7 +20003,8 @@ Examples:
   docx read input.docx
   docx read input.docx --markdown
   docx read input.docx --markdown --from p3 --to p20
-  docx read input.docx --markdown --changes --comments
+  docx read input.docx --markdown --accepted --comments
+  docx read input.docx --markdown --baseline
   docx read input.docx | jq '.blocks[] | select(.type == "paragraph")'
 `;
 var init_read2 = __esm(() => {
@@ -19538,33 +20041,25 @@ function replaceSpanInParagraph(paragraph, span, replacement, tracked) {
 function collectRunSlots(paragraph) {
   const slots = [];
   let offset = 0;
-  for (const child of paragraph.children) {
-    if (child.tag === "w:r") {
-      const length = runTextLength(child);
-      slots.push({
-        parent: paragraph,
-        run: child,
-        offsetBefore: offset,
-        length
-      });
-      offset += length;
-      continue;
-    }
-    if (child.tag === "w:ins" || child.tag === "w:del" || child.tag === "w:hyperlink") {
-      for (const inner of child.children) {
-        if (inner.tag !== "w:r")
-          continue;
-        const length = runTextLength(inner);
+  function walk(parent, children) {
+    for (const child of children) {
+      if (child.tag === "w:r") {
+        const length = runTextLength(child);
         slots.push({
-          parent: child,
-          run: inner,
+          parent,
+          run: child,
           offsetBefore: offset,
           length
         });
         offset += length;
+        continue;
+      }
+      if (isRunBearingWrapper(child.tag)) {
+        walk(child, child.children);
       }
     }
   }
+  walk(paragraph, paragraph.children);
   return slots;
 }
 function rebuildContainer(container, baseOffset, span, replacement, runProperties, isParagraph, tracked) {
@@ -19618,13 +20113,8 @@ function rebuildContainer(container, baseOffset, span, replacement, runPropertie
       }
       continue;
     }
-    if (isParagraph && (child.tag === "w:ins" || child.tag === "w:del" || child.tag === "w:hyperlink")) {
-      let innerLength = 0;
-      for (const inner of child.children) {
-        if (inner.tag === "w:r")
-          innerLength += runTextLength(inner);
-      }
-      offset += innerLength;
+    if (isParagraph && isRunBearingWrapper(child.tag)) {
+      offset += sumRunBearingTextLength(child.children);
       newChildren.push(child);
       continue;
     }
@@ -19685,8 +20175,8 @@ function rebuildAcrossBoundaries(paragraph, span, replacement, runProperties, tr
       }
       continue;
     }
-    if (child.tag === "w:ins" || child.tag === "w:del") {
-      const innerLength = sumInnerRunLengths2(child);
+    if (child.tag === "w:ins" || child.tag === "w:del" || child.tag === "w:moveFrom" || child.tag === "w:moveTo") {
+      const innerLength = sumRunBearingTextLength(child.children);
       const wrapperStart = offset;
       const wrapperEnd = offset + innerLength;
       offset = wrapperEnd;
@@ -19703,7 +20193,7 @@ function rebuildAcrossBoundaries(paragraph, span, replacement, runProperties, tr
       continue;
     }
     if (child.tag === "w:hyperlink") {
-      const innerLength = sumInnerRunLengths2(child);
+      const innerLength = sumRunBearingTextLength(child.children);
       const wrapperStart = offset;
       const wrapperEnd = offset + innerLength;
       offset = wrapperEnd;
@@ -19721,6 +20211,23 @@ function rebuildAcrossBoundaries(paragraph, span, replacement, runProperties, tr
       });
       continue;
     }
+    if (isRunBearingWrapper(child.tag)) {
+      const innerLength = sumRunBearingTextLength(child.children);
+      const wrapperStart = offset;
+      const wrapperEnd = offset + innerLength;
+      offset = wrapperEnd;
+      if (wrapperEnd <= span.start) {
+        newChildren.push(child);
+        continue;
+      }
+      if (wrapperStart >= span.end) {
+        placeReplacement();
+        newChildren.push(child);
+        continue;
+      }
+      splitTransparentWrapperAcrossSpan(child, wrapperStart, span, newChildren, placeReplacement);
+      continue;
+    }
     newChildren.push(child);
   }
   if (!placed)
@@ -19728,7 +20235,7 @@ function rebuildAcrossBoundaries(paragraph, span, replacement, runProperties, tr
   paragraph.children = newChildren;
 }
 function splitWrapperAcrossSpan(wrapper, wrapperStart, span, tracked, out, placeReplacement) {
-  const isDel = wrapper.tag === "w:del";
+  const isSubtractive = isSubtractiveTrackedChangeWrapper(wrapper.tag);
   const preInner = [];
   const cutInner = [];
   const postInner = [];
@@ -19759,7 +20266,7 @@ function splitWrapperAcrossSpan(wrapper, wrapperStart, span, tracked, out, place
       postInner.push(sliceRun(inner, sliceEndInRun, length));
   }
   const preChildren = preInner.slice();
-  if (isDel) {
+  if (isSubtractive) {
     preChildren.push(...cutInner);
   } else if (tracked && cutInner.length > 0) {
     for (const cutRun of cutInner)
@@ -19781,8 +20288,48 @@ function splitWrapperAcrossSpan(wrapper, wrapperStart, span, tracked, out, place
     out.push(postWrapper);
   }
 }
+function splitTransparentWrapperAcrossSpan(wrapper, wrapperStart, span, out, placeReplacement) {
+  const preInner = [];
+  const postInner = [];
+  let innerOffset = wrapperStart;
+  for (const inner of wrapper.children) {
+    if (inner.tag !== "w:r") {
+      preInner.push(inner);
+      continue;
+    }
+    const length = runTextLength(inner);
+    const runStart = innerOffset;
+    const runEnd = innerOffset + length;
+    innerOffset = runEnd;
+    if (runEnd <= span.start) {
+      preInner.push(inner);
+      continue;
+    }
+    if (runStart >= span.end) {
+      postInner.push(inner);
+      continue;
+    }
+    const sliceStartInRun = Math.max(0, span.start - runStart);
+    const sliceEndInRun = Math.min(length, span.end - runStart);
+    if (sliceStartInRun > 0)
+      preInner.push(sliceRun(inner, 0, sliceStartInRun));
+    if (sliceEndInRun < length)
+      postInner.push(sliceRun(inner, sliceEndInRun, length));
+  }
+  if (preInner.length > 0) {
+    const preWrapper = new XmlNode2(wrapper.tag, { ...wrapper.attributes });
+    preWrapper.children = preInner;
+    out.push(preWrapper);
+  }
+  placeReplacement();
+  if (postInner.length > 0) {
+    const postWrapper = new XmlNode2(wrapper.tag, { ...wrapper.attributes });
+    postWrapper.children = postInner;
+    out.push(postWrapper);
+  }
+}
 function splitHyperlinkAcrossSpan(wrapper, wrapperStart, span, runProperties, replacement, tracked, out, placeReplacement, markReplacementPlaced) {
-  const wrapperEnd = wrapperStart + wrapper.children.reduce((total, inner) => inner.tag === "w:r" ? total + runTextLength(inner) : total, 0);
+  const wrapperEnd = wrapperStart + sumRunBearingTextLength(wrapper.children);
   const startsInside = span.start > wrapperStart && span.start < wrapperEnd;
   const preInner = [];
   const postInner = [];
@@ -19836,14 +20383,6 @@ function splitHyperlinkAcrossSpan(wrapper, wrapperStart, span, runProperties, re
     out.push(postWrapper);
   }
 }
-function sumInnerRunLengths2(wrapper) {
-  let total = 0;
-  for (const inner of wrapper.children) {
-    if (inner.tag === "w:r")
-      total += runTextLength(inner);
-  }
-  return total;
-}
 function mintMeta(tracked) {
   return { ...tracked.meta, revisionId: tracked.allocator.next() };
 }
@@ -20057,9 +20596,9 @@ var init_replace3 = __esm(() => {
   init_replace_span();
 });
 
-// src/cli/track-changes/index.tsx
-var exports_track_changes = {};
-__export(exports_track_changes, {
+// src/cli/track-changes/list.ts
+var exports_list4 = {};
+__export(exports_list4, {
   run: () => run27
 });
 import { parseArgs as parseArgs23 } from "util";
@@ -20070,8 +20609,6 @@ async function run27(args) {
       args,
       allowPositionals: true,
       options: {
-        output: { type: "string", short: "o" },
-        "dry-run": { type: "boolean" },
         help: { type: "boolean", short: "h" }
       }
     });
@@ -20086,9 +20623,364 @@ async function run27(args) {
   const path = parsed.positionals[0];
   if (!path)
     return fail("USAGE", "Missing FILE argument", HELP27);
+  const view = await openOrFail(path);
+  if (typeof view === "number")
+    return view;
+  const byId = new Map;
+  for (const paragraph of flattenParagraphs(view.doc.blocks)) {
+    for (const run28 of paragraph.runs) {
+      if (run28.type !== "text" || !run28.trackedChange)
+        continue;
+      const change = run28.trackedChange;
+      const existing = byId.get(change.id);
+      if (existing) {
+        existing.text += run28.text;
+        continue;
+      }
+      byId.set(change.id, {
+        ...change,
+        blockId: paragraph.id,
+        text: run28.text
+      });
+    }
+  }
+  for (const [id, reference] of view.trackedChangeReferences) {
+    if (byId.has(id))
+      continue;
+    const kind = trackedChangeKindForTag(reference.node.tag);
+    if (!kind)
+      continue;
+    byId.set(id, {
+      id,
+      kind,
+      author: reference.node.getAttribute("w:author") ?? "",
+      date: reference.node.getAttribute("w:date") ?? "",
+      revisionId: reference.node.getAttribute("w:id") ?? "",
+      blockId: reference.blockId,
+      text: ""
+    });
+  }
+  const sorted = [...byId.values()].sort((a2, b) => trackedChangeIndex(a2.id) - trackedChangeIndex(b.id));
+  await respond(sorted);
+  return EXIT.OK;
+}
+function trackedChangeIndex(id) {
+  const match = id.match(/^tc(\d+)$/);
+  return match?.[1] ? Number(match[1]) : 0;
+}
+function trackedChangeKindForTag(tag) {
+  if (tag === "w:ins")
+    return "ins";
+  if (tag === "w:del")
+    return "del";
+  if (tag === "w:moveFrom")
+    return "moveFrom";
+  if (tag === "w:moveTo")
+    return "moveTo";
+  return null;
+}
+var HELP27 = `docx track-changes list \u2014 inventory every revision wrapper
+
+Usage:
+  docx track-changes list FILE [options]
+
+Options:
+  -h, --help    Show this help
+
+Lists every <w:ins>, <w:del>, <w:moveFrom>, and <w:moveTo> wrapper with
+stable tcN ids. moveFrom/moveTo halves of the same logical move appear
+as separate entries (one for each side); their kind tells them apart.
+
+Output: JSON array of { id, kind, author, date, revisionId, blockId, text }
+sorted by id (document order). kind is one of: "ins", "del", "moveFrom",
+"moveTo".
+
+Examples:
+  docx track-changes list doc.docx
+  docx track-changes list doc.docx | jq '.[] | select(.kind == "del")'
+  docx track-changes list doc.docx | jq '.[] | select(.kind | test("move"))'
+`;
+var init_list4 = __esm(() => {
+  init_core();
+  init_respond();
+});
+
+// src/cli/track-changes/apply.ts
+import { parseArgs as parseArgs24 } from "util";
+async function runApply(args, verb, help) {
+  let parsed;
+  try {
+    parsed = parseArgs24({
+      args,
+      allowPositionals: true,
+      options: {
+        at: { type: "string" },
+        all: { type: "boolean" },
+        output: { type: "string", short: "o" },
+        "dry-run": { type: "boolean" },
+        help: { type: "boolean", short: "h" }
+      }
+    });
+  } catch (parseError) {
+    const message = parseError instanceof Error ? parseError.message : String(parseError);
+    return fail("USAGE", message, help);
+  }
+  if (parsed.values.help) {
+    await writeStdout(help);
+    return EXIT.OK;
+  }
+  const path = parsed.positionals[0];
+  if (!path)
+    return fail("USAGE", "Missing FILE argument", help);
+  const at = parsed.values.at;
+  const all = Boolean(parsed.values.all);
+  if (at && all) {
+    return fail("USAGE", "--at and --all are mutually exclusive", help);
+  }
+  if (!at && !all) {
+    return fail("USAGE", "Specify --at tcN or --all", help);
+  }
+  const view = await openOrFail(path);
+  if (typeof view === "number")
+    return view;
+  const allChanges = collectTrackedChanges(view.documentTree);
+  let targets;
+  if (all) {
+    targets = allChanges;
+  } else {
+    const found = allChanges.find((change) => change.id === at);
+    if (!found) {
+      return fail("TRACKED_CHANGE_NOT_FOUND", `Tracked change not found: ${at}`);
+    }
+    targets = [found];
+  }
+  const records = targets.map((target) => ({
+    id: target.id,
+    kind: target.kind,
+    action: actionFor(target.kind, verb),
+    author: target.author,
+    date: target.date
+  }));
+  const outputPath = parsed.values.output;
+  if (parsed.values["dry-run"]) {
+    await respond({
+      ok: true,
+      operation: `track-changes.${verb}`,
+      dryRun: true,
+      path,
+      ...outputPath ? { output: outputPath } : {},
+      applied: records
+    });
+    return EXIT.OK;
+  }
+  for (const target of [...targets].reverse()) {
+    if (verb === "accept")
+      applyAccept(target.node, target.parent);
+    else
+      applyReject(target.node, target.parent);
+  }
+  await saveDocView(view, outputPath);
+  await respond({
+    ok: true,
+    operation: `track-changes.${verb}`,
+    path: outputPath ?? path,
+    applied: records
+  });
+  return EXIT.OK;
+}
+function collectTrackedChanges(tree) {
+  const out = [];
+  let counter = 0;
+  function walk(children) {
+    for (const node of children) {
+      const kind = trackedChangeKindForTag2(node.tag);
+      if (kind) {
+        out.push({
+          node,
+          parent: children,
+          kind,
+          id: `tc${counter++}`,
+          author: node.getAttribute("w:author") ?? "",
+          date: node.getAttribute("w:date") ?? ""
+        });
+      }
+      if (node.children.length > 0)
+        walk(node.children);
+    }
+  }
+  walk(tree);
+  return out;
+}
+function trackedChangeKindForTag2(tag) {
+  if (tag === "w:ins")
+    return "ins";
+  if (tag === "w:del")
+    return "del";
+  if (tag === "w:moveFrom")
+    return "moveFrom";
+  if (tag === "w:moveTo")
+    return "moveTo";
+  return null;
+}
+function actionFor(kind, verb) {
+  const isAdditive = kind === "ins" || kind === "moveTo";
+  if (verb === "accept")
+    return isAdditive ? "unwrap" : "delete";
+  return isAdditive ? "delete" : "unwrap";
+}
+function applyAccept(node, parent) {
+  if (node.tag === "w:ins" || node.tag === "w:moveTo") {
+    unwrapNode(node, parent);
+    return;
+  }
+  deleteNode(node, parent);
+}
+function applyReject(node, parent) {
+  if (node.tag === "w:ins" || node.tag === "w:moveTo") {
+    deleteNode(node, parent);
+    return;
+  }
+  renameDelTextToText(node);
+  unwrapNode(node, parent);
+}
+function unwrapNode(node, parent) {
+  const index = parent.indexOf(node);
+  if (index === -1)
+    return;
+  parent.splice(index, 1, ...node.children);
+}
+function deleteNode(node, parent) {
+  const index = parent.indexOf(node);
+  if (index === -1)
+    return;
+  parent.splice(index, 1);
+}
+function renameDelTextToText(node) {
+  if (node.tag === "w:delText")
+    node.tag = "w:t";
+  for (const child of node.children)
+    renameDelTextToText(child);
+}
+var init_apply = __esm(() => {
+  init_core();
+  init_respond();
+});
+
+// src/cli/track-changes/accept.ts
+var exports_accept = {};
+__export(exports_accept, {
+  run: () => run28
+});
+async function run28(args) {
+  return runApply(args, "accept", HELP28);
+}
+var HELP28 = `docx track-changes accept \u2014 accept tracked changes (incorporate into the doc)
+
+Usage:
+  docx track-changes accept FILE --at tcN [options]
+  docx track-changes accept FILE --all [options]
+
+Accepting an insertion (<w:ins>) or move destination (<w:moveTo>) unwraps the
+wrapper \u2014 the content becomes plain runs at this location. Accepting a
+deletion (<w:del>) or move source (<w:moveFrom>) removes the element and its
+<w:delText> entirely (the text disappears for real).
+
+Out of scope: tracked paragraph marks (<w:rPr><w:ins/></w:rPr> inside <w:pPr>)
+and formatting changes (<w:rPrChange>/<w:pPrChange>). These aren't modeled in
+the AST today and --all silently skips them.
+
+Options:
+  --at tcN          Accept a single tracked change by id
+  --all             Accept every tracked change (mutually exclusive with --at)
+  -o, --output PATH Write to PATH instead of overwriting FILE
+  --dry-run         Print what would change; do not write the file
+  -h, --help        Show this help
+
+Examples:
+  docx track-changes accept doc.docx --at tc0
+  docx track-changes accept doc.docx --all
+  docx track-changes accept doc.docx --all --dry-run
+`;
+var init_accept = __esm(() => {
+  init_apply();
+});
+
+// src/cli/track-changes/reject.ts
+var exports_reject = {};
+__export(exports_reject, {
+  run: () => run29
+});
+async function run29(args) {
+  return runApply(args, "reject", HELP29);
+}
+var HELP29 = `docx track-changes reject \u2014 reject tracked changes (revert to pre-change state)
+
+Usage:
+  docx track-changes reject FILE --at tcN [options]
+  docx track-changes reject FILE --all [options]
+
+Rejecting an insertion (<w:ins>) or move destination (<w:moveTo>) removes the
+element and its content (it shouldn't have arrived at this location).
+Rejecting a deletion (<w:del>) or move source (<w:moveFrom>) unwraps the
+wrapper and converts <w:delText> back to <w:t>, so the text reappears as
+plain runs.
+
+moveFrom and moveTo are processed independently. To fully undo a move, target
+both halves (or use --all). The runtime treats them as paired only by their
+shared revision id, not by atomic accept/reject.
+
+Out of scope: tracked paragraph marks (<w:rPr><w:del/></w:rPr> inside <w:pPr>)
+and formatting changes (<w:rPrChange>/<w:pPrChange>). These aren't modeled in
+the AST today and --all silently skips them.
+
+Options:
+  --at tcN          Reject a single tracked change by id
+  --all             Reject every tracked change (mutually exclusive with --at)
+  -o, --output PATH Write to PATH instead of overwriting FILE
+  --dry-run         Print what would change; do not write the file
+  -h, --help        Show this help
+
+Examples:
+  docx track-changes reject doc.docx --at tc0
+  docx track-changes reject doc.docx --all
+  docx track-changes reject doc.docx --all --dry-run
+`;
+var init_reject = __esm(() => {
+  init_apply();
+});
+
+// src/cli/track-changes/toggle.tsx
+var exports_toggle = {};
+__export(exports_toggle, {
+  run: () => run30
+});
+import { parseArgs as parseArgs25 } from "util";
+async function run30(args) {
+  let parsed;
+  try {
+    parsed = parseArgs25({
+      args,
+      allowPositionals: true,
+      options: {
+        output: { type: "string", short: "o" },
+        "dry-run": { type: "boolean" },
+        help: { type: "boolean", short: "h" }
+      }
+    });
+  } catch (parseError) {
+    const message = parseError instanceof Error ? parseError.message : String(parseError);
+    return fail("USAGE", message, HELP30);
+  }
+  if (parsed.values.help) {
+    await writeStdout(HELP30);
+    return EXIT.OK;
+  }
+  const path = parsed.positionals[0];
+  if (!path)
+    return fail("USAGE", "Missing FILE argument", HELP30);
   const mode = parsed.positionals[1];
   if (mode !== "on" && mode !== "off") {
-    return fail("USAGE", `Expected "on" or "off", got: ${mode ?? "<nothing>"}`, HELP27);
+    return fail("USAGE", `Expected "on" or "off", got: ${mode ?? "<nothing>"}`, HELP30);
   }
   const view = await openOrFail(path);
   if (typeof view === "number")
@@ -20140,7 +21032,7 @@ async function run27(args) {
   });
   return EXIT.OK;
 }
-var HELP27 = `docx track-changes \u2014 toggle the document's tracked-changes mode
+var HELP30 = `docx track-changes \u2014 toggle the document's tracked-changes mode
 
 Usage:
   docx track-changes FILE on|off [options]
@@ -20159,7 +21051,7 @@ Examples:
   docx track-changes doc.docx on
   docx track-changes doc.docx off
 `, SETTINGS_PART = "word/settings.xml", SETTINGS_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/settings", SETTINGS_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml", NS_W2 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
-var init_track_changes2 = __esm(() => {
+var init_toggle = __esm(() => {
   init_core();
   init_jsx();
   init_package();
@@ -20168,58 +21060,126 @@ var init_track_changes2 = __esm(() => {
   init_jsx_dev_runtime();
 });
 
+// src/cli/track-changes/index.ts
+var exports_track_changes = {};
+__export(exports_track_changes, {
+  run: () => run31
+});
+async function run31(args) {
+  const first = args[0];
+  if (first === "--help" || first === "-h" || first === "help") {
+    await writeStdout(HELP31);
+    return 0;
+  }
+  if (!first) {
+    return fail("USAGE", "Missing arguments", HELP31);
+  }
+  if (first === "list") {
+    const module_2 = await Promise.resolve().then(() => (init_list4(), exports_list4));
+    return module_2.run(args.slice(1));
+  }
+  if (first === "accept") {
+    const module_2 = await Promise.resolve().then(() => (init_accept(), exports_accept));
+    return module_2.run(args.slice(1));
+  }
+  if (first === "reject") {
+    const module_2 = await Promise.resolve().then(() => (init_reject(), exports_reject));
+    return module_2.run(args.slice(1));
+  }
+  const module_ = await Promise.resolve().then(() => (init_toggle(), exports_toggle));
+  return module_.run(args);
+}
+var HELP31 = `docx track-changes \u2014 manage tracked-changes
+
+Usage:
+  docx track-changes FILE on|off [options]
+  docx track-changes list FILE [options]
+  docx track-changes accept FILE (--at tcN | --all) [options]
+  docx track-changes reject FILE (--at tcN | --all) [options]
+
+Verbs:
+  on        Set <w:trackChanges/> in word/settings.xml
+  off       Remove <w:trackChanges/>
+  list      Inventory every <w:ins>/<w:del>/<w:moveFrom>/<w:moveTo> with
+            id, kind, author, date, location
+  accept    Accept tracked changes \u2014 additive wrappers (<w:ins>, <w:moveTo>)
+            unwrap; subtractive wrappers (<w:del>, <w:moveFrom>) are removed
+  reject    Reject tracked changes \u2014 additive wrappers are removed;
+            subtractive wrappers unwrap (with <w:delText> \u2192 <w:t> rename)
+
+When tracking is on, this CLI's insert/edit/delete/replace commands
+emit <w:ins>/<w:del> markers (attributed via --author or $DOCX_AUTHOR).
+moveFrom/moveTo are read, listed, and accept/reject independently \u2014 we
+don't emit them ourselves (Word does that interactively).
+Accept/reject themselves bypass tracking \u2014 they're doc surgery, not edits.
+
+Run "docx track-changes <verb> --help" for verb-specific help.
+`;
+var init_track_changes2 = __esm(() => {
+  init_respond();
+});
+
 // src/cli/wc/count.ts
+function textFor(options) {
+  if (options.view === "accepted")
+    return paragraphTextAccepted;
+  if (options.view === "baseline")
+    return paragraphTextBaseline;
+  return paragraphText;
+}
 function countWords(text) {
   const matches = text.match(/\S+/g);
   return matches?.length ?? 0;
 }
-function countWordsInBlocks(blocks) {
+function countWordsInBlocks(blocks, options = {}) {
+  const text = textFor(options);
   let total = 0;
   for (const block of blocks) {
     if (block.type === "paragraph") {
-      total += countWords(paragraphText(block));
+      total += countWords(text(block));
     } else if (block.type === "table") {
       for (const row of block.rows) {
         for (const cell of row.cells) {
-          total += countWordsInBlocks(cell.blocks);
+          total += countWordsInBlocks(cell.blocks, options);
         }
       }
     }
   }
   return total;
 }
-function countWordsInParagraphSpan(paragraph, start, end) {
-  const text = paragraphText(paragraph);
+function countWordsInParagraphSpan(paragraph, start, end, options = {}) {
+  const text = textFor(options)(paragraph);
   const clampedEnd = Math.min(Math.max(end, 0), text.length);
   const clampedStart = Math.min(Math.max(start, 0), clampedEnd);
   return countWords(text.slice(clampedStart, clampedEnd));
 }
-function countWordsInRange(paragraphsInOrder, startBlockId, startOffset, endBlockId, endOffset) {
+function countWordsInRange(paragraphsInOrder, startBlockId, startOffset, endBlockId, endOffset, options = {}) {
   const startIndex = paragraphsInOrder.findIndex((p) => p.id === startBlockId);
   const endIndex = paragraphsInOrder.findIndex((p) => p.id === endBlockId);
   if (startIndex === -1 || endIndex === -1)
     return 0;
   if (endIndex < startIndex)
     return 0;
+  const text = textFor(options);
   if (startIndex === endIndex) {
     const paragraph = paragraphsInOrder[startIndex];
     if (!paragraph)
       return 0;
-    return countWordsInParagraphSpan(paragraph, startOffset, endOffset);
+    return countWordsInParagraphSpan(paragraph, startOffset, endOffset, options);
   }
   let total = 0;
   const first = paragraphsInOrder[startIndex];
   if (first) {
-    total += countWordsInParagraphSpan(first, startOffset, paragraphText(first).length);
+    total += countWordsInParagraphSpan(first, startOffset, text(first).length, options);
   }
   for (let index = startIndex + 1;index < endIndex; index++) {
     const middle = paragraphsInOrder[index];
     if (middle)
-      total += countWords(paragraphText(middle));
+      total += countWords(text(middle));
   }
   const last = paragraphsInOrder[endIndex];
   if (last)
-    total += countWordsInParagraphSpan(last, 0, endOffset);
+    total += countWordsInParagraphSpan(last, 0, endOffset, options);
   return total;
 }
 var init_count = __esm(() => {
@@ -20229,41 +21189,51 @@ var init_count = __esm(() => {
 // src/cli/wc/index.ts
 var exports_wc = {};
 __export(exports_wc, {
-  run: () => run28
+  run: () => run32
 });
-import { parseArgs as parseArgs24 } from "util";
-async function run28(args) {
+import { parseArgs as parseArgs26 } from "util";
+async function run32(args) {
   let parsed;
   try {
-    parsed = parseArgs24({
+    parsed = parseArgs26({
       args,
       allowPositionals: true,
       options: {
+        accepted: { type: "boolean" },
+        baseline: { type: "boolean" },
         help: { type: "boolean", short: "h" }
       }
     });
   } catch (parseError) {
     const message = parseError instanceof Error ? parseError.message : String(parseError);
-    return fail("USAGE", message, HELP28);
+    return fail("USAGE", message, HELP32);
   }
   if (parsed.values.help) {
-    await writeStdout(HELP28);
+    await writeStdout(HELP32);
     return EXIT.OK;
   }
   const path = parsed.positionals[0];
   const locatorInput = parsed.positionals[1];
   if (!path)
-    return fail("USAGE", "Missing FILE argument", HELP28);
-  const view = await openOrFail(path);
-  if (typeof view === "number")
-    return view;
+    return fail("USAGE", "Missing FILE argument", HELP32);
+  const wantAccepted = Boolean(parsed.values.accepted);
+  const wantBaseline = Boolean(parsed.values.baseline);
+  if (wantAccepted && wantBaseline) {
+    return fail("USAGE", "--accepted and --baseline are mutually exclusive", HELP32);
+  }
+  const view = wantAccepted ? "accepted" : wantBaseline ? "baseline" : "current";
+  const pickText = paragraphTextFor(view);
+  const docView = await openOrFail(path);
+  if (typeof docView === "number")
+    return docView;
   if (!locatorInput) {
     await respond({
       ok: true,
       operation: "wc",
       path,
       scope: "document",
-      words: countWordsInBlocks(view.doc.blocks)
+      view,
+      words: countWordsInBlocks(docView.doc.blocks, { view })
     });
     return EXIT.OK;
   }
@@ -20276,22 +21246,23 @@ async function run28(args) {
     }
     throw error;
   }
-  if (locator.kind === "comment" || locator.kind === "image") {
+  if (locator.kind === "comment" || locator.kind === "image" || locator.kind === "hyperlink" || locator.kind === "trackedChange") {
     return fail("USAGE", `Locator ${locatorInput} addresses a ${locator.kind}, not text`, "wc accepts paragraph, span, range, table, and cell locators.");
   }
-  const blocks = view.doc.blocks;
+  const blocks = docView.doc.blocks;
   if (locator.kind === "block") {
     const block = findBlockById(blocks, locator.blockId);
     if (!block) {
       return fail("BLOCK_NOT_FOUND", `Block not found: ${locator.blockId}`);
     }
-    const words = block.type === "paragraph" ? countWords(paragraphText(block)) : block.type === "table" ? countWordsInBlocks([block]) : 0;
+    const words = block.type === "paragraph" ? countWords(pickText(block)) : block.type === "table" ? countWordsInBlocks([block], { view }) : 0;
     await respond({
       ok: true,
       operation: "wc",
       path,
       locator: locatorInput,
       scope: block.type,
+      view,
       words
     });
     return EXIT.OK;
@@ -20307,7 +21278,10 @@ async function run28(args) {
       path,
       locator: locatorInput,
       scope: "paragraphSpan",
-      words: countWordsInParagraphSpan(block, locator.start, locator.end)
+      view,
+      words: countWordsInParagraphSpan(block, locator.start, locator.end, {
+        view
+      })
     });
     return EXIT.OK;
   }
@@ -20327,7 +21301,8 @@ async function run28(args) {
       path,
       locator: locatorInput,
       scope: "range",
-      words: countWordsInRange(paragraphs, locator.start.blockId, locator.start.offset, locator.end.blockId, locator.end.offset)
+      view,
+      words: countWordsInRange(paragraphs, locator.start.blockId, locator.start.offset, locator.end.blockId, locator.end.offset, { view })
     });
     return EXIT.OK;
   }
@@ -20344,7 +21319,8 @@ async function run28(args) {
         path,
         locator: locatorInput,
         scope: "cell",
-        words: countWordsInBlocks(cellBlocks)
+        view,
+        words: countWordsInBlocks(cellBlocks, { view })
       });
       return EXIT.OK;
     }
@@ -20357,13 +21333,14 @@ async function run28(args) {
     if (!block || block.type !== "paragraph") {
       return fail("BLOCK_NOT_FOUND", `Paragraph not found: ${composedId}`);
     }
-    const words = locator.inner.kind === "blockSpan" ? countWordsInParagraphSpan(block, locator.inner.start, locator.inner.end) : countWords(paragraphText(block));
+    const words = locator.inner.kind === "blockSpan" ? countWordsInParagraphSpan(block, locator.inner.start, locator.inner.end, { view }) : countWords(pickText(block));
     await respond({
       ok: true,
       operation: "wc",
       path,
       locator: locatorInput,
       scope: locator.inner.kind === "blockSpan" ? "paragraphSpan" : "paragraph",
+      view,
       words
     });
     return EXIT.OK;
@@ -20382,7 +21359,14 @@ function findCellBlocks(blocks, locator) {
     return null;
   return cell.blocks;
 }
-var HELP28 = `docx wc \u2014 count words in a document or a locator-addressed slice
+function paragraphTextFor(view) {
+  if (view === "accepted")
+    return paragraphTextAccepted;
+  if (view === "baseline")
+    return paragraphTextBaseline;
+  return paragraphText;
+}
+var HELP32 = `docx wc \u2014 count words in a document or a locator-addressed slice
 
 Usage:
   docx wc FILE [LOCATOR] [options]
@@ -20397,13 +21381,20 @@ Locators (optional; default: whole document):
   tN:rRcC:pK:S-E  span within a cell paragraph
 
 Options:
+  --accepted        Count the accepted view: skip subtractive wrappers
+                    (<w:del>, <w:moveFrom>); keep additive wrappers
+                    (<w:ins>, <w:moveTo>) as plain text. Mirrors
+                    "docx read --markdown --accepted".
+  --baseline        Count the baseline view: skip additive wrappers
+                    (<w:ins>, <w:moveTo>); keep subtractive wrappers
+                    (<w:del>, <w:moveFrom>) as plain text \u2014 i.e., the doc as
+                    it was before any tracked changes were made.
   -h, --help        show this help
 
 Counting is whitespace-segmented (\\S+) over the joined paragraph text. Hidden
-content like images/breaks/tabs contributes no words. Tracked-change deletions
-are counted alongside insertions because their characters are still part of the
-on-disk text; accept or reject changes first if you need a delta on the
-"accepted" view.
+content like images/breaks/tabs contributes no words. By default, every
+tracked-change wrapper's text counts (they're all on disk); pass --accepted
+or --baseline (mutually exclusive) to count a tracked-change-aware slice.
 
 Examples:
   docx wc doc.docx
@@ -20420,7 +21411,7 @@ var init_wc = __esm(() => {
 // package.json
 var package_default = {
   name: "bun-docx",
-  version: "0.6.1",
+  version: "0.7.0",
   description: "CLI for AI agents (Claude, Codex) to read, edit, and comment on .docx files with full format fidelity.",
   keywords: [
     "docx",
@@ -20500,9 +21491,10 @@ Commands:
   comments  \u2026     Add, reply, resolve, delete, list comments
   images    \u2026     Extract, replace, list images
   hyperlinks \u2026    Add, list, replace, delete hyperlinks
-  track-changes FILE on|off  Toggle tracked-changes mode
+  track-changes \u2026  Toggle (FILE on|off), list / accept / reject changes
   info      \u2026     Reference material (schema, locators)
 
+It is highly recommended to agents to run "docx info locators" to understand their capabilities.
 Run "docx <command> --help" for command-specific help.
 
 Environment:
@@ -20510,9 +21502,19 @@ Environment:
   DOCX_CLI_NOW   Override the timestamp used for tracked changes (test only)
 
 Tracked changes:
-  When <w:trackChanges/> is set in the doc (toggle via "docx track-changes
-  FILE on"), insert/edit/delete/replace automatically emit <w:ins>/<w:del>
-  markers attributed to $DOCX_AUTHOR.
+  Toggle:    docx track-changes FILE on|off
+  Inventory: docx track-changes list FILE  (JSON: id, kind, author, date, blockId, text)
+  Accept:    docx track-changes accept FILE (--at tcN | --all)
+  Reject:    docx track-changes reject FILE (--at tcN | --all)
+
+  When <w:trackChanges/> is set, insert/edit/delete/replace automatically emit
+  <w:ins>/<w:del> markers attributed via --author (or $DOCX_AUTHOR, or "docx-cli").
+
+  "docx read --markdown" surfaces them as CriticMarkup:
+    {++inserted++}[^tcN]   {--deleted--}[^tcN]
+  with a [^tcN]: definition appendix. Switch view with --accepted (post-accept:
+  drop del, ins as plain) or --baseline (pre-change: drop ins, del as plain).
+  "docx wc" mirrors the same --accepted / --baseline flags.
 `;
 async function printTopHelp() {
   await writeStdout(TOP_HELP);