bun-docx 0.2.0 → 0.4.0

package/dist/index.js

@@ -13422,10 +13422,8 @@ class XmlNode2 {
   }
   static serialize(tree) {
     const builder = new Builder(BUILD_OPTIONS);
-    const flat = [];
-    flattenFragments(tree, flat);
     const pojo = [];
-    for (const node of flat) {
+    for (const node of tree) {
       pojo.push(node.toObject());
     }
     return builder.build(pojo);
@@ -13516,6 +13514,15 @@ class XmlNode2 {
     }
     return out;
   }
+  clone() {
+    const cloned = new XmlNode2(this.tag, { ...this.attributes });
+    if (this.text !== undefined)
+      cloned.text = this.text;
+    for (const child of this.children) {
+      cloned.children.push(child.clone());
+    }
+    return cloned;
+  }
   toObject() {
     if (this.isText) {
       return { "#text": this.text ?? "" };
@@ -13539,16 +13546,7 @@ class XmlNode2 {
     return result;
   }
 }
-function flattenFragments(tree, out) {
-  for (const node of tree) {
-    if (node.tag === FRAGMENT_TAG) {
-      flattenFragments(node.children, out);
-      continue;
-    }
-    out.push(node);
-  }
-}
-var PARSE_OPTIONS, BUILD_OPTIONS, FRAGMENT_TAG = "#fragment";
+var PARSE_OPTIONS, BUILD_OPTIONS;
 var init_xml_node = __esm(() => {
   init_fxb();
   init_fxp();
@@ -13596,19 +13594,10 @@ function sliceRun(run, start, end) {
       consumed += text.length;
       continue;
     }
-    sliced.children.push(deepCloneNode(child));
+    sliced.children.push(child.clone());
   }
   return sliced;
 }
-function deepCloneNode(node) {
-  const clone = new XmlNode2(node.tag, { ...node.attributes });
-  if (node.text !== undefined)
-    clone.text = node.text;
-  for (const child of node.children) {
-    clone.children.push(deepCloneNode(child));
-  }
-  return clone;
-}
 var init_run_ops = __esm(() => {
   init_xml_node();
 });
@@ -13665,6 +13654,26 @@ var init_parts = __esm(() => {
 });
 
 // src/core/package/index.ts
+import { lstat, rename, unlink } from "fs/promises";
+async function writeAtomic(target, buf) {
+  let isSymlink = false;
+  try {
+    isSymlink = (await lstat(target)).isSymbolicLink();
+  } catch {}
+  if (isSymlink) {
+    await Bun.write(target, buf);
+    return;
+  }
+  const tmp = `${target}.docx-cli-tmp-${process.pid}-${Date.now()}`;
+  try {
+    await Bun.write(tmp, buf);
+    await rename(tmp, target);
+  } catch (err) {
+    await unlink(tmp).catch(() => {});
+    throw err;
+  }
+}
+
 class Pkg {
   zip;
   path;
@@ -13727,7 +13736,7 @@ class Pkg {
       compression: "DEFLATE",
       compressionOptions: { level: 6 }
     });
-    await Bun.write(target, buf);
+    await writeAtomic(target, buf);
   }
   async toBytes() {
     return this.zip.generateAsync({
@@ -13934,8 +13943,9 @@ function readRun(view, node, activeComments, trackedChange, state) {
   }
   let combinedText = "";
   for (const child of node.children) {
-    if (child.tag === "w:t")
+    if (child.tag === "w:t" || child.tag === "w:delText") {
       combinedText += child.collectText();
+    }
   }
   if (combinedText.length === 0)
     return null;
@@ -14421,87 +14431,82 @@ var init_locators = __esm(() => {
   init_resolve();
 });
 
-// src/core/index.ts
-var init_core = __esm(() => {
-  init_ast();
-  init_locators();
-  init_package();
-  init_parser();
-});
-
-// src/cli/respond.ts
-async function respond(payload) {
-  await Bun.write(Bun.stdout, `${JSON.stringify(payload)}
-`);
-}
-async function writeStdout(text) {
-  await Bun.write(Bun.stdout, text);
+// src/core/track-changes/index.ts
+function isTrackChangesEnabled(view) {
+  if (!view.settingsTree)
+    return false;
+  const settingsRoot = XmlNode2.findRoot(view.settingsTree, "w:settings");
+  if (!settingsRoot)
+    return false;
+  return settingsRoot.children.some((child) => child.tag === "w:trackChanges");
 }
-async function fail(code, message, hint) {
-  const payload = {
-    ok: false,
-    code,
-    error: message
+function createRevisionAllocator(view) {
+  let nextId = computeMaxRevisionId(view) + 1;
+  return {
+    next() {
+      const id = nextId;
+      nextId += 1;
+      return id;
+    }
   };
-  if (hint)
-    payload.hint = hint;
-  await respond(payload);
-  return exitCodeFor(code);
 }
-function exitCodeFor(code) {
-  switch (code) {
-    case "USAGE":
-    case "INVALID_LOCATOR":
-      return EXIT.USAGE_ERROR;
-    case "FILE_NOT_FOUND":
-    case "PART_NOT_FOUND":
-    case "BLOCK_NOT_FOUND":
-    case "COMMENT_NOT_FOUND":
-    case "IMAGE_NOT_FOUND":
-    case "MATCH_NOT_FOUND":
-      return EXIT.NOT_FOUND;
-    case "NOT_A_ZIP":
-    case "TRACKED_CHANGE_CONFLICT":
-    case "UNHANDLED":
-      return EXIT.GENERAL_ERROR;
-  }
+function resolveAuthor(authorFlag) {
+  if (authorFlag)
+    return authorFlag;
+  if (Bun.env.DOCX_AUTHOR)
+    return Bun.env.DOCX_AUTHOR;
+  if (Bun.env.DOCX_CLI_AUTHOR)
+    return Bun.env.DOCX_CLI_AUTHOR;
+  return "docx-cli";
 }
-async function openOrFail(path) {
-  try {
-    return await openDocView(path);
-  } catch (err) {
-    if (err instanceof PkgError) {
-      if (err.code === "FILE_NOT_FOUND") {
-        return await fail("FILE_NOT_FOUND", err.message);
-      }
-      if (err.code === "NOT_A_ZIP")
-        return await fail("NOT_A_ZIP", err.message);
-    }
-    throw err;
+function resolveDate() {
+  return Bun.env.DOCX_CLI_NOW ?? new Date().toISOString();
+}
+function convertTextToDelText(node) {
+  const cloned = node.clone();
+  mutateTextToDelText([cloned]);
+  return cloned;
+}
+function computeMaxRevisionId(view) {
+  let max = -1;
+  walkXml(view.documentTree, (node) => {
+    if (node.tag !== "w:ins" && node.tag !== "w:del")
+      return;
+    const idAttr = node.getAttribute("w:id");
+    if (!idAttr)
+      return;
+    const value = Number(idAttr);
+    if (Number.isFinite(value) && value > max)
+      max = value;
+  });
+  return max;
+}
+function walkXml(nodes, visit) {
+  for (const node of nodes) {
+    visit(node);
+    if (node.children.length > 0)
+      walkXml(node.children, visit);
   }
 }
-async function resolveBlockOrFail(view, locator) {
-  try {
-    return resolveBlock(view, locator);
-  } catch (err) {
-    if (err instanceof LocatorResolveError) {
-      return await fail("BLOCK_NOT_FOUND", err.message);
-    }
-    throw err;
+function mutateTextToDelText(nodes) {
+  for (const node of nodes) {
+    if (node.tag === "w:t")
+      node.tag = "w:delText";
+    mutateTextToDelText(node.children);
   }
 }
-var EXIT;
-var init_respond = __esm(() => {
-  init_core();
-  EXIT = {
-    OK: 0,
-    GENERAL_ERROR: 1,
-    USAGE_ERROR: 2,
-    NOT_FOUND: 3
-  };
+var init_track_changes = __esm(() => {
+  init_parser();
 });
 
 // src/core/jsx/index.ts
+function normalizeChildren(children) {
+  if (children === undefined || children === null)
+    return [];
+  if (Array.isArray(children))
+    return children;
+  return [children];
+}
 function namespace(prefix, tags) {
   const result = {};
   for (const tagName of tags) {
@@ -14510,19 +14515,22 @@ function namespace(prefix, tags) {
   return result;
 }
 function makeTag(qualifiedName) {
-  return (props, ...children) => {
+  return (props) => {
     const attributes = {};
+    let childrenProp;
     if (props) {
       for (const [key, value] of Object.entries(props)) {
-        if (key === "children")
+        if (key === "children") {
+          childrenProp = value;
           continue;
+        }
         if (value === false || value == null)
           continue;
         attributes[mapAttributeName(key)] = String(value);
       }
     }
     const childNodes = [];
-    flatten(children, childNodes);
+    flatten(normalizeChildren(childrenProp), childNodes);
     return new XmlNode2(qualifiedName, attributes, childNodes);
   };
 }
@@ -14535,7 +14543,7 @@ function flatten(items, out) {
       continue;
     }
     if (item instanceof XmlNode2) {
-      if (item.tag === FRAGMENT_TAG2) {
+      if (item.tag === FRAGMENT_TAG) {
         for (const child of item.children)
           out.push(child);
         continue;
@@ -14554,7 +14562,7 @@ function mapAttributeName(name) {
     return name;
   return `${name.slice(0, dashIndex)}:${name.slice(dashIndex + 1)}`;
 }
-var FRAGMENT_TAG2 = "#fragment", W_TAGS, R_TAGS, A_TAGS, WP_TAGS, PIC_TAGS, CP_TAGS, DC_TAGS, DCTERMS_TAGS, W14_TAGS, W15_TAGS, w, r, a, wp, pic, cp, dc, dcterms, w14, w15;
+var FRAGMENT_TAG = "#fragment", W_TAGS, R_TAGS, A_TAGS, WP_TAGS, PIC_TAGS, CP_TAGS, DC_TAGS, DCTERMS_TAGS, W14_TAGS, W15_TAGS, w, r, a, wp, pic, cp, dc, dcterms, w14, w15;
 var init_jsx = __esm(() => {
   init_parser();
   W_TAGS = [
@@ -14592,6 +14600,7 @@ var init_jsx = __esm(() => {
     "tcPr",
     "ins",
     "del",
+    "delText",
     "commentRangeStart",
     "commentRangeEnd",
     "commentReference",
@@ -14646,18 +14655,9 @@ var init_jsx = __esm(() => {
 
 // src/core/jsx/jsx-runtime.ts
 function jsx(type, props, _key) {
-  const { children, ...rest } = props ?? {};
-  const childArgs = normalizeChildren(children);
-  const result = type(rest, ...childArgs);
+  const result = type(props);
   return result ?? new XmlNode2("#fragment");
 }
-function normalizeChildren(children) {
-  if (children === undefined)
-    return [];
-  if (Array.isArray(children))
-    return children;
-  return [children];
-}
 var jsxDEV;
 var init_jsx_runtime = __esm(() => {
   init_parser();
@@ -14670,6 +14670,134 @@ var init_jsx_dev_runtime = __esm(() => {
   init_jsx_runtime();
 });
 
+// src/core/track-changes/emit.tsx
+function Ins({
+  meta,
+  children
+}) {
+  return /* @__PURE__ */ jsxDEV(w.ins, {
+    "w-id": String(meta.revisionId),
+    "w-author": meta.author,
+    "w-date": meta.date,
+    children
+  }, undefined, false, undefined, this);
+}
+function Del({
+  meta,
+  children
+}) {
+  return /* @__PURE__ */ jsxDEV(w.del, {
+    "w-id": String(meta.revisionId),
+    "w-author": meta.author,
+    "w-date": meta.date,
+    children
+  }, undefined, false, undefined, this);
+}
+function markParagraphMarkAs(paragraph, kind, meta) {
+  let pPr = paragraph.findChild("w:pPr");
+  if (!pPr) {
+    pPr = /* @__PURE__ */ jsxDEV(w.pPr, {}, undefined, false, undefined, this);
+    paragraph.children.unshift(pPr);
+  }
+  let rPr = pPr.findChild("w:rPr");
+  if (!rPr) {
+    rPr = /* @__PURE__ */ jsxDEV(w.rPr, {}, undefined, false, undefined, this);
+    pPr.children.push(rPr);
+  }
+  const marker = kind === "ins" ? /* @__PURE__ */ jsxDEV(Ins, {
+    meta
+  }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV(Del, {
+    meta
+  }, undefined, false, undefined, this);
+  rPr.children.push(marker);
+}
+var init_emit = __esm(() => {
+  init_jsx();
+  init_jsx_dev_runtime();
+});
+
+// src/core/index.ts
+var init_core = __esm(() => {
+  init_ast();
+  init_locators();
+  init_package();
+  init_parser();
+  init_track_changes();
+  init_emit();
+});
+
+// src/cli/respond.ts
+async function respond(payload) {
+  await Bun.write(Bun.stdout, `${JSON.stringify(payload)}
+`);
+}
+async function writeStdout(text) {
+  await Bun.write(Bun.stdout, text);
+}
+async function fail(code, message, hint) {
+  const payload = {
+    ok: false,
+    code,
+    error: message
+  };
+  if (hint)
+    payload.hint = hint;
+  await respond(payload);
+  return exitCodeFor(code);
+}
+function exitCodeFor(code) {
+  switch (code) {
+    case "USAGE":
+    case "INVALID_LOCATOR":
+      return EXIT.USAGE_ERROR;
+    case "FILE_NOT_FOUND":
+    case "PART_NOT_FOUND":
+    case "BLOCK_NOT_FOUND":
+    case "COMMENT_NOT_FOUND":
+    case "IMAGE_NOT_FOUND":
+    case "MATCH_NOT_FOUND":
+      return EXIT.NOT_FOUND;
+    case "NOT_A_ZIP":
+    case "TRACKED_CHANGE_CONFLICT":
+    case "UNHANDLED":
+      return EXIT.GENERAL_ERROR;
+  }
+}
+async function openOrFail(path) {
+  try {
+    return await openDocView(path);
+  } catch (err) {
+    if (err instanceof PkgError) {
+      if (err.code === "FILE_NOT_FOUND") {
+        return await fail("FILE_NOT_FOUND", err.message);
+      }
+      if (err.code === "NOT_A_ZIP")
+        return await fail("NOT_A_ZIP", err.message);
+    }
+    throw err;
+  }
+}
+async function resolveBlockOrFail(view, locator) {
+  try {
+    return resolveBlock(view, locator);
+  } catch (err) {
+    if (err instanceof LocatorResolveError) {
+      return await fail("BLOCK_NOT_FOUND", err.message);
+    }
+    throw err;
+  }
+}
+var EXIT;
+var init_respond = __esm(() => {
+  init_core();
+  EXIT = {
+    OK: 0,
+    GENERAL_ERROR: 1,
+    USAGE_ERROR: 2,
+    NOT_FOUND: 3
+  };
+});
+
 // src/cli/comments/helpers.tsx
 function nextCommentId(view) {
   if (!view.commentsTree)
@@ -15045,6 +15173,7 @@ async function run(args) {
         range: { type: "string" },
         text: { type: "string" },
         author: { type: "string" },
+        output: { type: "string", short: "o" },
         "dry-run": { type: "boolean" },
         help: { type: "boolean", short: "h" }
       }
@@ -15094,6 +15223,7 @@ async function run(args) {
   const date = new Date().toISOString();
   const numericId = nextCommentId(view);
   const paraId = generateParaId();
+  const outputPath = parsed.values.output;
   if (parsed.values["dry-run"]) {
     await respond({
       ok: true,
@@ -15101,7 +15231,8 @@ async function run(args) {
       dryRun: true,
       path,
       commentId: `c${numericId}`,
-      locator: rangeInput
+      locator: rangeInput,
+      ...outputPath ? { output: outputPath } : {}
     });
     return EXIT.OK;
   }
@@ -15124,11 +15255,11 @@ async function run(args) {
       text
     }
   }, undefined, false, undefined, this));
-  await saveDocView(view);
+  await saveDocView(view, outputPath);
   await respond({
     ok: true,
     operation: "comments.add",
-    path,
+    path: outputPath ?? path,
     commentId: `c${numericId}`,
     locator: rangeInput
   });
@@ -15148,6 +15279,7 @@ async function runCrossBlock(parsed, path, rangeInput, locator, text) {
   const date = new Date().toISOString();
   const numericId = nextCommentId(view);
   const paraId = generateParaId();
+  const outputPath = parsed.values.output;
   if (parsed.values["dry-run"]) {
     await respond({
       ok: true,
@@ -15155,7 +15287,8 @@ async function runCrossBlock(parsed, path, rangeInput, locator, text) {
       dryRun: true,
       path,
       commentId: `c${numericId}`,
-      locator: rangeInput
+      locator: rangeInput,
+      ...outputPath ? { output: outputPath } : {}
     });
     return EXIT.OK;
   }
@@ -15178,11 +15311,11 @@ async function runCrossBlock(parsed, path, rangeInput, locator, text) {
       text
     }
   }, undefined, false, undefined, this));
-  await saveDocView(view);
+  await saveDocView(view, outputPath);
   await respond({
     ok: true,
     operation: "comments.add",
-    path,
+    path: outputPath ?? path,
     commentId: `c${numericId}`,
     locator: rangeInput
   });
@@ -15204,6 +15337,7 @@ Required:
 
 Optional:
   --author NAME     Author name (default: $DOCX_AUTHOR)
+  -o, --output PATH Write to PATH instead of overwriting FILE
   --dry-run         Print what would be added; do not write the file
   -h, --help        Show this help
 
@@ -15219,53 +15353,6 @@ var init_add = __esm(() => {
   init_jsx_dev_runtime();
 });
 
-// src/cli/comments/trash.ts
-import { dirname, join } from "path";
-function trashPathFor(docPath) {
-  return join(dirname(docPath), TRASH_DIR, TRASH_FILE);
-}
-async function readTrash(docPath) {
-  const path = trashPathFor(docPath);
-  const file = Bun.file(path);
-  if (!await file.exists()) {
-    return { version: TRASH_VERSION, entries: [] };
-  }
-  const parsed = await file.json();
-  if (parsed.version !== TRASH_VERSION) {
-    return { version: TRASH_VERSION, entries: [] };
-  }
-  return parsed;
-}
-async function writeTrash(docPath, trash) {
-  const path = trashPathFor(docPath);
-  await Bun.write(path, `${JSON.stringify(trash, null, 2)}
-`);
-}
-async function pushTrashEntry(docPath, entry) {
-  const trash = await readTrash(docPath);
-  trash.entries.push(entry);
-  await writeTrash(docPath, trash);
-}
-async function popTrashEntry(docPath, commentId) {
-  const trash = await readTrash(docPath);
-  const fileName = docPath.split("/").pop() ?? docPath;
-  for (let index = trash.entries.length - 1;index >= 0; index--) {
-    const entry = trash.entries[index];
-    if (!entry)
-      continue;
-    if (entry.file !== fileName)
-      continue;
-    if (entry.commentId !== commentId)
-      continue;
-    trash.entries.splice(index, 1);
-    await writeTrash(docPath, trash);
-    return entry;
-  }
-  return;
-}
-var TRASH_VERSION = 1, TRASH_DIR = ".docx-cli", TRASH_FILE = "trash.json";
-var init_trash = () => {};
-
 // src/cli/comments/delete.ts
 var exports_delete = {};
 __export(exports_delete, {
@@ -15280,6 +15367,7 @@ async function run2(args) {
       allowPositionals: true,
       options: {
         id: { type: "string" },
+        output: { type: "string", short: "o" },
         "dry-run": { type: "boolean" },
         help: { type: "boolean", short: "h" }
       }
@@ -15307,31 +15395,19 @@ async function run2(args) {
   if (!commentReference) {
     return fail("COMMENT_NOT_FOUND", `Comment not found: ${commentId}`);
   }
-  const anchor = view.doc.comments.find((c) => c.id === commentId)?.anchor;
-  if (!anchor) {
-    return fail("COMMENT_NOT_FOUND", `Anchor not found for ${commentId}`);
-  }
+  const outputPath = parsed.values.output;
   if (parsed.values["dry-run"]) {
     await respond({
       ok: true,
       operation: "comments.delete",
       dryRun: true,
       path,
-      commentId
+      commentId,
+      ...outputPath ? { output: outputPath } : {}
     });
     return EXIT.OK;
   }
-  const commentXml = XmlNode2.serialize([commentReference.node]);
   const paraId = findCommentParaId(view, commentId);
-  const extXml = paraId ? extractExtEntryXml(view, paraId) : null;
-  await pushTrashEntry(path, {
-    file: path.split("/").pop() ?? path,
-    deletedAt: new Date().toISOString(),
-    commentId,
-    anchor,
-    commentXml,
-    extXml
-  });
   const commentIndex = commentReference.parent.indexOf(commentReference.node);
   if (commentIndex !== -1)
     commentReference.parent.splice(commentIndex, 1);
@@ -15342,28 +15418,15 @@ async function run2(args) {
     }
   }
   removeCommentMarkers(view.documentTree, numericId);
-  await saveDocView(view);
+  await saveDocView(view, outputPath);
   await respond({
     ok: true,
     operation: "comments.delete",
-    path,
+    path: outputPath ?? path,
     commentId
   });
   return EXIT.OK;
 }
-function extractExtEntryXml(view, paraId) {
-  if (!view.commentsExtTree)
-    return null;
-  const root = XmlNode2.findRoot(view.commentsExtTree, "w15:commentsEx");
-  if (!root)
-    return null;
-  for (const child of root.children) {
-    if (child.tag === "w15:commentEx" && child.getAttribute("w15:paraId") === paraId) {
-      return XmlNode2.serialize([child]);
-    }
-  }
-  return null;
-}
 var HELP2 = `docx comments delete \u2014 remove a comment
 
 Usage:
@@ -15373,12 +15436,10 @@ Required:
   --id ID           Comment id (e.g., c0)
 
 Optional:
+  -o, --output PATH Write to PATH instead of overwriting FILE
   --dry-run         Print what would be removed; do not write the file
   -h, --help        Show this help
 
-The deleted comment is journaled to <dir>/.docx-cli/trash.json so it can
-be brought back via "docx comments restore".
-
 Examples:
   docx comments delete doc.docx --id c2
 `;
@@ -15387,7 +15448,6 @@ var init_delete = __esm(() => {
   init_parser();
   init_respond();
   init_helpers();
-  init_trash();
 });
 
 // src/cli/comments/list.ts
@@ -15484,6 +15544,7 @@ async function run4(args) {
         to: { type: "string" },
         text: { type: "string" },
         author: { type: "string" },
+        output: { type: "string", short: "o" },
         "dry-run": { type: "boolean" },
         help: { type: "boolean", short: "h" }
       }
@@ -15521,6 +15582,7 @@ async function run4(args) {
   const date = new Date().toISOString();
   const numericId = nextCommentId(view);
   const replyParaId = generateParaId();
+  const outputPath = parsed.values.output;
   if (parsed.values["dry-run"]) {
     await respond({
       ok: true,
@@ -15528,7 +15590,8 @@ async function run4(args) {
       dryRun: true,
       path,
       commentId: `c${numericId}`,
-      parentId: `c${parentNumericId}`
+      parentId: `c${parentNumericId}`,
+      ...outputPath ? { output: outputPath } : {}
     });
     return EXIT.OK;
   }
@@ -15549,11 +15612,11 @@ async function run4(args) {
     "w15:paraIdParent": parentParaId,
     "w15:done": "0"
   }));
-  await saveDocView(view);
+  await saveDocView(view, outputPath);
   await respond({
     ok: true,
     operation: "comments.reply",
-    path,
+    path: outputPath ?? path,
     commentId: `c${numericId}`,
     parentId: `c${parentNumericId}`
   });
@@ -15570,6 +15633,7 @@ Required:
 
 Optional:
   --author NAME     Author name (default: $DOCX_AUTHOR)
+  -o, --output PATH Write to PATH instead of overwriting FILE
   --dry-run         Print what would be added; do not write the file
   -h, --help        Show this help
 
@@ -15599,6 +15663,7 @@ async function run5(args) {
       options: {
         id: { type: "string" },
         unset: { type: "boolean" },
+        output: { type: "string", short: "o" },
         "dry-run": { type: "boolean" },
         help: { type: "boolean", short: "h" }
       }
@@ -15630,6 +15695,7 @@ async function run5(args) {
   if (!paraId) {
     return fail("COMMENT_NOT_FOUND", `Comment c${numericId} could not be assigned a w14:paraId.`);
   }
+  const outputPath = parsed.values.output;
   if (parsed.values["dry-run"]) {
     await respond({
       ok: true,
@@ -15637,7 +15703,8 @@ async function run5(args) {
       dryRun: true,
       path,
       commentId: `c${numericId}`,
-      resolved
+      resolved,
+      ...outputPath ? { output: outputPath } : {}
     });
     return EXIT.OK;
   }
@@ -15651,11 +15718,11 @@ async function run5(args) {
     entry.setAttribute("w15:done", "1");
   else
     delete entry.attributes["w15:done"];
-  await saveDocView(view);
+  await saveDocView(view, outputPath);
   await respond({
     ok: true,
     operation: "comments.resolve",
-    path,
+    path: outputPath ?? path,
     commentId: `c${numericId}`,
     resolved
   });
@@ -15671,6 +15738,7 @@ Required:
 
 Optional:
   --unset           Mark unresolved instead of resolved
+  -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
 
@@ -15685,132 +15753,15 @@ var init_resolve2 = __esm(() => {
   init_helpers();
 });
 
-// src/cli/comments/restore.ts
-var exports_restore = {};
-__export(exports_restore, {
+// src/cli/comments/index.ts
+var exports_comments = {};
+__export(exports_comments, {
   run: () => run6
 });
-import { parseArgs as parseArgs6 } from "util";
 async function run6(args) {
-  let parsed;
-  try {
-    parsed = parseArgs6({
-      args,
-      allowPositionals: true,
-      options: {
-        id: { type: "string" },
-        "dry-run": { type: "boolean" },
-        help: { type: "boolean", short: "h" }
-      }
-    });
-  } catch (parseError) {
-    const message = parseError instanceof Error ? parseError.message : String(parseError);
-    return fail("USAGE", message, HELP6);
-  }
-  if (parsed.values.help) {
-    await writeStdout(HELP6);
-    return EXIT.OK;
-  }
-  const path = parsed.positionals[0];
-  if (!path)
-    return fail("USAGE", "Missing FILE argument", HELP6);
-  const idInput = parsed.values.id;
-  if (!idInput)
-    return fail("USAGE", "Missing --id COMMENT_ID", HELP6);
-  const commentId = idInput.startsWith("c") ? idInput : `c${idInput}`;
-  const numericId = commentId.slice(1);
-  if (parsed.values["dry-run"]) {
-    await respond({
-      ok: true,
-      operation: "comments.restore",
-      dryRun: true,
-      path,
-      commentId
-    });
-    return EXIT.OK;
-  }
-  const entry = await popTrashEntry(path, commentId);
-  if (!entry) {
-    return fail("COMMENT_NOT_FOUND", `No trashed entry for ${commentId} in ${path}`, "Trash lives at <dir>/.docx-cli/trash.json \u2014 make sure it's the same directory.");
-  }
-  const view = await openOrFail(path);
-  if (typeof view === "number")
-    return view;
-  const startBlock = view.blockReferences.get(entry.anchor.startBlockId);
-  if (!startBlock) {
-    return fail("BLOCK_NOT_FOUND", `Original anchor block ${entry.anchor.startBlockId} no longer exists`);
-  }
-  const endBlock = view.blockReferences.get(entry.anchor.endBlockId);
-  if (!endBlock) {
-    return fail("BLOCK_NOT_FOUND", `Original anchor block ${entry.anchor.endBlockId} no longer exists`);
-  }
-  try {
-    addCommentRangeMarkers(startBlock.node, entry.anchor.startOffset, endBlock.node, entry.anchor.endOffset, numericId);
-  } catch (error) {
-    if (error instanceof SpanOutOfRangeError) {
-      return fail("INVALID_LOCATOR", `Saved span no longer fits the block: ${error.message}`);
-    }
-    throw error;
-  }
-  const commentNodes = XmlNode2.parse(entry.commentXml);
-  const commentNode = commentNodes[0];
-  if (!commentNode) {
-    return fail("USAGE", "Trashed commentXml is empty");
-  }
-  const commentsRoot = ensureCommentsPart(view);
-  commentsRoot.children.push(commentNode);
-  if (entry.extXml) {
-    const extNodes = XmlNode2.parse(entry.extXml);
-    const extNode = extNodes[0];
-    if (extNode) {
-      const extRoot = ensureCommentsExtPart(view);
-      extRoot.children.push(extNode);
-    }
-  }
-  await saveDocView(view);
-  await respond({
-    ok: true,
-    operation: "comments.restore",
-    path,
-    commentId
-  });
-  return EXIT.OK;
-}
-var HELP6 = `docx comments restore \u2014 undo a recent delete
-
-Usage:
-  docx comments restore FILE --id cN [options]
-
-Required:
-  --id ID           Comment id to restore (e.g., c0)
-
-Optional:
-  --dry-run         Print what would be restored; do not write the file
-  -h, --help        Show this help
-
-Pulls the most recent matching entry from <dir>/.docx-cli/trash.json
-and re-anchors the comment at its original location.
-
-Examples:
-  docx comments restore doc.docx --id c2
-`;
-var init_restore = __esm(() => {
-  init_core();
-  init_parser();
-  init_respond();
-  init_helpers();
-  init_trash();
-});
-
-// src/cli/comments/index.ts
-var exports_comments = {};
-__export(exports_comments, {
-  run: () => run7
-});
-async function run7(args) {
   const verb = args[0];
   if (!verb || verb === "--help" || verb === "-h" || verb === "help") {
-    await writeStdout(HELP7);
+    await writeStdout(HELP6);
     return verb ? 0 : 2;
   }
   const loader = SUBCOMMANDS[verb];
@@ -15820,7 +15771,7 @@ async function run7(args) {
   const module_ = await loader();
   return module_.run(args.slice(1));
 }
-var SUBCOMMANDS, HELP7 = `docx comments \u2014 manage Word comments
+var SUBCOMMANDS, HELP6 = `docx comments \u2014 manage Word comments
 
 Usage:
   docx comments <verb> FILE [options]
@@ -15831,7 +15782,6 @@ Verbs:
   list     Print existing comments as JSON
   resolve  Mark a comment resolved
   delete   Remove a comment
-  restore  Restore a recently deleted comment
 
 Run "docx comments <verb> --help" for verb-specific help.
 `;
@@ -15842,8 +15792,7 @@ var init_comments = __esm(() => {
     delete: () => Promise.resolve().then(() => (init_delete(), exports_delete)),
     list: () => Promise.resolve().then(() => (init_list(), exports_list)),
     reply: () => Promise.resolve().then(() => (init_reply(), exports_reply)),
-    resolve: () => Promise.resolve().then(() => (init_resolve2(), exports_resolve)),
-    restore: () => Promise.resolve().then(() => (init_restore(), exports_restore))
+    resolve: () => Promise.resolve().then(() => (init_resolve2(), exports_resolve))
   };
 });
 
@@ -15939,13 +15888,13 @@ var init_template = __esm(() => {
 // src/cli/create/index.tsx
 var exports_create = {};
 __export(exports_create, {
-  run: () => run8
+  run: () => run7
 });
-import { parseArgs as parseArgs7 } from "util";
-async function run8(args) {
+import { parseArgs as parseArgs6 } from "util";
+async function run7(args) {
   let parsed;
   try {
-    parsed = parseArgs7({
+    parsed = parseArgs6({
       args,
       allowPositionals: true,
       options: {
@@ -15957,15 +15906,15 @@ async function run8(args) {
       }
     });
   } catch (e) {
-    return fail("USAGE", e instanceof Error ? e.message : String(e), HELP8);
+    return fail("USAGE", e instanceof Error ? e.message : String(e), HELP7);
   }
   if (parsed.values.help) {
-    await writeStdout(HELP8);
+    await writeStdout(HELP7);
     return EXIT.OK;
   }
   const path = parsed.positionals[0];
   if (!path) {
-    return fail("USAGE", "Missing FILE argument", HELP8);
+    return fail("USAGE", "Missing FILE argument", HELP7);
   }
   if (await Bun.file(path).exists() && !parsed.values.force) {
     return fail("USAGE", `File already exists: ${path}`, "Pass --force to overwrite.");
@@ -15985,7 +15934,7 @@ async function run8(args) {
     compression: "DEFLATE",
     compressionOptions: { level: 6 }
   });
-  await Bun.write(path, buf);
+  await writeAtomic(path, buf);
   await respond({
     ok: true,
     operation: "create",
@@ -15995,7 +15944,7 @@ async function run8(args) {
   });
   return EXIT.OK;
 }
-var import_jszip2, HELP8 = `docx create \u2014 create a new minimal .docx
+var import_jszip2, HELP7 = `docx create \u2014 create a new minimal .docx
 
 Usage:
   docx create FILE [options]
@@ -16012,43 +15961,45 @@ Examples:
   docx create out.docx --title "Spec" --author "Claude" --text "First paragraph."
 `;
 var init_create = __esm(() => {
+  init_package();
   init_respond();
   init_template();
   import_jszip2 = __toESM(require_lib3(), 1);
 });
 
-// src/cli/delete/index.ts
+// src/cli/delete/index.tsx
 var exports_delete2 = {};
 __export(exports_delete2, {
-  run: () => run9
+  run: () => run8
 });
-import { parseArgs as parseArgs8 } from "util";
-async function run9(args) {
+import { parseArgs as parseArgs7 } from "util";
+async function run8(args) {
   let parsed;
   try {
-    parsed = parseArgs8({
+    parsed = parseArgs7({
       args,
       allowPositionals: true,
       options: {
         at: { type: "string" },
+        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, HELP9);
+    return fail("USAGE", message, HELP8);
   }
   if (parsed.values.help) {
-    await writeStdout(HELP9);
+    await writeStdout(HELP8);
     return EXIT.OK;
   }
   const path = parsed.positionals[0];
   if (!path)
-    return fail("USAGE", "Missing FILE argument", HELP9);
+    return fail("USAGE", "Missing FILE argument", HELP8);
   const at = parsed.values.at;
   if (!at)
-    return fail("USAGE", "Missing --at LOCATOR", HELP9);
+    return fail("USAGE", "Missing --at LOCATOR", HELP8);
   const view = await openOrFail(path);
   if (typeof view === "number")
     return view;
@@ -16059,22 +16010,67 @@ async function run9(args) {
   if (targetIndex === -1) {
     return fail("BLOCK_NOT_FOUND", "Block reference is stale (parent does not contain it)");
   }
+  const outputPath = parsed.values.output;
   if (parsed.values["dry-run"]) {
     await respond({
       ok: true,
       operation: "delete",
       dryRun: true,
       path,
-      locator: at
+      locator: at,
+      ...outputPath ? { output: outputPath } : {}
     });
     return EXIT.OK;
   }
-  blockRef.parent.splice(targetIndex, 1);
-  await saveDocView(view);
-  await respond({ ok: true, operation: "delete", path, locator: at });
+  if (isTrackChangesEnabled(view)) {
+    if (blockRef.node.tag !== "w:p") {
+      return fail("TRACKED_CHANGE_CONFLICT", "Tracked deletion of non-paragraph blocks (e.g., tables) is not supported", "Use `docx track-changes off` first, or delete table contents row-by-row.");
+    }
+    applyTrackedDeletion(view, blockRef.node);
+  } else {
+    blockRef.parent.splice(targetIndex, 1);
+  }
+  await saveDocView(view, outputPath);
+  await respond({
+    ok: true,
+    operation: "delete",
+    path: outputPath ?? path,
+    locator: at
+  });
   return EXIT.OK;
 }
-var HELP9 = `docx delete \u2014 remove a block at a locator
+function applyTrackedDeletion(view, paragraph) {
+  const allocator = createRevisionAllocator(view);
+  const baseMeta = { author: resolveAuthor(), date: resolveDate() };
+  const mintMeta = () => ({
+    ...baseMeta,
+    revisionId: allocator.next()
+  });
+  const newChildren = [];
+  let runBuffer = [];
+  const flush = () => {
+    if (runBuffer.length === 0)
+      return;
+    const converted = runBuffer.map((run9) => convertTextToDelText(run9));
+    newChildren.push(/* @__PURE__ */ jsxDEV(Del, {
+      meta: mintMeta(),
+      children: converted
+    }, undefined, false, undefined, this));
+    runBuffer = [];
+  };
+  for (const child of paragraph.children) {
+    if (child.tag === "w:r") {
+      runBuffer.push(child);
+      continue;
+    }
+    flush();
+    newChildren.push(child);
+  }
+  flush();
+  paragraph.children = newChildren;
+  markParagraphMarkAs(paragraph, "del", mintMeta());
+}
+var HELP8 = `docx delete \u2014 remove a block at a locator
 
 Usage:
   docx delete FILE [options]
@@ -16082,6 +16078,7 @@ Usage:
 Locator (required):
   --at LOCATOR      Block to remove (e.g., p3, t0)
 
+  -o, --output PATH Write to PATH instead of overwriting FILE
   --dry-run         Print what would be removed; do not write the file
   -h, --help        Show this help
 
@@ -16092,6 +16089,7 @@ Examples:
 var init_delete2 = __esm(() => {
   init_core();
   init_respond();
+  init_jsx_dev_runtime();
 });
 
 // src/cli/insert/emit.tsx
@@ -16103,68 +16101,68 @@ function Paragraph(props) {
       /* @__PURE__ */ jsxDEV(ParagraphProperties, {
         options: { style, alignment }
       }, undefined, false, undefined, this),
-      runs.map((run10) => /* @__PURE__ */ jsxDEV(RunElement, {
-        run: run10
+      runs.map((run9) => /* @__PURE__ */ jsxDEV(RunElement, {
+        run: run9
       }, undefined, false, undefined, this))
     ]
   }, undefined, true, undefined, this);
 }
-function RunElement({ run: run10 }) {
-  if (run10.type === "text")
+function RunElement({ run: run9 }) {
+  if (run9.type === "text")
     return /* @__PURE__ */ jsxDEV(TextRunElement, {
-      run: run10
+      run: run9
     }, undefined, false, undefined, this);
-  if (run10.type === "break") {
+  if (run9.type === "break") {
     return /* @__PURE__ */ jsxDEV(w.r, {
       children: /* @__PURE__ */ jsxDEV(w.br, {
-        "w-type": run10.kind === "line" ? undefined : run10.kind
+        "w-type": run9.kind === "line" ? undefined : run9.kind
       }, undefined, false, undefined, this)
     }, undefined, false, undefined, this);
   }
-  if (run10.type === "tab") {
+  if (run9.type === "tab") {
     return /* @__PURE__ */ jsxDEV(w.r, {
       children: /* @__PURE__ */ jsxDEV(w.tab, {}, undefined, false, undefined, this)
     }, undefined, false, undefined, this);
   }
-  throw new Error(`Cannot emit run of type "${run10.type}" \u2014 image emission lives in the images command.`);
+  throw new Error(`Cannot emit run of type "${run9.type}" \u2014 image emission lives in the images command.`);
 }
-function TextRunElement({ run: run10 }) {
+function TextRunElement({ run: run9 }) {
   return /* @__PURE__ */ jsxDEV(w.r, {
     children: [
       /* @__PURE__ */ jsxDEV(RunProperties, {
-        run: run10
+        run: run9
       }, undefined, false, undefined, this),
       /* @__PURE__ */ jsxDEV(w.t, {
         "xml:space": "preserve",
-        children: run10.text
+        children: run9.text
       }, undefined, false, undefined, this)
     ]
   }, undefined, true, undefined, this);
 }
-function RunProperties({ run: run10 }) {
-  const isEmpty = FORMATTING_KEYS.every((key) => run10[key] == null);
+function RunProperties({ run: run9 }) {
+  const isEmpty = FORMATTING_KEYS.every((key) => run9[key] == null);
   if (isEmpty)
     return null;
   return /* @__PURE__ */ jsxDEV(w.rPr, {
     children: [
-      run10.color && /* @__PURE__ */ jsxDEV(w.color, {
-        "w-val": run10.color
+      run9.color && /* @__PURE__ */ jsxDEV(w.color, {
+        "w-val": run9.color
       }, undefined, false, undefined, this),
-      run10.highlight && /* @__PURE__ */ jsxDEV(w.highlight, {
-        "w-val": run10.highlight
+      run9.highlight && /* @__PURE__ */ jsxDEV(w.highlight, {
+        "w-val": run9.highlight
       }, undefined, false, undefined, this),
-      run10.bold && /* @__PURE__ */ jsxDEV(w.b, {}, undefined, false, undefined, this),
-      run10.italic && /* @__PURE__ */ jsxDEV(w.i, {}, undefined, false, undefined, this),
-      run10.underline && /* @__PURE__ */ jsxDEV(w.u, {
-        "w-val": run10.underline
+      run9.bold && /* @__PURE__ */ jsxDEV(w.b, {}, undefined, false, undefined, this),
+      run9.italic && /* @__PURE__ */ jsxDEV(w.i, {}, undefined, false, undefined, this),
+      run9.underline && /* @__PURE__ */ jsxDEV(w.u, {
+        "w-val": run9.underline
       }, undefined, false, undefined, this),
-      run10.strike && /* @__PURE__ */ jsxDEV(w.strike, {}, undefined, false, undefined, this),
-      run10.font && /* @__PURE__ */ jsxDEV(w.rFonts, {
-        "w-ascii": run10.font,
-        "w-hAnsi": run10.font
+      run9.strike && /* @__PURE__ */ jsxDEV(w.strike, {}, undefined, false, undefined, this),
+      run9.font && /* @__PURE__ */ jsxDEV(w.rFonts, {
+        "w-ascii": run9.font,
+        "w-hAnsi": run9.font
       }, undefined, false, undefined, this),
-      run10.sizeHalfPoints !== undefined && /* @__PURE__ */ jsxDEV(w.sz, {
-        "w-val": String(run10.sizeHalfPoints)
+      run9.sizeHalfPoints !== undefined && /* @__PURE__ */ jsxDEV(w.sz, {
+        "w-val": String(run9.sizeHalfPoints)
       }, undefined, false, undefined, this)
     ]
   }, undefined, true, undefined, this);
@@ -16196,7 +16194,7 @@ function textRunFromProps(props) {
   return { type: "text", text, ...formatting };
 }
 var FORMATTING_KEYS;
-var init_emit = __esm(() => {
+var init_emit2 = __esm(() => {
   init_jsx();
   init_jsx_dev_runtime();
   FORMATTING_KEYS = [
@@ -16214,13 +16212,13 @@ var init_emit = __esm(() => {
 // src/cli/edit/index.tsx
 var exports_edit = {};
 __export(exports_edit, {
-  run: () => run10
+  run: () => run9
 });
-import { parseArgs as parseArgs9 } from "util";
-async function run10(args) {
+import { parseArgs as parseArgs8 } from "util";
+async function run9(args) {
   let parsed;
   try {
-    parsed = parseArgs9({
+    parsed = parseArgs8({
       args,
       allowPositionals: true,
       options: {
@@ -16232,31 +16230,32 @@ async function run10(args) {
         color: { type: "string" },
         bold: { type: "boolean" },
         italic: { 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, HELP10);
+    return fail("USAGE", message, HELP9);
   }
   if (parsed.values.help) {
-    await writeStdout(HELP10);
+    await writeStdout(HELP9);
     return EXIT.OK;
   }
   const path = parsed.positionals[0];
   if (!path)
-    return fail("USAGE", "Missing FILE argument", HELP10);
+    return fail("USAGE", "Missing FILE argument", HELP9);
   const at = parsed.values.at;
   if (!at)
-    return fail("USAGE", "Missing --at LOCATOR", HELP10);
+    return fail("USAGE", "Missing --at LOCATOR", HELP9);
   const text = parsed.values.text;
   const runsJson = parsed.values.runs;
   if (!text && !runsJson) {
-    return fail("USAGE", "Missing content: pass --text or --runs", HELP10);
+    return fail("USAGE", "Missing content: pass --text or --runs", HELP9);
   }
   if (text && runsJson) {
-    return fail("USAGE", "Pass either --text or --runs, not both", HELP10);
+    return fail("USAGE", "Pass either --text or --runs, not both", HELP9);
   }
   const paragraphOptions = {};
   const styleValue = parsed.values.style;
@@ -16305,22 +16304,81 @@ async function run10(args) {
   if (targetIndex === -1) {
     return fail("BLOCK_NOT_FOUND", "Block reference is stale (parent does not contain it)");
   }
+  const outputPath = parsed.values.output;
   if (parsed.values["dry-run"]) {
     await respond({
       ok: true,
       operation: "edit",
       dryRun: true,
       path,
-      locator: at
+      locator: at,
+      ...outputPath ? { output: outputPath } : {}
     });
     return EXIT.OK;
   }
-  blockRef.parent.splice(targetIndex, 1, paragraphNode);
-  await saveDocView(view);
-  await respond({ ok: true, operation: "edit", path, locator: at });
+  if (isTrackChangesEnabled(view)) {
+    applyTrackedEdit(view, blockRef.node, paragraphNode);
+  } else {
+    blockRef.parent.splice(targetIndex, 1, paragraphNode);
+  }
+  await saveDocView(view, outputPath);
+  await respond({
+    ok: true,
+    operation: "edit",
+    path: outputPath ?? path,
+    locator: at
+  });
   return EXIT.OK;
 }
-var HELP10 = `docx edit \u2014 replace a paragraph at a locator
+function applyTrackedEdit(view, existingParagraph, newParagraph) {
+  const allocator = createRevisionAllocator(view);
+  const baseMeta = { author: resolveAuthor(), date: resolveDate() };
+  const mintMeta = () => ({
+    ...baseMeta,
+    revisionId: allocator.next()
+  });
+  const oldRuns = [];
+  const oldNonRuns = [];
+  for (const child of existingParagraph.children) {
+    if (child.tag === "w:r")
+      oldRuns.push(child);
+    else
+      oldNonRuns.push(child);
+  }
+  let newPPr = null;
+  const newRuns = [];
+  for (const child of newParagraph.children) {
+    if (child.tag === "w:pPr")
+      newPPr = child;
+    else if (child.tag === "w:r")
+      newRuns.push(child);
+  }
+  const rebuilt = [];
+  if (newPPr) {
+    rebuilt.push(newPPr);
+    for (const child of oldNonRuns) {
+      if (child.tag !== "w:pPr")
+        rebuilt.push(child);
+    }
+  } else {
+    rebuilt.push(...oldNonRuns);
+  }
+  if (oldRuns.length > 0) {
+    const deletedRuns = oldRuns.map((run10) => convertTextToDelText(run10));
+    rebuilt.push(/* @__PURE__ */ jsxDEV(Del, {
+      meta: mintMeta(),
+      children: deletedRuns
+    }, undefined, false, undefined, this));
+  }
+  if (newRuns.length > 0) {
+    rebuilt.push(/* @__PURE__ */ jsxDEV(Ins, {
+      meta: mintMeta(),
+      children: newRuns
+    }, undefined, false, undefined, this));
+  }
+  existingParagraph.children = rebuilt;
+}
+var HELP9 = `docx edit \u2014 replace a paragraph at a locator
 
 Usage:
   docx edit FILE [options]
@@ -16341,6 +16399,7 @@ Run options (only with --text):
   --bold            Bold
   --italic          Italic
 
+  -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
 
@@ -16350,7 +16409,7 @@ Examples:
 `;
 var init_edit = __esm(() => {
   init_core();
-  init_emit();
+  init_emit2();
   init_respond();
   init_jsx_dev_runtime();
 });
@@ -16409,14 +16468,18 @@ function regexMatcher(pattern, ignoreCase) {
 function collectMatches(blocks, matcher, out) {
   for (const block of blocks) {
     if (block.type === "paragraph") {
-      const paragraphText = block.runs.map((run11) => run11.type === "text" ? run11.text : "").join("");
+      const paragraphText = block.runs.map((run10) => run10.type === "text" ? run10.text : "").join("");
       for (const span of matcher(paragraphText)) {
-        out.push({
+        const match = {
           blockId: block.id,
           start: span.start,
           end: span.end,
           text: span.text
-        });
+        };
+        const overlaps = trackedChangesOverlapping(block, span.start, span.end);
+        if (overlaps.length > 0)
+          match.trackedChanges = overlaps;
+        out.push(match);
       }
       continue;
     }
@@ -16429,17 +16492,41 @@ function collectMatches(blocks, matcher, out) {
     }
   }
 }
+function trackedChangesOverlapping(paragraph, start, end) {
+  const seen = new Set;
+  const out = [];
+  let offset = 0;
+  for (const run10 of paragraph.runs) {
+    const length = run10.type === "text" ? run10.text.length : 0;
+    const runStart = offset;
+    const runEnd = offset + length;
+    offset = runEnd;
+    if (run10.type !== "text")
+      continue;
+    if (runEnd <= start || runStart >= end)
+      continue;
+    const change = run10.trackedChange;
+    if (!change)
+      continue;
+    const key = `${change.kind}:${change.revisionId}:${change.author}`;
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    out.push(change);
+  }
+  return out;
+}
 
 // src/cli/find/index.ts
 var exports_find = {};
 __export(exports_find, {
-  run: () => run11
+  run: () => run10
 });
-import { parseArgs as parseArgs10 } from "util";
-async function run11(args) {
+import { parseArgs as parseArgs9 } from "util";
+async function run10(args) {
   let parsed;
   try {
-    parsed = parseArgs10({
+    parsed = parseArgs9({
       args,
       allowPositionals: true,
       options: {
@@ -16452,18 +16539,18 @@ async function run11(args) {
     });
   } catch (parseError) {
     const message = parseError instanceof Error ? parseError.message : String(parseError);
-    return fail("USAGE", message, HELP11);
+    return fail("USAGE", message, HELP10);
   }
   if (parsed.values.help) {
-    await writeStdout(HELP11);
+    await writeStdout(HELP10);
     return EXIT.OK;
   }
   const path = parsed.positionals[0];
   const query = parsed.positionals[1];
   if (!path)
-    return fail("USAGE", "Missing FILE argument", HELP11);
+    return fail("USAGE", "Missing FILE argument", HELP10);
   if (query == null)
-    return fail("USAGE", "Missing QUERY argument", HELP11);
+    return fail("USAGE", "Missing QUERY argument", HELP10);
   const ignoreCase = Boolean(parsed.values["ignore-case"]);
   const useRegex = Boolean(parsed.values.regex);
   const wantAll = Boolean(parsed.values.all);
@@ -16512,7 +16599,7 @@ async function run11(args) {
   });
   return EXIT.OK;
 }
-var HELP11 = `docx find \u2014 locate text spans and return their locators
+var HELP10 = `docx find \u2014 locate text spans and return their locators
 
 Usage:
   docx find FILE QUERY [options]
@@ -16545,14 +16632,14 @@ var init_find = __esm(() => {
 // src/cli/images/extract.ts
 var exports_extract = {};
 __export(exports_extract, {
-  run: () => run12
+  run: () => run11
 });
-import { join as join2 } from "path";
-import { parseArgs as parseArgs11 } from "util";
-async function run12(args) {
+import { join } from "path";
+import { parseArgs as parseArgs10 } from "util";
+async function run11(args) {
   let parsed;
   try {
-    parsed = parseArgs11({
+    parsed = parseArgs10({
       args,
       allowPositionals: true,
       options: {
@@ -16563,18 +16650,18 @@ async function run12(args) {
     });
   } catch (parseError) {
     const message = parseError instanceof Error ? parseError.message : String(parseError);
-    return fail("USAGE", message, HELP12);
+    return fail("USAGE", message, HELP11);
   }
   if (parsed.values.help) {
-    await writeStdout(HELP12);
+    await writeStdout(HELP11);
     return EXIT.OK;
   }
   const path = parsed.positionals[0];
   if (!path)
-    return fail("USAGE", "Missing FILE argument", HELP12);
+    return fail("USAGE", "Missing FILE argument", HELP11);
   const outputDir = parsed.values.to;
   if (!outputDir)
-    return fail("USAGE", "Missing --to DIR", HELP12);
+    return fail("USAGE", "Missing --to DIR", HELP11);
   const targetId = parsed.values.id;
   const view = await openOrFail(path);
   if (typeof view === "number")
@@ -16594,7 +16681,7 @@ async function run12(args) {
       continue;
     const extension = extensionFor(image.contentType, reference.partName);
     const fileName = `${image.hash}.${extension}`;
-    const outputPath = join2(outputDir, fileName);
+    const outputPath = join(outputDir, fileName);
     if (!seenHashes.has(image.hash)) {
       const bytes = await view.pkg.readBytes(reference.partName);
       await Bun.write(outputPath, bytes);
@@ -16612,9 +16699,9 @@ async function run12(args) {
 function collectImages(blocks, out) {
   for (const block of blocks) {
     if (block.type === "paragraph") {
-      for (const run13 of block.runs) {
-        if (run13.type === "image")
-          out.push(run13);
+      for (const run12 of block.runs) {
+        if (run12.type === "image")
+          out.push(run12);
       }
       continue;
     }
@@ -16634,7 +16721,7 @@ function extensionFor(contentType, partName) {
   const fromName = partName.split(".").pop()?.toLowerCase();
   return fromName ?? "bin";
 }
-var HELP12 = `docx images extract \u2014 dump image bytes to a directory
+var HELP11 = `docx images extract \u2014 dump image bytes to a directory
 
 Usage:
   docx images extract FILE --to DIR [options]
@@ -16675,13 +16762,13 @@ var init_extract = __esm(() => {
 // src/cli/images/list.ts
 var exports_list2 = {};
 __export(exports_list2, {
-  run: () => run13
+  run: () => run12
 });
-import { parseArgs as parseArgs12 } from "util";
-async function run13(args) {
+import { parseArgs as parseArgs11 } from "util";
+async function run12(args) {
   let parsed;
   try {
-    parsed = parseArgs12({
+    parsed = parseArgs11({
       args,
       allowPositionals: true,
       options: {
@@ -16690,15 +16777,15 @@ async function run13(args) {
     });
   } catch (parseError) {
     const message = parseError instanceof Error ? parseError.message : String(parseError);
-    return fail("USAGE", message, HELP13);
+    return fail("USAGE", message, HELP12);
   }
   if (parsed.values.help) {
-    await writeStdout(HELP13);
+    await writeStdout(HELP12);
     return EXIT.OK;
   }
   const path = parsed.positionals[0];
   if (!path)
-    return fail("USAGE", "Missing FILE argument", HELP13);
+    return fail("USAGE", "Missing FILE argument", HELP12);
   const view = await openOrFail(path);
   if (typeof view === "number")
     return view;
@@ -16711,9 +16798,9 @@ async function run13(args) {
 function collectImages2(blocks, out) {
   for (const block of blocks) {
     if (block.type === "paragraph") {
-      for (const run14 of block.runs) {
-        if (run14.type === "image")
-          out.push(run14);
+      for (const run13 of block.runs) {
+        if (run13.type === "image")
+          out.push(run13);
       }
       continue;
     }
@@ -16726,7 +16813,7 @@ function collectImages2(blocks, out) {
     }
   }
 }
-var HELP13 = `docx images list \u2014 print image manifest as JSON
+var HELP12 = `docx images list \u2014 print image manifest as JSON
 
 Usage:
   docx images list FILE [options]
@@ -16745,39 +16832,40 @@ var init_list2 = __esm(() => {
 // src/cli/images/replace.ts
 var exports_replace = {};
 __export(exports_replace, {
-  run: () => run14
+  run: () => run13
 });
-import { parseArgs as parseArgs13 } from "util";
-async function run14(args) {
+import { parseArgs as parseArgs12 } from "util";
+async function run13(args) {
   let parsed;
   try {
-    parsed = parseArgs13({
+    parsed = parseArgs12({
       args,
       allowPositionals: true,
       options: {
         at: { type: "string" },
         with: { type: "string" },
+        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, HELP14);
+    return fail("USAGE", message, HELP13);
   }
   if (parsed.values.help) {
-    await writeStdout(HELP14);
+    await writeStdout(HELP13);
     return EXIT.OK;
   }
   const path = parsed.positionals[0];
   if (!path)
-    return fail("USAGE", "Missing FILE argument", HELP14);
+    return fail("USAGE", "Missing FILE argument", HELP13);
   const targetId = parsed.values.at;
   if (!targetId)
-    return fail("USAGE", "Missing --at IMG_ID", HELP14);
+    return fail("USAGE", "Missing --at IMG_ID", HELP13);
   const sourcePath = parsed.values.with;
   if (!sourcePath)
-    return fail("USAGE", "Missing --with PATH", HELP14);
+    return fail("USAGE", "Missing --with PATH", HELP13);
   const sourceFile = Bun.file(sourcePath);
   if (!await sourceFile.exists()) {
     return fail("FILE_NOT_FOUND", `Replacement file not found: ${sourcePath}`);
@@ -16796,6 +16884,7 @@ async function run14(args) {
   }
   const originalPartName = reference.partName;
   const newPartName = renameExtension(originalPartName, newExtension);
+  const outputPath = parsed.values.output;
   if (parsed.values["dry-run"]) {
     await respond({
       ok: true,
@@ -16804,7 +16893,8 @@ async function run14(args) {
       path,
       imageId: targetId,
       from: { partName: originalPartName, mimeType: reference.contentType },
-      to: { partName: newPartName, mimeType: newMimeType }
+      to: { partName: newPartName, mimeType: newMimeType },
+      ...outputPath ? { output: outputPath } : {}
     });
     return EXIT.OK;
   }
@@ -16819,11 +16909,11 @@ async function run14(args) {
     reference.partName = newPartName;
     reference.contentType = newMimeType;
   }
-  await saveDocView(view);
+  await saveDocView(view, outputPath);
   await respond({
     ok: true,
     operation: "images.replace",
-    path,
+    path: outputPath ?? path,
     imageId: targetId,
     partName: newPartName,
     mimeType: newMimeType,
@@ -16867,7 +16957,7 @@ function ensureContentTypeDefault(contentTypesTree, extension, mimeType) {
   }
   types.children.push(new XmlNode2("Default", { Extension: extension, ContentType: mimeType }));
 }
-var HELP14 = `docx images replace \u2014 swap an image's bytes
+var HELP13 = `docx images replace \u2014 swap an image's bytes
 
 Usage:
   docx images replace FILE --at IMG_ID --with PATH [options]
@@ -16877,6 +16967,7 @@ Required:
   --with PATH       New image file (any image MIME type)
 
 Optional:
+  -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
 
@@ -16909,12 +17000,12 @@ var init_replace = __esm(() => {
 // src/cli/images/index.ts
 var exports_images = {};
 __export(exports_images, {
-  run: () => run15
+  run: () => run14
 });
-async function run15(args) {
+async function run14(args) {
   const verb = args[0];
   if (!verb || verb === "--help" || verb === "-h" || verb === "help") {
-    await writeStdout(HELP15);
+    await writeStdout(HELP14);
     return verb ? 0 : 2;
   }
   const loader = SUBCOMMANDS2[verb];
@@ -16924,7 +17015,7 @@ async function run15(args) {
   const module_ = await loader();
   return module_.run(args.slice(1));
 }
-var SUBCOMMANDS2, HELP15 = `docx images \u2014 manage embedded images
+var SUBCOMMANDS2, HELP14 = `docx images \u2014 manage embedded images
 
 Usage:
   docx images <verb> FILE [options]
@@ -17057,13 +17148,13 @@ var init_types = () => {};
 // src/cli/info/schema.ts
 var exports_schema = {};
 __export(exports_schema, {
-  run: () => run16
+  run: () => run15
 });
-import { parseArgs as parseArgs14 } from "util";
-async function run16(args) {
+import { parseArgs as parseArgs13 } from "util";
+async function run15(args) {
   let parsed;
   try {
-    parsed = parseArgs14({
+    parsed = parseArgs13({
       args,
       allowPositionals: true,
       options: {
@@ -17074,10 +17165,10 @@ async function run16(args) {
     });
   } catch (parseError) {
     const message = parseError instanceof Error ? parseError.message : String(parseError);
-    return fail("USAGE", message, HELP16);
+    return fail("USAGE", message, HELP15);
   }
   if (parsed.values.help) {
-    await writeStdout(HELP16);
+    await writeStdout(HELP15);
     return EXIT.OK;
   }
   if (parsed.values.ts) {
@@ -17087,7 +17178,7 @@ async function run16(args) {
   await respond(JSON_SCHEMA);
   return EXIT.OK;
 }
-var HELP16 = `docx schema \u2014 print the AST type definitions
+var HELP15 = `docx schema \u2014 print the AST type definitions
 
 Usage:
   docx schema [options]
@@ -17279,13 +17370,13 @@ var init_schema = __esm(() => {
 // src/cli/info/locators.ts
 var exports_locators = {};
 __export(exports_locators, {
-  run: () => run17
+  run: () => run16
 });
-import { parseArgs as parseArgs15 } from "util";
-async function run17(args) {
+import { parseArgs as parseArgs14 } from "util";
+async function run16(args) {
   let parsed;
   try {
-    parsed = parseArgs15({
+    parsed = parseArgs14({
       args,
       allowPositionals: true,
       options: {
@@ -17295,10 +17386,10 @@ async function run17(args) {
     });
   } catch (parseError) {
     const message = parseError instanceof Error ? parseError.message : String(parseError);
-    return fail("USAGE", message, HELP17);
+    return fail("USAGE", message, HELP16);
   }
   if (parsed.values.help) {
-    await writeStdout(HELP17);
+    await writeStdout(HELP16);
     return EXIT.OK;
   }
   if (parsed.values.json) {
@@ -17309,7 +17400,7 @@ async function run17(args) {
   await writeStdout(REFERENCE);
   return EXIT.OK;
 }
-var HELP17 = `docx locators \u2014 print the locator grammar reference
+var HELP16 = `docx locators \u2014 print the locator grammar reference
 
 Usage:
   docx locators [options]
@@ -17389,12 +17480,12 @@ var init_locators2 = __esm(() => {
 // src/cli/info/index.ts
 var exports_info = {};
 __export(exports_info, {
-  run: () => run18
+  run: () => run17
 });
-async function run18(args) {
+async function run17(args) {
   const topic = args[0];
   if (!topic || topic === "--help" || topic === "-h" || topic === "help") {
-    await writeStdout(HELP18);
+    await writeStdout(HELP17);
     return topic ? 0 : 2;
   }
   const loader = SUBCOMMANDS3[topic];
@@ -17404,7 +17495,7 @@ async function run18(args) {
   const module_ = await loader();
   return module_.run(args.slice(1));
 }
-var SUBCOMMANDS3, HELP18 = `docx info \u2014 print reference material about the CLI
+var SUBCOMMANDS3, HELP17 = `docx info \u2014 print reference material about the CLI
 
 Usage:
   docx info <topic> [options]
@@ -17426,13 +17517,13 @@ var init_info = __esm(() => {
 // src/cli/insert/index.tsx
 var exports_insert = {};
 __export(exports_insert, {
-  run: () => run19
+  run: () => run18
 });
-import { parseArgs as parseArgs16 } from "util";
-async function run19(args) {
+import { parseArgs as parseArgs15 } from "util";
+async function run18(args) {
   let parsed;
   try {
-    parsed = parseArgs16({
+    parsed = parseArgs15({
       args,
       allowPositionals: true,
       options: {
@@ -17445,36 +17536,37 @@ async function run19(args) {
         color: { type: "string" },
         bold: { type: "boolean" },
         italic: { 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, HELP19);
+    return fail("USAGE", message, HELP18);
   }
   if (parsed.values.help) {
-    await writeStdout(HELP19);
+    await writeStdout(HELP18);
     return EXIT.OK;
   }
   const path = parsed.positionals[0];
   if (!path)
-    return fail("USAGE", "Missing FILE argument", HELP19);
+    return fail("USAGE", "Missing FILE argument", HELP18);
   const after = parsed.values.after;
   const before = parsed.values.before;
   if (!after && !before) {
-    return fail("USAGE", "Missing locator: pass --after or --before", HELP19);
+    return fail("USAGE", "Missing locator: pass --after or --before", HELP18);
   }
   if (after && before) {
-    return fail("USAGE", "Pass either --after or --before, not both", HELP19);
+    return fail("USAGE", "Pass either --after or --before, not both", HELP18);
   }
   const text = parsed.values.text;
   const runsJson = parsed.values.runs;
   if (!text && !runsJson) {
-    return fail("USAGE", "Missing content: pass --text or --runs", HELP19);
+    return fail("USAGE", "Missing content: pass --text or --runs", HELP18);
   }
   if (text && runsJson) {
-    return fail("USAGE", "Pass either --text or --runs, not both", HELP19);
+    return fail("USAGE", "Pass either --text or --runs, not both", HELP18);
   }
   const paragraphOptions = {};
   const styleValue = parsed.values.style;
@@ -17525,6 +17617,10 @@ async function run19(args) {
     return fail("BLOCK_NOT_FOUND", "Block reference is stale (parent does not contain it)");
   }
   const insertIndex = after !== undefined ? targetIndex + 1 : targetIndex;
+  if (isTrackChangesEnabled(view)) {
+    applyTrackedInsertion(paragraphNode, view);
+  }
+  const outputPath = parsed.values.output;
   if (parsed.values["dry-run"]) {
     await respond({
       ok: true,
@@ -17532,22 +17628,53 @@ async function run19(args) {
       dryRun: true,
       path,
       locator: targetLocator,
-      placement: after !== undefined ? "after" : "before"
+      placement: after !== undefined ? "after" : "before",
+      ...outputPath ? { output: outputPath } : {}
     });
     return EXIT.OK;
   }
   blockRef.parent.splice(insertIndex, 0, paragraphNode);
-  await saveDocView(view);
+  await saveDocView(view, outputPath);
   await respond({
     ok: true,
     operation: "insert",
-    path,
+    path: outputPath ?? path,
     locator: targetLocator,
     placement: after !== undefined ? "after" : "before"
   });
   return EXIT.OK;
 }
-var HELP19 = `docx insert \u2014 insert a paragraph at a locator
+function applyTrackedInsertion(paragraph, view) {
+  const allocator = createRevisionAllocator(view);
+  const baseMeta = { author: resolveAuthor(), date: resolveDate() };
+  const mintMeta = () => ({
+    ...baseMeta,
+    revisionId: allocator.next()
+  });
+  const newChildren = [];
+  let runBuffer = [];
+  const flush = () => {
+    if (runBuffer.length === 0)
+      return;
+    newChildren.push(/* @__PURE__ */ jsxDEV(Ins, {
+      meta: mintMeta(),
+      children: runBuffer
+    }, undefined, false, undefined, this));
+    runBuffer = [];
+  };
+  for (const child of paragraph.children) {
+    if (child.tag === "w:r") {
+      runBuffer.push(child);
+      continue;
+    }
+    flush();
+    newChildren.push(child);
+  }
+  flush();
+  paragraph.children = newChildren;
+  markParagraphMarkAs(paragraph, "ins", mintMeta());
+}
+var HELP18 = `docx insert \u2014 insert a paragraph at a locator
 
 Usage:
   docx insert FILE [options]
@@ -17569,6 +17696,7 @@ Run options (only with --text):
   --bold            Bold
   --italic          Italic
 
+  -o, --output PATH Write to PATH instead of overwriting FILE
   --dry-run         Print what would be inserted; do not write the file
   -h, --help        Show this help
 
@@ -17580,10 +17708,145 @@ Examples:
 var init_insert = __esm(() => {
   init_core();
   init_respond();
-  init_emit();
+  init_emit2();
   init_jsx_dev_runtime();
 });
 
+// src/cli/outline/build.ts
+function buildOutline(doc, options = {}) {
+  const stylePrefix = options.stylePrefix ?? "Heading";
+  const root = {
+    id: "",
+    locator: "",
+    level: 0,
+    style: "",
+    text: "",
+    children: []
+  };
+  const stack = [root];
+  for (const paragraph of headingParagraphs(doc.blocks, stylePrefix)) {
+    const level = headingLevel(paragraph.style, stylePrefix);
+    if (level === null)
+      continue;
+    while ((stack[stack.length - 1]?.level ?? 0) >= level)
+      stack.pop();
+    const parent = stack[stack.length - 1] ?? root;
+    const entry = {
+      id: paragraph.id,
+      locator: paragraph.id,
+      level,
+      style: paragraph.style ?? "",
+      text: paragraphText(paragraph),
+      children: []
+    };
+    parent.children.push(entry);
+    stack.push(entry);
+  }
+  return root.children;
+}
+function headingLevel(style, stylePrefix) {
+  if (!style)
+    return null;
+  if (!style.startsWith(stylePrefix))
+    return null;
+  const remainder = style.slice(stylePrefix.length).trim();
+  if (remainder === "")
+    return 1;
+  const parsed = Number(remainder);
+  if (!Number.isInteger(parsed) || parsed < 1)
+    return null;
+  return parsed;
+}
+function* headingParagraphs(blocks, stylePrefix) {
+  for (const block of blocks) {
+    if (block.type !== "paragraph")
+      continue;
+    if (headingLevel(block.style, stylePrefix) === null)
+      continue;
+    yield block;
+  }
+}
+function paragraphText(paragraph) {
+  let out = "";
+  for (const run19 of paragraph.runs) {
+    if (run19.type === "text")
+      out += run19.text;
+  }
+  return out;
+}
+
+// src/cli/outline/index.ts
+var exports_outline = {};
+__export(exports_outline, {
+  run: () => run19
+});
+import { parseArgs as parseArgs16 } from "util";
+async function run19(args) {
+  let parsed;
+  try {
+    parsed = parseArgs16({
+      args,
+      allowPositionals: true,
+      options: {
+        "style-prefix": { type: "string" },
+        help: { type: "boolean", short: "h" }
+      }
+    });
+  } catch (parseError) {
+    const message = parseError instanceof Error ? parseError.message : String(parseError);
+    return fail("USAGE", message, HELP19);
+  }
+  if (parsed.values.help) {
+    await writeStdout(HELP19);
+    return EXIT.OK;
+  }
+  const path = parsed.positionals[0];
+  if (!path)
+    return fail("USAGE", "Missing FILE argument", HELP19);
+  const stylePrefix = parsed.values["style-prefix"] ?? "Heading";
+  if (stylePrefix.length === 0) {
+    return fail("USAGE", "--style-prefix cannot be empty");
+  }
+  const view = await openOrFail(path);
+  if (typeof view === "number")
+    return view;
+  const outline = buildOutline(view.doc, { stylePrefix });
+  await respond({
+    ok: true,
+    operation: "outline",
+    path,
+    stylePrefix,
+    outline
+  });
+  return EXIT.OK;
+}
+var HELP19 = `docx outline \u2014 list headings as a hierarchical tree
+
+Usage:
+  docx outline FILE [options]
+
+Options:
+  --style-prefix S  paragraph-style prefix that marks a heading (default: "Heading")
+  -h, --help        show this help
+
+Walks top-level paragraphs whose style starts with the prefix and parses the
+trailing number as the heading level (e.g. "Heading1" \u2192 1, "Heading 2" \u2192 2).
+Paragraphs nested inside table cells are skipped \u2014 outlines reflect the
+document's structural skeleton, not embedded labels. Lower levels nest under
+higher ones; missing intermediate levels nest directly (H1 \u2192 H3 is fine).
+
+Output is JSON: an array of entries, each shaped like
+  { id, locator, level, style, text, children }.
+
+Examples:
+  docx outline doc.docx
+  docx outline doc.docx --style-prefix "Section"
+  docx outline doc.docx | jq '.outline[].text'
+`;
+var init_outline = __esm(() => {
+  init_respond();
+});
+
 // src/cli/read/index.ts
 var exports_read = {};
 __export(exports_read, {
@@ -17637,7 +17900,7 @@ var init_read2 = __esm(() => {
 });
 
 // src/cli/replace/replace-span.tsx
-function replaceSpanInParagraph(paragraph, span, replacement) {
+function replaceSpanInParagraph(paragraph, span, replacement, tracked) {
   if (span.start > span.end) {
     throw new Error(`replaceSpanInParagraph: invalid span ${span.start}-${span.end}`);
   }
@@ -17645,17 +17908,21 @@ function replaceSpanInParagraph(paragraph, span, replacement) {
   const overlapping = slots.filter((slot) => slot.offsetBefore + slot.length > span.start && slot.offsetBefore < span.end);
   const firstSlot = overlapping[0];
   if (!firstSlot) {
-    paragraph.children.push(replacementRun(null, replacement));
+    paragraph.children.push(/* @__PURE__ */ jsxDEV(ReplacementRun, {
+      runProperties: null,
+      text: replacement
+    }, undefined, false, undefined, this));
     return;
   }
+  const inheritedProperties = firstSlot.run.findChild("w:rPr")?.clone() ?? null;
   const firstParent = firstSlot.parent;
-  if (overlapping.some((slot) => slot.parent !== firstParent)) {
-    throw new TrackedChangeBoundaryError("Span crosses a tracked-change (<w:ins>/<w:del>) boundary; accept or reject the tracked change first.");
+  const allSameParent = overlapping.every((slot) => slot.parent === firstParent);
+  if (allSameParent) {
+    const containerStart = firstParent === paragraph ? 0 : firstSlot.offsetBefore;
+    rebuildContainer(firstParent, containerStart, span, replacement, inheritedProperties, firstParent === paragraph, tracked ?? null);
+    return;
   }
-  const firstRunProperties = firstSlot.run.findChild("w:rPr");
-  const inheritedProperties = firstRunProperties ? deepCloneNode(firstRunProperties) : null;
-  const containerStart = firstParent === paragraph ? 0 : firstSlot.offsetBefore;
-  rebuildContainer(firstParent, containerStart, span, replacement, inheritedProperties, firstParent === paragraph);
+  rebuildAcrossBoundaries(paragraph, span, replacement, inheritedProperties, tracked ?? null);
 }
 function collectRunSlots(paragraph) {
   const slots = [];
@@ -17689,10 +17956,23 @@ function collectRunSlots(paragraph) {
   }
   return slots;
 }
-function rebuildContainer(container, baseOffset, span, replacement, runProperties, isParagraph) {
+function rebuildContainer(container, baseOffset, span, replacement, runProperties, isParagraph, tracked) {
   const newChildren = [];
   let offset = baseOffset;
-  let placedReplacement = false;
+  let placed = false;
+  const placeReplacement = () => {
+    if (placed)
+      return;
+    placed = true;
+    const run21 = /* @__PURE__ */ jsxDEV(ReplacementRun, {
+      runProperties,
+      text: replacement
+    }, undefined, false, undefined, this);
+    newChildren.push(tracked && isParagraph ? /* @__PURE__ */ jsxDEV(Ins, {
+      meta: mintMeta(tracked),
+      children: run21
+    }, undefined, false, undefined, this) : run21);
+  };
   for (const child of container.children) {
     if (child.tag === "w:r") {
       const length = runTextLength(child);
@@ -17704,10 +17984,7 @@ function rebuildContainer(container, baseOffset, span, replacement, runPropertie
         continue;
       }
       if (runStart >= span.end) {
-        if (!placedReplacement) {
-          newChildren.push(replacementRun(runProperties, replacement));
-          placedReplacement = true;
-        }
+        placeReplacement();
         newChildren.push(child);
         continue;
       }
@@ -17716,10 +17993,15 @@ function rebuildContainer(container, baseOffset, span, replacement, runPropertie
       if (sliceStartInRun > 0) {
         newChildren.push(sliceRun(child, 0, sliceStartInRun));
       }
-      if (!placedReplacement) {
-        newChildren.push(replacementRun(runProperties, replacement));
-        placedReplacement = true;
+      if (tracked) {
+        const cutRun = sliceRun(child, sliceStartInRun, sliceEndInRun);
+        convertRunTextToDelText(cutRun);
+        newChildren.push(/* @__PURE__ */ jsxDEV(Del, {
+          meta: mintMeta(tracked),
+          children: cutRun
+        }, undefined, false, undefined, this));
       }
+      placeReplacement();
       if (sliceEndInRun < length) {
         newChildren.push(sliceRun(child, sliceEndInRun, length));
       }
@@ -17737,23 +18019,159 @@ function rebuildContainer(container, baseOffset, span, replacement, runPropertie
     }
     newChildren.push(child);
   }
-  if (!placedReplacement) {
-    newChildren.push(replacementRun(runProperties, replacement));
-  }
+  if (!placed)
+    placeReplacement();
   container.children = newChildren;
 }
-function replacementRun(runProperties, text) {
-  if (text.length === 0) {
-    return /* @__PURE__ */ jsxDEV(w.r, {
-      children: [
-        runProperties,
-        /* @__PURE__ */ jsxDEV(w.t, {
-          "xml:space": "preserve",
-          children: ""
-        }, undefined, false, undefined, this)
-      ]
-    }, undefined, true, undefined, this);
+function rebuildAcrossBoundaries(paragraph, span, replacement, runProperties, tracked) {
+  const newChildren = [];
+  let offset = 0;
+  let placed = false;
+  const placeReplacement = () => {
+    if (placed)
+      return;
+    placed = true;
+    const run21 = /* @__PURE__ */ jsxDEV(ReplacementRun, {
+      runProperties,
+      text: replacement
+    }, undefined, false, undefined, this);
+    newChildren.push(tracked ? /* @__PURE__ */ jsxDEV(Ins, {
+      meta: mintMeta(tracked),
+      children: run21
+    }, undefined, false, undefined, this) : run21);
+  };
+  for (const child of paragraph.children) {
+    if (child.tag === "w:r") {
+      const length = runTextLength(child);
+      const runStart = offset;
+      const runEnd = offset + length;
+      offset = runEnd;
+      if (runEnd <= span.start) {
+        newChildren.push(child);
+        continue;
+      }
+      if (runStart >= span.end) {
+        placeReplacement();
+        newChildren.push(child);
+        continue;
+      }
+      const sliceStartInRun = Math.max(0, span.start - runStart);
+      const sliceEndInRun = Math.min(length, span.end - runStart);
+      if (sliceStartInRun > 0) {
+        newChildren.push(sliceRun(child, 0, sliceStartInRun));
+      }
+      if (tracked) {
+        const cutRun = sliceRun(child, sliceStartInRun, sliceEndInRun);
+        convertRunTextToDelText(cutRun);
+        newChildren.push(/* @__PURE__ */ jsxDEV(Del, {
+          meta: mintMeta(tracked),
+          children: cutRun
+        }, undefined, false, undefined, this));
+      }
+      placeReplacement();
+      if (sliceEndInRun < length) {
+        newChildren.push(sliceRun(child, sliceEndInRun, length));
+      }
+      continue;
+    }
+    if (child.tag === "w:ins" || child.tag === "w:del") {
+      const innerLength = sumInnerRunLengths(child);
+      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;
+      }
+      splitWrapperAcrossSpan(child, wrapperStart, span, tracked, newChildren, placeReplacement);
+      continue;
+    }
+    newChildren.push(child);
+  }
+  if (!placed)
+    placeReplacement();
+  paragraph.children = newChildren;
+}
+function splitWrapperAcrossSpan(wrapper, wrapperStart, span, tracked, out, placeReplacement) {
+  const isDel = wrapper.tag === "w:del";
+  const preInner = [];
+  const cutInner = [];
+  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));
+    cutInner.push(sliceRun(inner, sliceStartInRun, sliceEndInRun));
+    if (sliceEndInRun < length)
+      postInner.push(sliceRun(inner, sliceEndInRun, length));
+  }
+  const preChildren = preInner.slice();
+  if (isDel) {
+    preChildren.push(...cutInner);
+  } else if (tracked && cutInner.length > 0) {
+    for (const cutRun of cutInner)
+      convertRunTextToDelText(cutRun);
+    preChildren.push(/* @__PURE__ */ jsxDEV(Del, {
+      meta: mintMeta(tracked),
+      children: cutInner
+    }, undefined, false, undefined, this));
+  }
+  if (preChildren.length > 0) {
+    const preWrapper = new XmlNode2(wrapper.tag, { ...wrapper.attributes });
+    preWrapper.children = preChildren;
+    out.push(preWrapper);
+  }
+  placeReplacement();
+  if (postInner.length > 0) {
+    const postWrapper = new XmlNode2(wrapper.tag, { ...wrapper.attributes });
+    postWrapper.children = postInner;
+    out.push(postWrapper);
+  }
+}
+function sumInnerRunLengths(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() };
+}
+function convertRunTextToDelText(run21) {
+  for (const child of run21.children) {
+    if (child.tag === "w:t")
+      child.tag = "w:delText";
   }
+}
+function ReplacementRun({
+  runProperties,
+  text
+}) {
   return /* @__PURE__ */ jsxDEV(w.r, {
     children: [
       runProperties,
@@ -17764,17 +18182,11 @@ function replacementRun(runProperties, text) {
     ]
   }, undefined, true, undefined, this);
 }
-var TrackedChangeBoundaryError;
 var init_replace_span = __esm(() => {
+  init_core();
   init_jsx();
   init_parser();
   init_jsx_dev_runtime();
-  TrackedChangeBoundaryError = class TrackedChangeBoundaryError extends Error {
-    constructor(message) {
-      super(message);
-      this.name = "TrackedChangeBoundaryError";
-    }
-  };
 });
 
 // src/cli/replace/index.ts
@@ -17794,6 +18206,7 @@ async function run21(args) {
         "ignore-case": { type: "boolean" },
         all: { type: "boolean" },
         limit: { type: "string" },
+        output: { type: "string", short: "o" },
         "dry-run": { type: "boolean" },
         help: { type: "boolean", short: "h" }
       }
@@ -17852,6 +18265,7 @@ async function run21(args) {
     end: match.end,
     text: match.text
   }));
+  const outputPath = parsed.values.output;
   if (parsed.values["dry-run"]) {
     await respond({
       ok: true,
@@ -17864,7 +18278,8 @@ async function run21(args) {
       ignoreCase,
       totalMatches: allMatches.length,
       replaced: selected.length,
-      matches: matchesPayload
+      matches: matchesPayload,
+      ...outputPath ? { output: outputPath } : {}
     });
     return EXIT.OK;
   }
@@ -17889,24 +18304,21 @@ async function run21(args) {
     }
     return rightMatch.start - leftMatch.start;
   });
+  const tracked = isTrackChangesEnabled(view) ? {
+    meta: { author: resolveAuthor(), date: resolveDate() },
+    allocator: createRevisionAllocator(view)
+  } : undefined;
   const regexFlags = ignoreCase ? "i" : "";
-  try {
-    for (const match of reversed) {
-      const concreteReplacement = useRegex ? match.text.replace(new RegExp(pattern, regexFlags), replacement) : replacement;
-      const blockRef = resolveBlock(view, match.blockId);
-      replaceSpanInParagraph(blockRef.node, { start: match.start, end: match.end }, concreteReplacement);
-    }
-  } catch (error) {
-    if (error instanceof TrackedChangeBoundaryError) {
-      return fail("TRACKED_CHANGE_CONFLICT", error.message, "Use `docx track-changes off` (or accept/reject the change in Word) before replacing.");
-    }
-    throw error;
+  for (const match of reversed) {
+    const concreteReplacement = useRegex ? match.text.replace(new RegExp(pattern, regexFlags), replacement) : replacement;
+    const blockRef = resolveBlock(view, match.blockId);
+    replaceSpanInParagraph(blockRef.node, { start: match.start, end: match.end }, concreteReplacement, tracked);
   }
-  await saveDocView(view);
+  await saveDocView(view, outputPath);
   await respond({
     ok: true,
     operation: "replace",
-    path,
+    path: outputPath ?? path,
     pattern,
     replacement,
     regex: useRegex,
@@ -17927,6 +18339,7 @@ Options:
   --ignore-case     case-insensitive match
   --all             replace every match (default: just the first)
   --limit N         replace at most N matches (in document order)
+  -o, --output PATH write to PATH instead of overwriting FILE
   --dry-run         report what would change without writing the file
   -h, --help        show this help
 
@@ -17969,6 +18382,7 @@ async function run22(args) {
       args,
       allowPositionals: true,
       options: {
+        output: { type: "string", short: "o" },
         "dry-run": { type: "boolean" },
         help: { type: "boolean", short: "h" }
       }
@@ -18002,6 +18416,7 @@ async function run22(args) {
     view.settingsTree.push(settingsRoot);
   }
   const hasTrackChanges = settingsRoot.children.some((child) => child.tag === "w:trackChanges");
+  const outputPath = parsed.values.output;
   if (parsed.values["dry-run"]) {
     await respond({
       ok: true,
@@ -18009,7 +18424,8 @@ async function run22(args) {
       dryRun: true,
       path,
       mode,
-      previouslyOn: hasTrackChanges
+      previouslyOn: hasTrackChanges,
+      ...outputPath ? { output: outputPath } : {}
     });
     return EXIT.OK;
   }
@@ -18026,11 +18442,11 @@ async function run22(args) {
       target: "settings.xml"
     });
   }
-  await saveDocView(view);
+  await saveDocView(view, outputPath);
   await respond({
     ok: true,
     operation: "track-changes",
-    path,
+    path: outputPath ?? path,
     mode,
     previouslyOn: hasTrackChanges
   });
@@ -18041,10 +18457,13 @@ var HELP22 = `docx track-changes \u2014 toggle the document's tracked-changes mo
 Usage:
   docx track-changes FILE on|off [options]
 
-Sets <w:trackChanges/> in word/settings.xml. When on, Word records new
-edits as tracked changes. Existing <w:ins>/<w:del> markers are unaffected.
+Sets <w:trackChanges/> in word/settings.xml. When on, this CLI's
+insert/edit/delete/replace commands also emit <w:ins>/<w:del> markers
+(attributed to $DOCX_AUTHOR) so changes remain reviewable. Existing
+<w:ins>/<w:del> markers are unaffected by the toggle itself.
 
 Options:
+  -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
 
@@ -18052,7 +18471,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_changes = __esm(() => {
+var init_track_changes2 = __esm(() => {
   init_core();
   init_jsx();
   init_package();
@@ -18060,10 +18479,297 @@ var init_track_changes = __esm(() => {
   init_respond();
   init_jsx_dev_runtime();
 });
+
+// src/cli/wc/count.ts
+function countWords(text) {
+  const matches = text.match(/\S+/g);
+  return matches?.length ?? 0;
+}
+function paragraphText2(paragraph) {
+  let out = "";
+  for (const run23 of paragraph.runs) {
+    if (run23.type === "text")
+      out += run23.text;
+  }
+  return out;
+}
+function countWordsInBlocks(blocks) {
+  let total = 0;
+  for (const block of blocks) {
+    if (block.type === "paragraph") {
+      total += countWords(paragraphText2(block));
+    } else if (block.type === "table") {
+      for (const row of block.rows) {
+        for (const cell of row.cells) {
+          total += countWordsInBlocks(cell.blocks);
+        }
+      }
+    }
+  }
+  return total;
+}
+function findBlockById(blocks, blockId) {
+  for (const block of blocks) {
+    if (block.id === blockId)
+      return block;
+    if (block.type === "table") {
+      for (const row of block.rows) {
+        for (const cell of row.cells) {
+          const inner = findBlockById(cell.blocks, blockId);
+          if (inner)
+            return inner;
+        }
+      }
+    }
+  }
+  return null;
+}
+function countWordsInParagraphSpan(paragraph, start, end) {
+  const text = paragraphText2(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) {
+  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;
+  if (startIndex === endIndex) {
+    const paragraph = paragraphsInOrder[startIndex];
+    if (!paragraph)
+      return 0;
+    return countWordsInParagraphSpan(paragraph, startOffset, endOffset);
+  }
+  let total = 0;
+  const first = paragraphsInOrder[startIndex];
+  if (first) {
+    total += countWordsInParagraphSpan(first, startOffset, paragraphText2(first).length);
+  }
+  for (let index = startIndex + 1;index < endIndex; index++) {
+    const middle = paragraphsInOrder[index];
+    if (middle)
+      total += countWords(paragraphText2(middle));
+  }
+  const last = paragraphsInOrder[endIndex];
+  if (last)
+    total += countWordsInParagraphSpan(last, 0, endOffset);
+  return total;
+}
+function flattenParagraphs(blocks) {
+  const out = [];
+  for (const block of blocks) {
+    if (block.type === "paragraph") {
+      out.push(block);
+      continue;
+    }
+    if (block.type === "table") {
+      for (const row of block.rows) {
+        for (const cell of row.cells) {
+          out.push(...flattenParagraphs(cell.blocks));
+        }
+      }
+    }
+  }
+  return out;
+}
+
+// src/cli/wc/index.ts
+var exports_wc = {};
+__export(exports_wc, {
+  run: () => run23
+});
+import { parseArgs as parseArgs20 } from "util";
+async function run23(args) {
+  let parsed;
+  try {
+    parsed = parseArgs20({
+      args,
+      allowPositionals: true,
+      options: {
+        help: { type: "boolean", short: "h" }
+      }
+    });
+  } catch (parseError) {
+    const message = parseError instanceof Error ? parseError.message : String(parseError);
+    return fail("USAGE", message, HELP23);
+  }
+  if (parsed.values.help) {
+    await writeStdout(HELP23);
+    return EXIT.OK;
+  }
+  const path = parsed.positionals[0];
+  const locatorInput = parsed.positionals[1];
+  if (!path)
+    return fail("USAGE", "Missing FILE argument", HELP23);
+  const view = await openOrFail(path);
+  if (typeof view === "number")
+    return view;
+  if (!locatorInput) {
+    await respond({
+      ok: true,
+      operation: "wc",
+      path,
+      scope: "document",
+      words: countWordsInBlocks(view.doc.blocks)
+    });
+    return EXIT.OK;
+  }
+  let locator;
+  try {
+    locator = parseLocator(locatorInput);
+  } catch (error) {
+    if (error instanceof LocatorParseError) {
+      return fail("INVALID_LOCATOR", error.message);
+    }
+    throw error;
+  }
+  if (locator.kind === "comment" || locator.kind === "image") {
+    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;
+  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(paragraphText2(block)) : block.type === "table" ? countWordsInBlocks([block]) : 0;
+    await respond({
+      ok: true,
+      operation: "wc",
+      path,
+      locator: locatorInput,
+      scope: block.type,
+      words
+    });
+    return EXIT.OK;
+  }
+  if (locator.kind === "blockSpan") {
+    const block = findBlockById(blocks, locator.blockId);
+    if (!block || block.type !== "paragraph") {
+      return fail("BLOCK_NOT_FOUND", `Paragraph not found: ${locator.blockId}`);
+    }
+    await respond({
+      ok: true,
+      operation: "wc",
+      path,
+      locator: locatorInput,
+      scope: "paragraphSpan",
+      words: countWordsInParagraphSpan(block, locator.start, locator.end)
+    });
+    return EXIT.OK;
+  }
+  if (locator.kind === "range") {
+    const paragraphs = flattenParagraphs(blocks);
+    const startExists = paragraphs.some((p) => p.id === locator.start.blockId);
+    const endExists = paragraphs.some((p) => p.id === locator.end.blockId);
+    if (!startExists) {
+      return fail("BLOCK_NOT_FOUND", `Paragraph not found: ${locator.start.blockId}`);
+    }
+    if (!endExists) {
+      return fail("BLOCK_NOT_FOUND", `Paragraph not found: ${locator.end.blockId}`);
+    }
+    await respond({
+      ok: true,
+      operation: "wc",
+      path,
+      locator: locatorInput,
+      scope: "range",
+      words: countWordsInRange(paragraphs, locator.start.blockId, locator.start.offset, locator.end.blockId, locator.end.offset)
+    });
+    return EXIT.OK;
+  }
+  if (locator.kind === "cell") {
+    const cellPath = `${locator.tableId}:r${locator.row}c${locator.col}`;
+    if (!locator.inner) {
+      const cellBlocks = findCellBlocks(blocks, locator);
+      if (!cellBlocks) {
+        return fail("BLOCK_NOT_FOUND", `Cell not found: ${cellPath}`);
+      }
+      await respond({
+        ok: true,
+        operation: "wc",
+        path,
+        locator: locatorInput,
+        scope: "cell",
+        words: countWordsInBlocks(cellBlocks)
+      });
+      return EXIT.OK;
+    }
+    const innerBlockId = locator.inner.kind === "block" ? locator.inner.blockId : locator.inner.kind === "blockSpan" ? locator.inner.blockId : null;
+    if (!innerBlockId) {
+      return fail("USAGE", `Unsupported inner locator for cell: ${locatorInput}`, "Inside a cell, wc accepts pK or pK:S-E only.");
+    }
+    const composedId = `${cellPath}:${innerBlockId}`;
+    const block = findBlockById(blocks, composedId);
+    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(paragraphText2(block));
+    await respond({
+      ok: true,
+      operation: "wc",
+      path,
+      locator: locatorInput,
+      scope: locator.inner.kind === "blockSpan" ? "paragraphSpan" : "paragraph",
+      words
+    });
+    return EXIT.OK;
+  }
+  return fail("USAGE", `Unsupported locator: ${locatorInput}`);
+}
+function findCellBlocks(blocks, locator) {
+  const block = findBlockById(blocks, locator.tableId);
+  if (!block || block.type !== "table")
+    return null;
+  const row = block.rows[locator.row];
+  if (!row)
+    return null;
+  const cell = row.cells[locator.col];
+  if (!cell)
+    return null;
+  return cell.blocks;
+}
+var HELP23 = `docx wc \u2014 count words in a document or a locator-addressed slice
+
+Usage:
+  docx wc FILE [LOCATOR] [options]
+
+Locators (optional; default: whole document):
+  pN              whole paragraph N
+  pN:S-E          chars S..E within paragraph N
+  pN:S-pM:E       cross-paragraph range
+  tN              whole table
+  tN:rRcC         whole cell
+  tN:rRcC:pK      paragraph K inside that cell
+  tN:rRcC:pK:S-E  span within a cell paragraph
+
+Options:
+  -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.
+
+Examples:
+  docx wc doc.docx
+  docx wc doc.docx p3
+  docx wc doc.docx p3:0-120
+  docx wc doc.docx p5:10-p9:42
+  docx wc doc.docx t0:r1c0
+`;
+var init_wc = __esm(() => {
+  init_core();
+  init_respond();
+});
 // package.json
 var package_default = {
   name: "bun-docx",
-  version: "0.2.0",
+  version: "0.4.0",
   description: "CLI for AI agents (Claude, Codex) to read, edit, and comment on .docx files with full format fidelity.",
   keywords: [
     "docx",
@@ -18138,7 +18844,9 @@ Commands:
   delete    FILE  Remove a block or run range
   find      FILE QUERY  Find text spans, return locators
   replace   FILE PATTERN REPL  Substitute text spans (sed for docx)
-  comments  \u2026     Add, reply, resolve, delete, restore, list comments
+  wc        FILE [LOCATOR]  Count words in the doc or a slice
+  outline   FILE  List headings as a hierarchical tree
+  comments  \u2026     Add, reply, resolve, delete, list comments
   images    \u2026     Extract, replace, list images
   track-changes FILE on|off  Toggle tracked-changes mode
   info      \u2026     Reference material (schema, locators)
@@ -18146,7 +18854,13 @@ Commands:
 Run "docx <command> --help" for command-specific help.
 
 Environment:
-  DOCX_AUTHOR  Default --author for "comments add" / "comments reply"
+  DOCX_AUTHOR    Default author for comments and tracked-change attribution
+  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.
 `;
 async function printTopHelp() {
   await writeStdout(TOP_HELP);
@@ -18163,9 +18877,11 @@ var COMMANDS = {
   images: () => Promise.resolve().then(() => (init_images(), exports_images)),
   info: () => Promise.resolve().then(() => (init_info(), exports_info)),
   insert: () => Promise.resolve().then(() => (init_insert(), exports_insert)),
+  outline: () => Promise.resolve().then(() => (init_outline(), exports_outline)),
   read: () => Promise.resolve().then(() => (init_read2(), exports_read)),
   replace: () => Promise.resolve().then(() => (init_replace2(), exports_replace2)),
-  "track-changes": () => Promise.resolve().then(() => (init_track_changes(), exports_track_changes))
+  "track-changes": () => Promise.resolve().then(() => (init_track_changes2(), exports_track_changes)),
+  wc: () => Promise.resolve().then(() => (init_wc(), exports_wc))
 };
 async function main(argv) {
   const args = argv.slice(2);