bun-docx 0.7.0 → 0.8.0

package/dist/index.js

@@ -13576,10 +13576,11 @@ function isSubtractiveTrackedChangeWrapper(tag) {
 function runTextLength(run) {
   let total = 0;
   for (const child of run.children) {
-    if (child.tag === "w:t")
+    if (child.tag === "w:t" || child.tag === "w:delText") {
       total += child.collectText().length;
-    else if (SINGLE_CHAR_TAGS.has(child.tag))
+    } else if (SINGLE_CHAR_TAGS.has(child.tag)) {
       total += 1;
+    }
   }
   return total;
 }
@@ -13805,6 +13806,322 @@ var init_package = __esm(() => {
   };
 });
 
+// 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) {
+    result[tagName] = makeTag(`${prefix}:${tagName}`);
+  }
+  return result;
+}
+function makeTag(qualifiedName) {
+  return (props) => {
+    const attributes = {};
+    let childrenProp;
+    if (props) {
+      for (const [key, value] of Object.entries(props)) {
+        if (key === "children") {
+          childrenProp = value;
+          continue;
+        }
+        if (value === false || value == null)
+          continue;
+        attributes[mapAttributeName(key)] = String(value);
+      }
+    }
+    const childNodes = [];
+    flatten(normalizeChildren(childrenProp), childNodes);
+    return new XmlNode2(qualifiedName, attributes, childNodes);
+  };
+}
+function flatten(items, out) {
+  for (const item of items) {
+    if (item == null || item === false)
+      continue;
+    if (Array.isArray(item)) {
+      flatten(item, out);
+      continue;
+    }
+    if (item instanceof XmlNode2) {
+      if (item.tag === FRAGMENT_TAG) {
+        for (const child of item.children)
+          out.push(child);
+        continue;
+      }
+      out.push(item);
+      continue;
+    }
+    if (typeof item === "string" || typeof item === "number") {
+      out.push(XmlNode2.textNode(String(item)));
+    }
+  }
+}
+function mapAttributeName(name) {
+  const dashIndex = name.indexOf("-");
+  if (dashIndex === -1)
+    return name;
+  return `${name.slice(0, dashIndex)}:${name.slice(dashIndex + 1)}`;
+}
+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 = [
+    "document",
+    "body",
+    "p",
+    "pPr",
+    "pStyle",
+    "jc",
+    "numPr",
+    "ilvl",
+    "numId",
+    "r",
+    "rPr",
+    "rStyle",
+    "t",
+    "b",
+    "i",
+    "u",
+    "strike",
+    "color",
+    "highlight",
+    "sz",
+    "rFonts",
+    "br",
+    "tab",
+    "drawing",
+    "sectPr",
+    "sectPrChange",
+    "cols",
+    "type",
+    "tbl",
+    "tblPr",
+    "tblGrid",
+    "gridCol",
+    "tr",
+    "tc",
+    "tcPr",
+    "ins",
+    "del",
+    "delText",
+    "commentRangeStart",
+    "commentRangeEnd",
+    "commentReference",
+    "comments",
+    "comment",
+    "settings",
+    "trackChanges",
+    "hyperlink"
+  ];
+  R_TAGS = ["embed", "link", "id"];
+  A_TAGS = [
+    "graphic",
+    "graphicData",
+    "blip",
+    "xfrm",
+    "off",
+    "ext",
+    "prstGeom",
+    "avLst"
+  ];
+  WP_TAGS = [
+    "inline",
+    "anchor",
+    "extent",
+    "effectExtent",
+    "docPr",
+    "cNvGraphicFramePr"
+  ];
+  PIC_TAGS = [
+    "pic",
+    "nvPicPr",
+    "cNvPr",
+    "cNvPicPr",
+    "blipFill",
+    "spPr"
+  ];
+  CP_TAGS = ["coreProperties", "lastModifiedBy"];
+  DC_TAGS = ["title", "creator", "subject", "description"];
+  DCTERMS_TAGS = ["created", "modified"];
+  W14_TAGS = ["paraId", "textId"];
+  W15_TAGS = ["commentsEx", "commentEx"];
+  w = namespace("w", W_TAGS);
+  r = namespace("r", R_TAGS);
+  a = namespace("a", A_TAGS);
+  wp = namespace("wp", WP_TAGS);
+  pic = namespace("pic", PIC_TAGS);
+  cp = namespace("cp", CP_TAGS);
+  dc = namespace("dc", DC_TAGS);
+  dcterms = namespace("dcterms", DCTERMS_TAGS);
+  w14 = namespace("w14", W14_TAGS);
+  w15 = namespace("w15", W15_TAGS);
+});
+
+// src/core/jsx/jsx-runtime.ts
+function jsx(type, props, _key) {
+  const result = type(props);
+  return result ?? new XmlNode2("#fragment");
+}
+var jsxDEV;
+var init_jsx_runtime = __esm(() => {
+  init_parser();
+  init_jsx();
+  jsxDEV = jsx;
+});
+
+// src/core/jsx/jsx-dev-runtime.ts
+var init_jsx_dev_runtime = __esm(() => {
+  init_jsx_runtime();
+});
+
+// src/core/sections.tsx
+function readSectionProperties(children) {
+  const props = {};
+  for (const child of children) {
+    if (child.tag === "w:cols") {
+      const num = child.getAttribute("w:num");
+      if (num) {
+        const parsed = Number.parseInt(num, 10);
+        if (Number.isFinite(parsed) && parsed > 0)
+          props.columns = parsed;
+      }
+      continue;
+    }
+    if (child.tag === "w:type") {
+      const value = child.getAttribute("w:val");
+      if (value && isSectionType(value))
+        props.sectionType = value;
+    }
+  }
+  return props;
+}
+function isSectionType(value) {
+  return SECTION_TYPE_ORDER.includes(value);
+}
+function SentinelSectionParagraph({
+  columns,
+  sectionType
+}) {
+  return /* @__PURE__ */ jsxDEV(w.p, {
+    children: /* @__PURE__ */ jsxDEV(w.pPr, {
+      children: /* @__PURE__ */ jsxDEV(w.sectPr, {
+        children: [
+          sectionType && /* @__PURE__ */ jsxDEV(w.type, {
+            "w-val": sectionType
+          }, undefined, false, undefined, this),
+          columns !== undefined && /* @__PURE__ */ jsxDEV(w.cols, {
+            "w-num": String(columns)
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this);
+}
+function applyColumns(sectPr, columns) {
+  if (columns === undefined)
+    return;
+  const existing = sectPr.findChild("w:cols");
+  if (columns === null) {
+    if (existing) {
+      const index = sectPr.children.indexOf(existing);
+      if (index !== -1)
+        sectPr.children.splice(index, 1);
+    }
+    return;
+  }
+  if (existing) {
+    existing.setAttribute("w:num", String(columns));
+    return;
+  }
+  insertBeforeSectPrChange(sectPr, /* @__PURE__ */ jsxDEV(w.cols, {
+    "w-num": String(columns)
+  }, undefined, false, undefined, this));
+}
+function applySectionType(sectPr, sectionType) {
+  if (sectionType === undefined)
+    return;
+  const existing = sectPr.findChild("w:type");
+  if (sectionType === null) {
+    if (existing) {
+      const index = sectPr.children.indexOf(existing);
+      if (index !== -1)
+        sectPr.children.splice(index, 1);
+    }
+    return;
+  }
+  if (existing) {
+    existing.setAttribute("w:val", sectionType);
+    return;
+  }
+  const node = /* @__PURE__ */ jsxDEV(w.type, {
+    "w-val": sectionType
+  }, undefined, false, undefined, this);
+  const colsIndex = sectPr.children.findIndex((child) => child.tag === "w:cols");
+  if (colsIndex !== -1) {
+    sectPr.children.splice(colsIndex, 0, node);
+    return;
+  }
+  insertBeforeSectPrChange(sectPr, node);
+}
+function insertBeforeSectPrChange(sectPr, node) {
+  const changeIndex = sectPr.children.findIndex((child) => child.tag === "w:sectPrChange");
+  if (changeIndex === -1)
+    sectPr.children.push(node);
+  else
+    sectPr.children.splice(changeIndex, 0, node);
+}
+function removeInlineSectPr(sectPr, parentChildren) {
+  const index = parentChildren.indexOf(sectPr);
+  if (index === -1)
+    return false;
+  parentChildren.splice(index, 1);
+  return true;
+}
+function isTrailingSectPr(bodyChildren, parentChildren) {
+  return parentChildren === bodyChildren;
+}
+function wrapSectPrChange(sectPr, meta) {
+  const existingChangeIndex = sectPr.children.findIndex((child) => child.tag === "w:sectPrChange");
+  if (existingChangeIndex !== -1) {
+    sectPr.children.splice(existingChangeIndex, 1);
+  }
+  const snapshotChildren = [];
+  for (const child of sectPr.children) {
+    if (child.tag === "w:sectPrChange")
+      continue;
+    snapshotChildren.push(child.clone());
+  }
+  const change = /* @__PURE__ */ jsxDEV(w.sectPrChange, {
+    "w-id": meta.revisionId,
+    "w-author": meta.author,
+    "w-date": meta.date,
+    children: /* @__PURE__ */ jsxDEV(w.sectPr, {
+      children: snapshotChildren
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this);
+  sectPr.children.push(change);
+  return change;
+}
+var SECTION_TYPE_ORDER;
+var init_sections = __esm(() => {
+  init_jsx();
+  init_jsx_dev_runtime();
+  SECTION_TYPE_ORDER = [
+    "continuous",
+    "nextPage",
+    "evenPage",
+    "oddPage",
+    "nextColumn"
+  ];
+});
+
 // src/core/ast/sym.ts
 function decodeSym(font, charHex) {
   const codepoint = Number.parseInt(charHex, 16);
@@ -14153,6 +14470,14 @@ function readBlocks(view, body, state) {
       const id = `p${paragraphIndex++}`;
       blocks.push(readParagraph(view, child, id, state));
       view.blockReferences.set(id, { node: child, parent: body.children });
+      const inlineSectPr = findInlineSectPr(child);
+      if (inlineSectPr) {
+        const sectionId = `s${sectionIndex++}`;
+        blocks.push(buildSectionBreak(sectionId, inlineSectPr.node));
+        view.blockReferences.set(sectionId, inlineSectPr);
+        registerSectPrChange(view, inlineSectPr.node, state, sectionId);
+      }
+      registerParagraphMarkChanges(view, child, state, id);
       continue;
     }
     if (child.tag === "w:tbl") {
@@ -14163,12 +14488,60 @@ function readBlocks(view, body, state) {
     }
     if (child.tag === "w:sectPr") {
       const id = `s${sectionIndex++}`;
-      blocks.push({ id, type: "sectionBreak" });
+      blocks.push(buildSectionBreak(id, child));
       view.blockReferences.set(id, { node: child, parent: body.children });
+      registerSectPrChange(view, child, state, id);
     }
   }
   return blocks;
 }
+function registerParagraphMarkChanges(view, paragraph, state, blockId) {
+  const pPr = paragraph.findChild("w:pPr");
+  if (!pPr)
+    return;
+  const rPr = pPr.findChild("w:rPr");
+  if (!rPr)
+    return;
+  for (const child of rPr.children) {
+    if (child.tag !== "w:ins" && child.tag !== "w:del")
+      continue;
+    const id = `tc${state.trackedChangeIndex++}`;
+    view.trackedChangeReferences.set(id, {
+      node: child,
+      parent: rPr.children,
+      blockId
+    });
+  }
+}
+function registerSectPrChange(view, sectPr, state, blockId) {
+  const change = sectPr.findChild("w:sectPrChange");
+  if (!change)
+    return;
+  const id = `tc${state.trackedChangeIndex++}`;
+  view.trackedChangeReferences.set(id, {
+    node: change,
+    parent: sectPr.children,
+    blockId
+  });
+}
+function findInlineSectPr(paragraph) {
+  const pPr = paragraph.findChild("w:pPr");
+  if (!pPr)
+    return;
+  const sectPr = pPr.findChild("w:sectPr");
+  if (!sectPr)
+    return;
+  return { node: sectPr, parent: pPr.children };
+}
+function buildSectionBreak(id, sectPr) {
+  const props = readSectionProperties(sectPr.children);
+  const block = { id, type: "sectionBreak" };
+  if (props.columns !== undefined)
+    block.columns = props.columns;
+  if (props.sectionType !== undefined)
+    block.sectionType = props.sectionType;
+  return block;
+}
 function readParagraph(view, node, id, state) {
   const paragraph = { id, type: "paragraph", runs: [] };
   const paragraphProperties = node.findChild("w:pPr");
@@ -14707,6 +15080,7 @@ function readNotes(tree, rootTag, itemTag, idPrefix) {
 var RELATIONSHIP_NAMESPACE_IMAGE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image", RELATIONSHIP_NAMESPACE_HYPERLINK = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink", TRACKED_CHANGE_KIND_BY_TAG;
 var init_read = __esm(() => {
   init_parser();
+  init_sections();
   init_sym();
   TRACKED_CHANGE_KIND_BY_TAG = {
     "w:ins": "ins",
@@ -15124,178 +15498,6 @@ 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) {
-    result[tagName] = makeTag(`${prefix}:${tagName}`);
-  }
-  return result;
-}
-function makeTag(qualifiedName) {
-  return (props) => {
-    const attributes = {};
-    let childrenProp;
-    if (props) {
-      for (const [key, value] of Object.entries(props)) {
-        if (key === "children") {
-          childrenProp = value;
-          continue;
-        }
-        if (value === false || value == null)
-          continue;
-        attributes[mapAttributeName(key)] = String(value);
-      }
-    }
-    const childNodes = [];
-    flatten(normalizeChildren(childrenProp), childNodes);
-    return new XmlNode2(qualifiedName, attributes, childNodes);
-  };
-}
-function flatten(items, out) {
-  for (const item of items) {
-    if (item == null || item === false)
-      continue;
-    if (Array.isArray(item)) {
-      flatten(item, out);
-      continue;
-    }
-    if (item instanceof XmlNode2) {
-      if (item.tag === FRAGMENT_TAG) {
-        for (const child of item.children)
-          out.push(child);
-        continue;
-      }
-      out.push(item);
-      continue;
-    }
-    if (typeof item === "string" || typeof item === "number") {
-      out.push(XmlNode2.textNode(String(item)));
-    }
-  }
-}
-function mapAttributeName(name) {
-  const dashIndex = name.indexOf("-");
-  if (dashIndex === -1)
-    return name;
-  return `${name.slice(0, dashIndex)}:${name.slice(dashIndex + 1)}`;
-}
-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 = [
-    "document",
-    "body",
-    "p",
-    "pPr",
-    "pStyle",
-    "jc",
-    "numPr",
-    "ilvl",
-    "numId",
-    "r",
-    "rPr",
-    "rStyle",
-    "t",
-    "b",
-    "i",
-    "u",
-    "strike",
-    "color",
-    "highlight",
-    "sz",
-    "rFonts",
-    "br",
-    "tab",
-    "drawing",
-    "sectPr",
-    "tbl",
-    "tblPr",
-    "tblGrid",
-    "gridCol",
-    "tr",
-    "tc",
-    "tcPr",
-    "ins",
-    "del",
-    "delText",
-    "commentRangeStart",
-    "commentRangeEnd",
-    "commentReference",
-    "comments",
-    "comment",
-    "settings",
-    "trackChanges",
-    "hyperlink"
-  ];
-  R_TAGS = ["embed", "link", "id"];
-  A_TAGS = [
-    "graphic",
-    "graphicData",
-    "blip",
-    "xfrm",
-    "off",
-    "ext",
-    "prstGeom",
-    "avLst"
-  ];
-  WP_TAGS = [
-    "inline",
-    "anchor",
-    "extent",
-    "effectExtent",
-    "docPr",
-    "cNvGraphicFramePr"
-  ];
-  PIC_TAGS = [
-    "pic",
-    "nvPicPr",
-    "cNvPr",
-    "cNvPicPr",
-    "blipFill",
-    "spPr"
-  ];
-  CP_TAGS = ["coreProperties", "lastModifiedBy"];
-  DC_TAGS = ["title", "creator", "subject", "description"];
-  DCTERMS_TAGS = ["created", "modified"];
-  W14_TAGS = ["paraId", "textId"];
-  W15_TAGS = ["commentsEx", "commentEx"];
-  w = namespace("w", W_TAGS);
-  r = namespace("r", R_TAGS);
-  a = namespace("a", A_TAGS);
-  wp = namespace("wp", WP_TAGS);
-  pic = namespace("pic", PIC_TAGS);
-  cp = namespace("cp", CP_TAGS);
-  dc = namespace("dc", DC_TAGS);
-  dcterms = namespace("dcterms", DCTERMS_TAGS);
-  w14 = namespace("w14", W14_TAGS);
-  w15 = namespace("w15", W15_TAGS);
-});
-
-// src/core/jsx/jsx-runtime.ts
-function jsx(type, props, _key) {
-  const result = type(props);
-  return result ?? new XmlNode2("#fragment");
-}
-var jsxDEV;
-var init_jsx_runtime = __esm(() => {
-  init_parser();
-  init_jsx();
-  jsxDEV = jsx;
-});
-
-// src/core/jsx/jsx-dev-runtime.ts
-var init_jsx_dev_runtime = __esm(() => {
-  init_jsx_runtime();
-});
-
 // src/core/track-changes/emit.tsx
 function Ins({
   meta,
@@ -15349,6 +15551,7 @@ var init_core = __esm(() => {
   init_package();
   init_parser();
   init_relationships();
+  init_sections();
   init_track_changes();
   init_emit();
 });
@@ -15358,6 +15561,14 @@ async function respond(payload) {
   await Bun.write(Bun.stdout, `${JSON.stringify(payload)}
 `);
 }
+function setVerboseAck(verbose) {
+  verboseAck = verbose;
+}
+async function respondAck(payload) {
+  if (!verboseAck)
+    return;
+  await respond(payload);
+}
 async function writeStdout(text) {
   await Bun.write(Bun.stdout, text);
 }
@@ -15416,7 +15627,7 @@ async function resolveBlockOrFail(view, locator) {
     throw err;
   }
 }
-var EXIT;
+var EXIT, verboseAck = false;
 var init_respond = __esm(() => {
   init_core();
   EXIT = {
@@ -15427,86 +15638,291 @@ var init_respond = __esm(() => {
   };
 });
 
-// src/cli/comments/helpers.tsx
-function nextCommentId(view) {
-  if (!view.commentsTree)
-    return "0";
-  const root = XmlNode2.findRoot(view.commentsTree, "w:comments");
-  if (!root)
-    return "0";
-  let highest = -1;
-  for (const child of root.children) {
-    if (child.tag !== "w:comment")
-      continue;
-    const idAttribute = child.getAttribute("w:id");
-    if (idAttribute == null)
-      continue;
-    const numeric = Number(idAttribute);
-    if (Number.isFinite(numeric) && numeric > highest)
-      highest = numeric;
-  }
-  return String(highest + 1);
-}
-function generateParaId() {
-  const bytes = new Uint8Array(4);
-  crypto.getRandomValues(bytes);
-  let hex = "";
-  for (const byte of bytes)
-    hex += byte.toString(16).padStart(2, "0");
-  return hex.toUpperCase();
-}
-function authorInitials(author) {
-  const parts = author.trim().split(/\s+/).filter(Boolean);
-  if (parts.length === 0)
-    return "?";
-  const first = parts[0]?.charAt(0) ?? "";
-  const last = parts.length > 1 ? parts[parts.length - 1]?.charAt(0) ?? "" : "";
-  return (first + last).toUpperCase() || "?";
-}
-function ensureCommentsPart(view) {
-  if (view.commentsTree) {
-    const existing = XmlNode2.findRoot(view.commentsTree, "w:comments");
-    if (existing)
-      return existing;
+// src/core/find/index.ts
+function findTextSpans(doc, query, options = {}) {
+  const view = options.view ?? "accepted";
+  const exact = options.exact ?? false;
+  const useRegex = options.regex ?? false;
+  let effectiveQuery = query;
+  const applied = [];
+  if (!useRegex && !exact) {
+    const norm = normalizeQuery(query);
+    effectiveQuery = norm.normalized;
+    applied.push(...norm.applied);
+  }
+  const matcher = useRegex ? regexMatcher(query, options.ignoreCase ?? false) : literalMatcher(effectiveQuery, options.ignoreCase ?? false, !exact);
+  const out = [];
+  collectMatches(doc.blocks, matcher, view, out);
+  const result = { matches: out };
+  if (applied.length > 0) {
+    result.normalizedQuery = effectiveQuery;
+    result.normalizationApplied = applied;
   }
-  const root = /* @__PURE__ */ jsxDEV(w.comments, {
-    "xmlns:w": NS_W,
-    "xmlns:w14": NS_W14
-  }, undefined, false, undefined, this);
-  view.commentsTree = [root];
-  registerPart(view.relationshipsTree, view.contentTypesTree, {
-    partName: "word/comments.xml",
-    contentType: COMMENTS_CONTENT_TYPE,
-    relationshipType: COMMENTS_REL_TYPE,
-    target: "comments.xml"
-  });
-  return root;
+  return result;
 }
-function ensureCommentsExtPart(view) {
-  if (view.commentsExtTree) {
-    const existing = XmlNode2.findRoot(view.commentsExtTree, "w15:commentsEx");
-    if (existing)
-      return existing;
+function literalMatcher(query, ignoreCase, normalize) {
+  if (query.length === 0) {
+    throw new Error("query cannot be empty");
   }
-  const root = /* @__PURE__ */ jsxDEV(w15.commentsEx, {
-    "xmlns:w15": NS_W15,
-    "xmlns:mc": "http://schemas.openxmlformats.org/markup-compatibility/2006",
-    "mc:Ignorable": "w15"
-  }, undefined, false, undefined, this);
-  view.commentsExtTree = [root];
-  registerPart(view.relationshipsTree, view.contentTypesTree, {
-    partName: "word/commentsExtended.xml",
-    contentType: COMMENTS_EXT_CONTENT_TYPE,
-    relationshipType: COMMENTS_EXT_REL_TYPE,
-    target: "commentsExtended.xml"
-  });
-  return root;
+  const needle = ignoreCase ? query.toLowerCase() : query;
+  return (paragraphText2) => {
+    const canonical = normalize ? normalizeHaystack(paragraphText2) : paragraphText2;
+    const haystack = ignoreCase ? canonical.toLowerCase() : canonical;
+    const matches = [];
+    let cursor = haystack.indexOf(needle);
+    while (cursor !== -1) {
+      matches.push({
+        start: cursor,
+        end: cursor + needle.length,
+        text: paragraphText2.slice(cursor, cursor + needle.length)
+      });
+      cursor = haystack.indexOf(needle, cursor + needle.length);
+    }
+    return matches;
+  };
 }
-function paragraphTextLength(paragraph) {
-  return sumRunBearingTextLength(paragraph.children);
+function regexMatcher(pattern, ignoreCase) {
+  const flags = `g${ignoreCase ? "i" : ""}`;
+  const regex = new RegExp(pattern, flags);
+  return (paragraphText2) => {
+    const matches = [];
+    regex.lastIndex = 0;
+    let result = regex.exec(paragraphText2);
+    while (result !== null) {
+      const matched = result[0];
+      if (matched.length === 0) {
+        regex.lastIndex += 1;
+        result = regex.exec(paragraphText2);
+        continue;
+      }
+      matches.push({
+        start: result.index,
+        end: result.index + matched.length,
+        text: matched
+      });
+      result = regex.exec(paragraphText2);
+    }
+    return matches;
+  };
+}
+function collectMatches(blocks, matcher, view, out) {
+  for (const block of blocks) {
+    if (block.type === "paragraph") {
+      const paragraphText2 = paragraphTextForView(block, view);
+      for (const span of matcher(paragraphText2)) {
+        const match = {
+          blockId: block.id,
+          start: span.start,
+          end: span.end,
+          text: span.text
+        };
+        const overlaps = trackedChangesOverlapping(block, span.start, span.end, view);
+        if (overlaps.length > 0)
+          match.trackedChanges = overlaps;
+        out.push(match);
+      }
+      continue;
+    }
+    if (block.type === "table") {
+      for (const row of block.rows) {
+        for (const cell of row.cells) {
+          collectMatches(cell.blocks, matcher, view, out);
+        }
+      }
+    }
+  }
+}
+function paragraphTextForView(paragraph, view) {
+  let out = "";
+  for (const run of paragraph.runs) {
+    if (run.type !== "text")
+      continue;
+    if (!isRunVisibleInView(run.trackedChange?.kind, view))
+      continue;
+    out += run.text;
+  }
+  return out;
+}
+function isRunVisibleInView(kind, view) {
+  if (view === "current")
+    return true;
+  if (view === "accepted")
+    return kind !== "del" && kind !== "moveFrom";
+  return kind !== "ins" && kind !== "moveTo";
+}
+function normalizeQuery(query) {
+  const applied = [];
+  let result = query;
+  const stripped = stripBalancedMarkdownEmphasis(result);
+  if (stripped !== result) {
+    applied.push("strip-md-emphasis");
+    result = stripped;
+  }
+  const quoteNormalized = normalizeQuotes(result);
+  if (quoteNormalized !== result) {
+    applied.push("smart-quotes");
+    result = quoteNormalized;
+  }
+  const dashNormalized = normalizeDashes(result);
+  if (dashNormalized !== result) {
+    applied.push("dashes");
+    result = dashNormalized;
+  }
+  return { normalized: result, applied };
+}
+function normalizeHaystack(text) {
+  return normalizeDashes(normalizeQuotes(text));
+}
+function normalizeQuotes(text) {
+  return text.replace(/[\u2018\u2019]/g, "'").replace(/[\u201C\u201D]/g, '"');
+}
+function normalizeDashes(text) {
+  return text.replace(/[\u2013\u2014]/g, "-");
+}
+function stripBalancedMarkdownEmphasis(text) {
+  const patterns = [
+    /\*\*(\S(?:.*?\S)?)\*\*/g,
+    /__(\S(?:.*?\S)?)__/g,
+    /`(\S(?:.*?\S)?)`/g,
+    /(?<![A-Za-z0-9_])\*(\S(?:.*?\S)?)\*(?![A-Za-z0-9_])/g,
+    /(?<![A-Za-z0-9_])_(\S(?:.*?\S)?)_(?![A-Za-z0-9_])/g
+  ];
+  let result = text;
+  for (const pattern of patterns) {
+    result = result.replace(pattern, "$1");
+  }
+  return result;
+}
+function trackedChangesOverlapping(paragraph, start, end, view) {
+  const seen = new Set;
+  const out = [];
+  let offset = 0;
+  for (const run of paragraph.runs) {
+    if (run.type !== "text")
+      continue;
+    if (!isRunVisibleInView(run.trackedChange?.kind, view))
+      continue;
+    const length = run.text.length;
+    const runStart = offset;
+    const runEnd = offset + length;
+    offset = runEnd;
+    if (runEnd <= start || runStart >= end)
+      continue;
+    const change = run.trackedChange;
+    if (!change)
+      continue;
+    if (seen.has(change.id))
+      continue;
+    seen.add(change.id);
+    out.push(change);
+  }
+  return out;
+}
+
+// src/cli/comments/helpers.tsx
+function isWrapperVisibleInView(tag, view) {
+  if (!isRunBearingWrapper(tag))
+    return false;
+  if (view === "current")
+    return true;
+  if (view === "accepted")
+    return tag !== "w:del" && tag !== "w:moveFrom";
+  return tag !== "w:ins" && tag !== "w:moveTo";
+}
+function sumVisibleTextLength(children, view) {
+  let total = 0;
+  for (const child of children) {
+    if (child.tag === "w:r") {
+      total += runTextLength(child);
+      continue;
+    }
+    if (isWrapperVisibleInView(child.tag, view)) {
+      total += sumVisibleTextLength(child.children, view);
+    }
+  }
+  return total;
+}
+function nextCommentId(view) {
+  if (!view.commentsTree)
+    return "0";
+  const root = XmlNode2.findRoot(view.commentsTree, "w:comments");
+  if (!root)
+    return "0";
+  let highest = -1;
+  for (const child of root.children) {
+    if (child.tag !== "w:comment")
+      continue;
+    const idAttribute = child.getAttribute("w:id");
+    if (idAttribute == null)
+      continue;
+    const numeric = Number(idAttribute);
+    if (Number.isFinite(numeric) && numeric > highest)
+      highest = numeric;
+  }
+  return String(highest + 1);
+}
+function generateParaId() {
+  const bytes = new Uint8Array(4);
+  crypto.getRandomValues(bytes);
+  let hex = "";
+  for (const byte of bytes)
+    hex += byte.toString(16).padStart(2, "0");
+  return hex.toUpperCase();
+}
+function authorInitials(author) {
+  const parts = author.trim().split(/\s+/).filter(Boolean);
+  if (parts.length === 0)
+    return "?";
+  const first = parts[0]?.charAt(0) ?? "";
+  const last = parts.length > 1 ? parts[parts.length - 1]?.charAt(0) ?? "" : "";
+  return (first + last).toUpperCase() || "?";
+}
+function ensureCommentsPart(view) {
+  if (view.commentsTree) {
+    const existing = XmlNode2.findRoot(view.commentsTree, "w:comments");
+    if (existing)
+      return existing;
+  }
+  const root = /* @__PURE__ */ jsxDEV(w.comments, {
+    "xmlns:w": NS_W,
+    "xmlns:w14": NS_W14
+  }, undefined, false, undefined, this);
+  view.commentsTree = [root];
+  registerPart(view.relationshipsTree, view.contentTypesTree, {
+    partName: "word/comments.xml",
+    contentType: COMMENTS_CONTENT_TYPE,
+    relationshipType: COMMENTS_REL_TYPE,
+    target: "comments.xml"
+  });
+  return root;
+}
+function ensureCommentsExtPart(view) {
+  if (view.commentsExtTree) {
+    const existing = XmlNode2.findRoot(view.commentsExtTree, "w15:commentsEx");
+    if (existing)
+      return existing;
+  }
+  const root = /* @__PURE__ */ jsxDEV(w15.commentsEx, {
+    "xmlns:w15": NS_W15,
+    "xmlns:mc": "http://schemas.openxmlformats.org/markup-compatibility/2006",
+    "mc:Ignorable": "w15"
+  }, undefined, false, undefined, this);
+  view.commentsExtTree = [root];
+  registerPart(view.relationshipsTree, view.contentTypesTree, {
+    partName: "word/commentsExtended.xml",
+    contentType: COMMENTS_EXT_CONTENT_TYPE,
+    relationshipType: COMMENTS_EXT_REL_TYPE,
+    target: "commentsExtended.xml"
+  });
+  return root;
 }
-function addCommentMarkersToParagraph(paragraph, commentId, span) {
-  const total = paragraphTextLength(paragraph);
+function paragraphTextLength(paragraph, view = "current") {
+  if (view === "current")
+    return sumRunBearingTextLength(paragraph.children);
+  return sumVisibleTextLength(paragraph.children, view);
+}
+function addCommentMarkersToParagraph(paragraph, commentId, span, view = "current") {
+  const total = paragraphTextLength(paragraph, view);
   const range = span ?? { start: 0, end: total };
   if (range.start < 0 || range.end > total || range.start > range.end) {
     throw new SpanOutOfRangeError(`Span ${range.start}-${range.end} out of paragraph length ${total}`);
@@ -15518,26 +15934,24 @@ function addCommentMarkersToParagraph(paragraph, commentId, span) {
       node: commentRangeEndMarker(commentId),
       follower: commentReferenceRun(commentId)
     }
-  ]);
+  ], view);
 }
-function addCommentRangeMarkers(startParagraph, startOffset, endParagraph, endOffset, commentId) {
+function addCommentRangeMarkers(startParagraph, startOffset, endParagraph, endOffset, commentId, view = "current") {
   if (startParagraph === endParagraph) {
     addCommentMarkersToParagraph(startParagraph, commentId, {
       start: startOffset,
       end: endOffset
-    });
+    }, view);
     return;
   }
-  placeMarkersInParagraph(startParagraph, [
-    { offset: startOffset, node: commentRangeStartMarker(commentId) }
-  ]);
+  placeMarkersInParagraph(startParagraph, [{ offset: startOffset, node: commentRangeStartMarker(commentId) }], view);
   placeMarkersInParagraph(endParagraph, [
     {
       offset: endOffset,
       node: commentRangeEndMarker(commentId),
       follower: commentReferenceRun(commentId)
     }
-  ]);
+  ], view);
 }
 function addCommentMarkersAroundRun(paragraph, target, commentId) {
   function walk(parent) {
@@ -15654,10 +16068,10 @@ function commentReferenceRun(commentId) {
     ]
   }, undefined, true, undefined, this);
 }
-function placeMarkersInParagraph(paragraph, markers) {
+function placeMarkersInParagraph(paragraph, markers, view = "current") {
   if (markers.length === 0)
     return;
-  const total = paragraphTextLength(paragraph);
+  const total = paragraphTextLength(paragraph, view);
   for (const marker of markers) {
     if (marker.offset < 0 || marker.offset > total) {
       throw new SpanOutOfRangeError(`Marker offset ${marker.offset} out of paragraph length ${total}`);
@@ -15665,13 +16079,13 @@ function placeMarkersInParagraph(paragraph, markers) {
   }
   const pending = markers.slice();
   const state = { offset: 0, placedCount: 0 };
-  paragraph.children = walkAndPlace(paragraph.children, pending, state);
+  paragraph.children = walkAndPlace(paragraph.children, pending, state, view);
   flushAtCurrentOffset(paragraph.children, pending, state);
   if (state.placedCount !== markers.length) {
     throw new SpanOutOfRangeError(`Could not place comment markers (placed ${state.placedCount} of ${markers.length})`);
   }
 }
-function walkAndPlace(children, pending, state) {
+function walkAndPlace(children, pending, state, view) {
   const result = [];
   for (const child of children) {
     if (child.tag === "w:r") {
@@ -15714,8 +16128,12 @@ function walkAndPlace(children, pending, state) {
       continue;
     }
     if (isRunBearingWrapper(child.tag)) {
+      if (!isWrapperVisibleInView(child.tag, view)) {
+        result.push(child);
+        continue;
+      }
       flushAtCurrentOffset(result, pending, state);
-      const innerChildren = walkAndPlace(child.children, pending, state);
+      const innerChildren = walkAndPlace(child.children, pending, state, view);
       const wrapper = new XmlNode2(child.tag, { ...child.attributes });
       wrapper.children = innerChildren;
       result.push(wrapper);
@@ -15880,10 +16298,16 @@ async function run(args) {
       allowPositionals: true,
       options: {
         range: { type: "string" },
+        anchor: { type: "string" },
+        occurrence: { type: "string" },
         text: { type: "string" },
+        batch: { type: "string" },
         author: { type: "string" },
+        current: { type: "boolean" },
+        baseline: { type: "boolean" },
         output: { type: "string", short: "o" },
         "dry-run": { type: "boolean" },
+        verbose: { type: "boolean", short: "v" },
         help: { type: "boolean", short: "h" }
       }
     });
@@ -15895,171 +16319,338 @@ async function run(args) {
     await writeStdout(HELP);
     return EXIT.OK;
   }
+  setVerboseAck(Boolean(parsed.values.verbose));
   const path = parsed.positionals[0];
   if (!path)
     return fail("USAGE", "Missing FILE argument", HELP);
   const rangeInput = parsed.values.range;
+  const anchorInput = parsed.values.anchor;
+  const batchInput = parsed.values.batch;
   const text = parsed.values.text;
-  if (!rangeInput)
-    return fail("USAGE", "Missing --range LOCATOR", HELP);
-  if (!text)
-    return fail("USAGE", "Missing --text TEXT", HELP);
-  let locator;
-  try {
-    locator = parseLocator(rangeInput);
-  } catch (error) {
-    if (error instanceof LocatorParseError) {
-      return fail("INVALID_LOCATOR", error.message);
-    }
-    throw error;
+  const occurrenceRaw = parsed.values.occurrence;
+  const defaultAuthor = parsed.values.author ?? Bun.env.DOCX_AUTHOR ?? "";
+  const outputPath = parsed.values.output;
+  const dryRun = Boolean(parsed.values["dry-run"]);
+  const wantCurrent = Boolean(parsed.values.current);
+  const wantBaseline = Boolean(parsed.values.baseline);
+  if (wantCurrent && wantBaseline) {
+    return fail("USAGE", "--current and --baseline are mutually exclusive");
   }
-  if (locator.kind === "range") {
-    return runCrossBlock(parsed, path, rangeInput, locator, text);
+  const findView = wantCurrent ? "current" : wantBaseline ? "baseline" : "accepted";
+  const anchorCount = (rangeInput ? 1 : 0) + (anchorInput ? 1 : 0) + (batchInput ? 1 : 0);
+  if (anchorCount === 0) {
+    return fail("USAGE", "Specify exactly one of --range, --anchor, or --batch", HELP);
   }
-  const target = locatorToBlockTarget(locator);
-  if (!target) {
-    return fail("INVALID_LOCATOR", "comments add supports paragraph locators only (pN, pN:start-end, pN:S-pM:E, or tT:rRcC:pK[:start-end])", "Comments and images are not valid anchors.");
+  if (anchorCount > 1) {
+    return fail("USAGE", "--range, --anchor, and --batch are mutually exclusive", HELP);
   }
-  const blockId = target.blockId;
   const view = await openOrFail(path);
   if (typeof view === "number")
     return view;
-  const paragraphRef = await resolveBlockOrFail(view, blockId);
-  if (typeof paragraphRef === "number")
-    return paragraphRef;
-  const span = target.span;
-  const author = parsed.values.author ?? Bun.env.DOCX_AUTHOR ?? "";
-  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,
-      operation: "comments.add",
-      dryRun: true,
-      path,
-      commentId: `c${numericId}`,
-      locator: rangeInput,
-      ...outputPath ? { output: outputPath } : {}
-    });
-    return EXIT.OK;
-  }
+  let rawEntries;
+  if (batchInput) {
+    if (text !== undefined || rangeInput || anchorInput || occurrenceRaw) {
+      return fail("USAGE", "--batch reads each entry's range/anchor/text/author from JSONL \u2014 do not pass them on the CLI", HELP);
+    }
+    try {
+      rawEntries = await readJsonlEntries(batchInput);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return fail("USAGE", `Failed to read batch: ${message}`);
+    }
+    if (rawEntries.length === 0) {
+      return fail("USAGE", "Batch file is empty");
+    }
+  } else {
+    if (!text)
+      return fail("USAGE", "Missing --text TEXT", HELP);
+    const occurrence = occurrenceRaw === undefined ? undefined : Number(occurrenceRaw);
+    if (occurrence !== undefined && (!Number.isInteger(occurrence) || occurrence < 1)) {
+      return fail("USAGE", `--occurrence must be a positive integer (1-indexed), got "${occurrenceRaw}"`);
+    }
+    rawEntries = [
+      {
+        range: rangeInput,
+        anchor: anchorInput,
+        occurrence,
+        text
+      }
+    ];
+  }
+  let resolved;
   try {
-    addCommentMarkersToParagraph(paragraphRef.node, numericId, span);
+    resolved = rawEntries.map((entry, index) => resolveEntry(view, entry, defaultAuthor, index, batchInput !== undefined, findView));
   } catch (error) {
-    if (error instanceof SpanOutOfRangeError) {
-      return fail("INVALID_LOCATOR", error.message);
+    if (error instanceof EntryError) {
+      return fail(error.code, error.message, error.hint);
     }
     throw error;
   }
-  const commentsRoot = ensureCommentsPart(view);
-  commentsRoot.children.push(/* @__PURE__ */ jsxDEV(CommentBody, {
-    options: {
-      id: numericId,
-      author,
-      date,
-      initials: authorInitials(author),
-      paraId,
-      text
-    }
-  }, undefined, false, undefined, this));
-  await saveDocView(view, outputPath);
-  await respond({
-    ok: true,
-    operation: "comments.add",
-    path: outputPath ?? path,
-    commentId: `c${numericId}`,
-    locator: rangeInput
-  });
-  return EXIT.OK;
-}
-async function runCrossBlock(parsed, path, rangeInput, locator, text) {
-  const view = await openOrFail(path);
-  if (typeof view === "number")
-    return view;
-  const startRef = await resolveBlockOrFail(view, locator.start.blockId);
-  if (typeof startRef === "number")
-    return startRef;
-  const endRef = await resolveBlockOrFail(view, locator.end.blockId);
-  if (typeof endRef === "number")
-    return endRef;
-  const author = parsed.values.author ?? Bun.env.DOCX_AUTHOR ?? "";
-  const date = new Date().toISOString();
-  const numericId = nextCommentId(view);
-  const paraId = generateParaId();
-  const outputPath = parsed.values.output;
-  if (parsed.values["dry-run"]) {
+  if (dryRun) {
     await respond({
       ok: true,
       operation: "comments.add",
       dryRun: true,
       path,
-      commentId: `c${numericId}`,
-      locator: rangeInput,
-      ...outputPath ? { output: outputPath } : {}
+      ...outputPath ? { output: outputPath } : {},
+      batch: resolved.map((entry) => ({
+        locator: entry.locatorString
+      }))
     });
     return EXIT.OK;
   }
-  try {
-    addCommentRangeMarkers(startRef.node, locator.start.offset, endRef.node, locator.end.offset, numericId);
-  } catch (error) {
-    if (error instanceof SpanOutOfRangeError) {
-      return fail("INVALID_LOCATOR", error.message);
-    }
-    throw error;
-  }
-  const commentsRoot = ensureCommentsPart(view);
-  commentsRoot.children.push(/* @__PURE__ */ jsxDEV(CommentBody, {
-    options: {
-      id: numericId,
-      author,
-      date,
-      initials: authorInitials(author),
-      paraId,
-      text
-    }
-  }, undefined, false, undefined, this));
+  const date = new Date().toISOString();
+  const minted = [];
+  for (const entry of resolved) {
+    const numericId = nextCommentId(view);
+    const paraId = generateParaId();
+    try {
+      if (entry.kind === "single") {
+        const paragraphRef = await resolveBlockOrFail(view, entry.blockId);
+        if (typeof paragraphRef === "number") {
+          return paragraphRef;
+        }
+        addCommentMarkersToParagraph(paragraphRef.node, numericId, entry.span, findView);
+      } else {
+        const startRef = await resolveBlockOrFail(view, entry.startBlockId);
+        if (typeof startRef === "number")
+          return startRef;
+        const endRef = await resolveBlockOrFail(view, entry.endBlockId);
+        if (typeof endRef === "number")
+          return endRef;
+        addCommentRangeMarkers(startRef.node, entry.startOffset, endRef.node, entry.endOffset, numericId, findView);
+      }
+    } catch (error) {
+      if (error instanceof SpanOutOfRangeError) {
+        return fail("INVALID_LOCATOR", error.message);
+      }
+      throw error;
+    }
+    const commentsRoot = ensureCommentsPart(view);
+    commentsRoot.children.push(/* @__PURE__ */ jsxDEV(CommentBody, {
+      options: {
+        id: numericId,
+        author: entry.author,
+        date,
+        initials: authorInitials(entry.author),
+        paraId,
+        text: entry.text
+      }
+    }, undefined, false, undefined, this));
+    minted.push({
+      commentId: `c${numericId}`,
+      locator: entry.locatorString
+    });
+  }
   await saveDocView(view, outputPath);
-  await respond({
-    ok: true,
-    operation: "comments.add",
-    path: outputPath ?? path,
-    commentId: `c${numericId}`,
-    locator: rangeInput
-  });
+  if (batchInput) {
+    await respond({
+      ok: true,
+      operation: "comments.add",
+      path: outputPath ?? path,
+      batch: minted
+    });
+  } else {
+    const single = minted[0];
+    if (!single) {
+      throw new Error("internal: single-shot path produced no minted entry");
+    }
+    await respondAck({
+      ok: true,
+      operation: "comments.add",
+      path: outputPath ?? path,
+      commentId: single.commentId,
+      locator: single.locator
+    });
+  }
   return EXIT.OK;
 }
-var HELP = `docx comments add \u2014 anchor a new comment to a locator
+function resolveEntry(view, raw, defaultAuthor, entryIndex, isBatch, findView) {
+  const labelPrefix = isBatch ? `entry ${entryIndex}: ` : "";
+  const author = raw.author ?? defaultAuthor;
+  const anchorCount = (raw.range ? 1 : 0) + (raw.anchor ? 1 : 0);
+  if (anchorCount === 0) {
+    throw new EntryError("USAGE", `${labelPrefix}must specify either "range" or "anchor"`);
+  }
+  if (anchorCount > 1) {
+    throw new EntryError("USAGE", `${labelPrefix}"range" and "anchor" are mutually exclusive`);
+  }
+  if (typeof raw.text !== "string" || raw.text.length === 0) {
+    throw new EntryError("USAGE", `${labelPrefix}"text" is required`);
+  }
+  if (raw.range) {
+    return resolveLocatorEntry(raw.range, raw.text, author, labelPrefix);
+  }
+  const anchor = raw.anchor;
+  if (!anchor) {
+    throw new EntryError("USAGE", `${labelPrefix}missing anchor`);
+  }
+  const occurrenceExplicit = raw.occurrence !== undefined;
+  const occurrence = raw.occurrence ?? 1;
+  if (!Number.isInteger(occurrence) || occurrence < 1) {
+    throw new EntryError("USAGE", `${labelPrefix}"occurrence" must be a positive integer, got ${JSON.stringify(raw.occurrence)}`);
+  }
+  return resolveAnchorEntry(view, anchor, occurrence, occurrenceExplicit, raw.text, author, labelPrefix, findView);
+}
+function resolveLocatorEntry(rangeInput, text, author, labelPrefix) {
+  let locator;
+  try {
+    locator = parseLocator(rangeInput);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new EntryError("INVALID_LOCATOR", `${labelPrefix}${message}`);
+  }
+  if (locator.kind === "range") {
+    return {
+      kind: "range",
+      startBlockId: locator.start.blockId,
+      startOffset: locator.start.offset,
+      endBlockId: locator.end.blockId,
+      endOffset: locator.end.offset,
+      text,
+      author,
+      locatorString: rangeInput
+    };
+  }
+  const target = locatorToBlockTarget(locator);
+  if (!target) {
+    throw new EntryError("INVALID_LOCATOR", `${labelPrefix}comments add supports paragraph locators only (pN, pN:start-end, pN:S-pM:E, or tT:rRcC:pK[:start-end])`, "Comments and images are not valid anchors.");
+  }
+  return {
+    kind: "single",
+    blockId: target.blockId,
+    span: target.span,
+    text,
+    author,
+    locatorString: rangeInput
+  };
+}
+function resolveAnchorEntry(view, anchor, occurrence, occurrenceExplicit, text, author, labelPrefix, findView) {
+  const result = findTextSpans(view.doc, anchor, { view: findView });
+  const matches = result.matches;
+  if (matches.length === 0) {
+    throw new EntryError("MATCH_NOT_FOUND", `${labelPrefix}anchor not found: ${JSON.stringify(anchor)}`, result.normalizedQuery ? `Searched as "${result.normalizedQuery}" after normalization (${(result.normalizationApplied ?? []).join(", ")}).` : undefined);
+  }
+  if (matches.length > 1 && !occurrenceExplicit) {
+    throw new EntryError("USAGE", `${labelPrefix}anchor matches ${matches.length} times; pass --occurrence N (1..${matches.length}) to disambiguate`);
+  }
+  if (occurrence > matches.length) {
+    throw new EntryError("MATCH_NOT_FOUND", `${labelPrefix}only ${matches.length} match(es) for anchor; --occurrence ${occurrence} is out of range`);
+  }
+  const match = matches[occurrence - 1];
+  if (!match) {
+    throw new EntryError("MATCH_NOT_FOUND", `${labelPrefix}match index ${occurrence} not found`);
+  }
+  const locatorString = `${match.blockId}:${match.start}-${match.end}`;
+  return {
+    kind: "single",
+    blockId: match.blockId,
+    span: { start: match.start, end: match.end },
+    text,
+    author,
+    locatorString
+  };
+}
+async function readJsonlEntries(source) {
+  const raw = source === "-" ? await new Response(Bun.stdin.stream()).text() : await Bun.file(source).text();
+  const entries = [];
+  const lines = raw.split(`
+`);
+  for (let index = 0;index < lines.length; index++) {
+    const lineRaw = lines[index];
+    if (lineRaw === undefined)
+      continue;
+    const line = lineRaw.trim();
+    if (line.length === 0)
+      continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`line ${index + 1}: invalid JSON (${message})`);
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error(`line ${index + 1}: expected a JSON object`);
+    }
+    entries.push(parsed);
+  }
+  return entries;
+}
+var HELP = `docx comments add \u2014 anchor a new comment to a locator or phrase
 
 Usage:
-  docx comments add FILE [options]
-
-Required:
-  --range LOCATOR   Where to anchor. Supports:
-                      pN              whole paragraph
-                      pN:S-E          chars S..E of pN
-                      pN:S-pM:E       chars S of pN through char E of pM (cross-paragraph)
-                      tT:rRcC:pK      whole cell paragraph
-                      tT:rRcC:pK:S-E  chars S..E of cell paragraph
-  --text TEXT       Comment body
-
-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
+  docx comments add FILE --range LOCATOR --text TEXT [options]
+  docx comments add FILE --anchor PHRASE --text TEXT [options]
+  docx comments add FILE --batch FILE.jsonl [options]
+  docx comments add FILE --batch -    [options]   # read JSONL from stdin
+
+Anchor (one required, mutually exclusive):
+  --range LOCATOR     Where to anchor. Supports:
+                        pN              whole paragraph
+                        pN:S-E          chars S..E of pN
+                        pN:S-pM:E       chars S of pN through char E of pM
+                        tT:rRcC:pK      whole cell paragraph
+                        tT:rRcC:pK:S-E  chars S..E of cell paragraph
+  --anchor PHRASE     Find the phrase via the same matcher as \`docx find\`
+                      (default: accepted view, normalization on). The match
+                      is converted to a pN:S-E locator and used as the
+                      anchor. Errors if the phrase matches more than once
+                      without --occurrence.
+  --batch PATH        Read a JSONL file (one entry per line). Each entry is
+                      a JSON object with the same shape as a single-shot
+                      call: { range | anchor (+ optional occurrence), text,
+                      optional author }. Use - for stdin.
+
+Per-entry fields:
+  --text TEXT         Comment body. Required for single-shot; required as
+                      a "text" field on every JSONL entry.
+  --occurrence N      For --anchor: pick the Nth match (1-indexed,
+                      default 1). Errors if N is out of range.
+  --author NAME       Author name (default: $DOCX_AUTHOR)
+
+View (for resolving --range offsets and --anchor matches):
+  --current           Resolve offsets in the raw concatenation (with both
+                      ins and del text). Use when offsets came from
+                      \`docx find --current\` or hand-counted bytes.
+  --baseline          Resolve offsets in the pre-change view (skip ins/
+                      moveTo).
+                      Default: accepted view (skip del/moveFrom) \u2014 matches
+                      \`find\`'s default. Mutually exclusive.
+
+General options:
+  -o, --output PATH   Write to PATH instead of overwriting FILE
+  --dry-run           Print what would be added; do not write the file
+  -v, --verbose       Print the success ack JSON (default: silent on success
+                      for single; batch always prints the minted ids)
+  -h, --help          Show this help
 
 Examples:
   docx comments add doc.docx --range p3 --text "Reconsider this paragraph"
-  docx comments add doc.docx --range p3:5-20 --text "Sharper wording?" --author "Jane"
-  docx comments add doc.docx --range p3:5-p5:10 --text "Whole section?" --author "Reviewer"
-`;
+  docx comments add doc.docx --anchor "fatally flawed" --text "Cite source?"
+  docx comments add doc.docx --anchor "TODO" --occurrence 2 --text "Pick up here"
+  docx comments add doc.docx --batch reviews.jsonl
+  cat reviews.jsonl | docx comments add doc.docx --batch -
+
+Batch JSONL example:
+  {"range": "p3:5-20", "text": "Sharper wording?"}
+  {"anchor": "fatally flawed", "text": "Cite Bianco here.", "author": "Reviewer"}
+`, EntryError;
 var init_add = __esm(() => {
   init_core();
   init_respond();
   init_helpers();
   init_jsx_dev_runtime();
+  EntryError = class EntryError extends Error {
+    code;
+    hint;
+    constructor(code, message, hint) {
+      super(message);
+      this.code = code;
+      this.hint = hint;
+      this.name = "EntryError";
+    }
+  };
 });
 
 // src/cli/comments/delete.ts
@@ -16075,9 +16666,11 @@ async function run2(args) {
       args,
       allowPositionals: true,
       options: {
-        id: { type: "string" },
+        id: { type: "string", multiple: true },
+        batch: { type: "string" },
         output: { type: "string", short: "o" },
         "dry-run": { type: "boolean" },
+        verbose: { type: "boolean", short: "v" },
         help: { type: "boolean", short: "h" }
       }
     });
@@ -16089,20 +16682,49 @@ async function run2(args) {
     await writeStdout(HELP2);
     return EXIT.OK;
   }
+  setVerboseAck(Boolean(parsed.values.verbose));
   const path = parsed.positionals[0];
   if (!path)
     return fail("USAGE", "Missing FILE argument", HELP2);
-  const idInput = parsed.values.id;
-  if (!idInput)
-    return fail("USAGE", "Missing --id COMMENT_ID", HELP2);
-  const numericId = idInput.startsWith("c") ? idInput.slice(1) : idInput;
-  const commentId = `c${numericId}`;
+  const idsRaw = parsed.values.id ?? [];
+  const batchInput = parsed.values.batch;
+  if (idsRaw.length > 0 && batchInput) {
+    return fail("USAGE", "--id and --batch are mutually exclusive", HELP2);
+  }
+  if (idsRaw.length === 0 && !batchInput) {
+    return fail("USAGE", "Specify --id cN (repeatable) or --batch FILE", HELP2);
+  }
+  let rawIds;
+  if (batchInput) {
+    try {
+      rawIds = await readJsonlIds(batchInput);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return fail("USAGE", `Failed to read batch: ${message}`);
+    }
+    if (rawIds.length === 0) {
+      return fail("USAGE", "Batch file is empty");
+    }
+  } else {
+    rawIds = idsRaw;
+  }
+  const seen = new Set;
+  const ordered = [];
+  for (const raw of rawIds) {
+    const normalized = raw.startsWith("c") ? raw : `c${raw}`;
+    if (seen.has(normalized))
+      continue;
+    seen.add(normalized);
+    ordered.push(normalized);
+  }
   const view = await openOrFail(path);
   if (typeof view === "number")
     return view;
-  const commentReference = findCommentByNumericId(view, numericId);
-  if (!commentReference) {
-    return fail("COMMENT_NOT_FOUND", `Comment not found: ${commentId}`);
+  for (const commentId of ordered) {
+    const numericId = commentId.slice(1);
+    if (!findCommentByNumericId(view, numericId)) {
+      return fail("COMMENT_NOT_FOUND", `Comment not found: ${commentId}`);
+    }
   }
   const outputPath = parsed.values.output;
   if (parsed.values["dry-run"]) {
@@ -16111,46 +16733,104 @@ async function run2(args) {
       operation: "comments.delete",
       dryRun: true,
       path,
-      commentId,
-      ...outputPath ? { output: outputPath } : {}
+      ...outputPath ? { output: outputPath } : {},
+      batch: ordered.map((commentId) => ({ commentId }))
     });
     return EXIT.OK;
   }
-  const paraId = findCommentParaId(view, commentId);
-  const commentIndex = commentReference.parent.indexOf(commentReference.node);
-  if (commentIndex !== -1)
-    commentReference.parent.splice(commentIndex, 1);
-  if (paraId && view.commentsExtTree) {
-    const extRoot = XmlNode2.findRoot(view.commentsExtTree, "w15:commentsEx");
-    if (extRoot) {
-      extRoot.children = extRoot.children.filter((child) => !(child.tag === "w15:commentEx" && child.getAttribute("w15:paraId") === paraId));
+  for (const commentId of ordered) {
+    const numericId = commentId.slice(1);
+    const commentReference = findCommentByNumericId(view, numericId);
+    if (!commentReference)
+      continue;
+    const paraId = findCommentParaId(view, commentId);
+    const commentIndex = commentReference.parent.indexOf(commentReference.node);
+    if (commentIndex !== -1)
+      commentReference.parent.splice(commentIndex, 1);
+    if (paraId && view.commentsExtTree) {
+      const extRoot = XmlNode2.findRoot(view.commentsExtTree, "w15:commentsEx");
+      if (extRoot) {
+        extRoot.children = extRoot.children.filter((child) => !(child.tag === "w15:commentEx" && child.getAttribute("w15:paraId") === paraId));
+      }
     }
+    removeCommentMarkers(view.documentTree, numericId);
   }
-  removeCommentMarkers(view.documentTree, numericId);
   await saveDocView(view, outputPath);
-  await respond({
-    ok: true,
-    operation: "comments.delete",
-    path: outputPath ?? path,
-    commentId
-  });
+  if (batchInput || ordered.length > 1) {
+    await respond({
+      ok: true,
+      operation: "comments.delete",
+      path: outputPath ?? path,
+      batch: ordered.map((commentId) => ({ commentId }))
+    });
+  } else {
+    const single = ordered[0];
+    if (!single) {
+      throw new Error("internal: empty single-shot id list");
+    }
+    await respondAck({
+      ok: true,
+      operation: "comments.delete",
+      path: outputPath ?? path,
+      commentId: single
+    });
+  }
   return EXIT.OK;
 }
-var HELP2 = `docx comments delete \u2014 remove a comment
+async function readJsonlIds(source) {
+  const raw = source === "-" ? await new Response(Bun.stdin.stream()).text() : await Bun.file(source).text();
+  const ids = [];
+  const lines = raw.split(`
+`);
+  for (let index = 0;index < lines.length; index++) {
+    const lineRaw = lines[index];
+    if (lineRaw === undefined)
+      continue;
+    const line = lineRaw.trim();
+    if (line.length === 0)
+      continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`line ${index + 1}: invalid JSON (${message})`);
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error(`line ${index + 1}: expected a JSON object`);
+    }
+    const entry = parsed;
+    if (typeof entry.id !== "string" || entry.id.length === 0) {
+      throw new Error(`line ${index + 1}: missing "id"`);
+    }
+    ids.push(entry.id);
+  }
+  return ids;
+}
+var HELP2 = `docx comments delete \u2014 remove one or more comments
 
 Usage:
-  docx comments delete FILE --id cN [options]
+  docx comments delete FILE --id cN [--id cM ...] [options]
+  docx comments delete FILE --batch FILE.jsonl [options]
+  docx comments delete FILE --batch -    [options]   # JSONL from stdin
 
-Required:
-  --id ID           Comment id (e.g., c0)
+Anchor (one required, mutually exclusive):
+  --id ID             Comment id (e.g., c0). Repeat for multiple ids:
+                      --id c1 --id c3 --id c5. All ids are validated against
+                      the pre-mutation tree, so the batch is atomic.
+  --batch PATH        JSONL with one {"id": "cN"} per line. Use - for stdin.
 
 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
+  -o, --output PATH   Write to PATH instead of overwriting FILE
+  --dry-run           Print what would be removed; do not write the file
+  -v, --verbose       Print the success ack JSON (default: silent on success
+                      for single; batch always prints the removed ids)
+  -h, --help          Show this help
 
 Examples:
   docx comments delete doc.docx --id c2
+  docx comments delete doc.docx --id c1 --id c3 --id c7
+  docx comments delete doc.docx --batch removals.jsonl
 `;
 var init_delete = __esm(() => {
   init_core();
@@ -16255,6 +16935,7 @@ async function run4(args) {
         author: { type: "string" },
         output: { type: "string", short: "o" },
         "dry-run": { type: "boolean" },
+        verbose: { type: "boolean", short: "v" },
         help: { type: "boolean", short: "h" }
       }
     });
@@ -16266,6 +16947,7 @@ async function run4(args) {
     await writeStdout(HELP4);
     return EXIT.OK;
   }
+  setVerboseAck(Boolean(parsed.values.verbose));
   const path = parsed.positionals[0];
   if (!path)
     return fail("USAGE", "Missing FILE argument", HELP4);
@@ -16322,7 +17004,7 @@ async function run4(args) {
     "w15:done": "0"
   }));
   await saveDocView(view, outputPath);
-  await respond({
+  await respondAck({
     ok: true,
     operation: "comments.reply",
     path: outputPath ?? path,
@@ -16344,6 +17026,7 @@ 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
+  -v, --verbose     Print the success ack JSON (default: silent on success)
   -h, --help        Show this help
 
 Examples:
@@ -16370,10 +17053,12 @@ async function run5(args) {
       args,
       allowPositionals: true,
       options: {
-        id: { type: "string" },
+        id: { type: "string", multiple: true },
+        batch: { type: "string" },
         unset: { type: "boolean" },
         output: { type: "string", short: "o" },
         "dry-run": { type: "boolean" },
+        verbose: { type: "boolean", short: "v" },
         help: { type: "boolean", short: "h" }
       }
     });
@@ -16385,24 +17070,56 @@ async function run5(args) {
     await writeStdout(HELP5);
     return EXIT.OK;
   }
+  setVerboseAck(Boolean(parsed.values.verbose));
   const path = parsed.positionals[0];
   if (!path)
     return fail("USAGE", "Missing FILE argument", HELP5);
-  const idInput = parsed.values.id;
-  if (!idInput)
-    return fail("USAGE", "Missing --id COMMENT_ID", HELP5);
-  const numericId = idInput.startsWith("c") ? idInput.slice(1) : idInput;
+  const idsRaw = parsed.values.id ?? [];
+  const batchInput = parsed.values.batch;
   const resolved = !parsed.values.unset;
+  if (idsRaw.length > 0 && batchInput) {
+    return fail("USAGE", "--id and --batch are mutually exclusive", HELP5);
+  }
+  if (idsRaw.length === 0 && !batchInput) {
+    return fail("USAGE", "Specify --id cN (repeatable) or --batch FILE", HELP5);
+  }
+  let rawIds;
+  if (batchInput) {
+    try {
+      rawIds = await readJsonlIds2(batchInput);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return fail("USAGE", `Failed to read batch: ${message}`);
+    }
+    if (rawIds.length === 0) {
+      return fail("USAGE", "Batch file is empty");
+    }
+  } else {
+    rawIds = idsRaw;
+  }
+  const seen = new Set;
+  const ordered = [];
+  for (const raw of rawIds) {
+    const normalized = raw.startsWith("c") ? raw : `c${raw}`;
+    if (seen.has(normalized))
+      continue;
+    seen.add(normalized);
+    ordered.push(normalized);
+  }
   const view = await openOrFail(path);
   if (typeof view === "number")
     return view;
-  const commentReference = findCommentByNumericId(view, numericId);
-  if (!commentReference) {
-    return fail("COMMENT_NOT_FOUND", `Comment not found: c${numericId}`);
-  }
-  const paraId = ensureCommentParaId(view, idInput);
-  if (!paraId) {
-    return fail("COMMENT_NOT_FOUND", `Comment c${numericId} could not be assigned a w14:paraId.`);
+  const paraIdByCommentId = new Map;
+  for (const commentId of ordered) {
+    const numericId = commentId.slice(1);
+    if (!findCommentByNumericId(view, numericId)) {
+      return fail("COMMENT_NOT_FOUND", `Comment not found: ${commentId}`);
+    }
+    const paraId = ensureCommentParaId(view, commentId);
+    if (!paraId) {
+      return fail("COMMENT_NOT_FOUND", `Comment ${commentId} could not be assigned a w14:paraId.`);
+    }
+    paraIdByCommentId.set(commentId, paraId);
   }
   const outputPath = parsed.values.output;
   if (parsed.values["dry-run"]) {
@@ -16411,49 +17128,108 @@ async function run5(args) {
       operation: "comments.resolve",
       dryRun: true,
       path,
-      commentId: `c${numericId}`,
       resolved,
-      ...outputPath ? { output: outputPath } : {}
+      ...outputPath ? { output: outputPath } : {},
+      batch: ordered.map((commentId) => ({ commentId, resolved }))
     });
     return EXIT.OK;
   }
   const extRoot = ensureCommentsExtPart(view);
-  let entry = extRoot.children.find((child) => child.tag === "w15:commentEx" && child.getAttribute("w15:paraId") === paraId);
-  if (!entry) {
-    entry = new XmlNode2("w15:commentEx", { "w15:paraId": paraId });
-    extRoot.children.push(entry);
+  for (const commentId of ordered) {
+    const paraId = paraIdByCommentId.get(commentId);
+    if (!paraId) {
+      throw new Error(`internal: missing paraId for ${commentId}`);
+    }
+    let entry = extRoot.children.find((child) => child.tag === "w15:commentEx" && child.getAttribute("w15:paraId") === paraId);
+    if (!entry) {
+      entry = new XmlNode2("w15:commentEx", { "w15:paraId": paraId });
+      extRoot.children.push(entry);
+    }
+    if (resolved)
+      entry.setAttribute("w15:done", "1");
+    else
+      delete entry.attributes["w15:done"];
   }
-  if (resolved)
-    entry.setAttribute("w15:done", "1");
-  else
-    delete entry.attributes["w15:done"];
   await saveDocView(view, outputPath);
-  await respond({
-    ok: true,
-    operation: "comments.resolve",
-    path: outputPath ?? path,
-    commentId: `c${numericId}`,
-    resolved
-  });
+  if (batchInput || ordered.length > 1) {
+    await respond({
+      ok: true,
+      operation: "comments.resolve",
+      path: outputPath ?? path,
+      resolved,
+      batch: ordered.map((commentId) => ({ commentId, resolved }))
+    });
+  } else {
+    const single = ordered[0];
+    if (!single) {
+      throw new Error("internal: empty single-shot id list");
+    }
+    await respondAck({
+      ok: true,
+      operation: "comments.resolve",
+      path: outputPath ?? path,
+      commentId: single,
+      resolved
+    });
+  }
   return EXIT.OK;
 }
-var HELP5 = `docx comments resolve \u2014 mark a comment resolved
+async function readJsonlIds2(source) {
+  const raw = source === "-" ? await new Response(Bun.stdin.stream()).text() : await Bun.file(source).text();
+  const ids = [];
+  const lines = raw.split(`
+`);
+  for (let index = 0;index < lines.length; index++) {
+    const lineRaw = lines[index];
+    if (lineRaw === undefined)
+      continue;
+    const line = lineRaw.trim();
+    if (line.length === 0)
+      continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`line ${index + 1}: invalid JSON (${message})`);
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error(`line ${index + 1}: expected a JSON object`);
+    }
+    const entry = parsed;
+    if (typeof entry.id !== "string" || entry.id.length === 0) {
+      throw new Error(`line ${index + 1}: missing "id"`);
+    }
+    ids.push(entry.id);
+  }
+  return ids;
+}
+var HELP5 = `docx comments resolve \u2014 mark one or more comments resolved
 
 Usage:
-  docx comments resolve FILE --id cN [options]
+  docx comments resolve FILE --id cN [--id cM ...] [options]
+  docx comments resolve FILE --batch FILE.jsonl [options]
+  docx comments resolve FILE --batch -    [options]   # JSONL from stdin
 
-Required:
-  --id ID           Comment id (e.g., c0)
+Anchor (one required, mutually exclusive):
+  --id ID             Comment id (e.g., c0). Repeat for multiple ids:
+                      --id c1 --id c3 --id c5. All ids are validated against
+                      the pre-mutation tree, so the batch is atomic.
+  --batch PATH        JSONL with one {"id": "cN"} per line. Use - for stdin.
 
 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
+  --unset             Mark unresolved instead of resolved (applies to all
+                      ids in the batch)
+  -o, --output PATH   Write to PATH instead of overwriting FILE
+  --dry-run           Print what would change; do not write the file
+  -v, --verbose       Print the success ack JSON (default: silent on success
+                      for single; batch always prints the affected ids)
+  -h, --help          Show this help
 
 Examples:
   docx comments resolve doc.docx --id c2
-  docx comments resolve doc.docx --id c2 --unset
+  docx comments resolve doc.docx --id c1 --id c3 --unset
+  docx comments resolve doc.docx --batch resolutions.jsonl
 `;
 var init_resolve2 = __esm(() => {
   init_core();
@@ -16611,6 +17387,7 @@ async function run7(args) {
         author: { type: "string" },
         text: { type: "string" },
         force: { type: "boolean" },
+        verbose: { type: "boolean", short: "v" },
         help: { type: "boolean", short: "h" }
       }
     });
@@ -16621,6 +17398,7 @@ async function run7(args) {
     await writeStdout(HELP7);
     return EXIT.OK;
   }
+  setVerboseAck(Boolean(parsed.values.verbose));
   const path = parsed.positionals[0];
   if (!path) {
     return fail("USAGE", "Missing FILE argument", HELP7);
@@ -16644,7 +17422,7 @@ async function run7(args) {
     compressionOptions: { level: 6 }
   });
   await writeAtomic(path, buf);
-  await respond({
+  await respondAck({
     ok: true,
     operation: "create",
     path,
@@ -16663,6 +17441,7 @@ Options:
   --author TEXT    Document author (default: $DOCX_AUTHOR)
   --text TEXT      Seed first paragraph with this text
   --force          Overwrite if file exists
+  -v, --verbose    Print the success ack JSON (default: silent on success)
   -h, --help       Show this help
 
 Examples:
@@ -16683,18 +17462,27 @@ __export(exports_delete2, {
 });
 import { parseArgs as parseArgs7 } from "util";
 async function run8(args) {
+  const opts = await parseAndValidateOptions(args);
+  if (typeof opts === "number")
+    return opts;
+  const view = await openOrFail(opts.filePath);
+  if (typeof view === "number")
+    return view;
+  const blockRef = await resolveBlockOrFail(view, opts.locator);
+  if (typeof blockRef === "number")
+    return blockRef;
+  if (blockRef.node.tag === "w:sectPr") {
+    return commitSectionDelete(view, blockRef, opts);
+  }
+  return commitBlockDelete(view, blockRef, opts);
+}
+async function parseAndValidateOptions(args) {
   let parsed;
   try {
     parsed = parseArgs7({
       args,
       allowPositionals: true,
-      options: {
-        at: { type: "string" },
-        author: { type: "string" },
-        output: { type: "string", short: "o" },
-        "dry-run": { type: "boolean" },
-        help: { type: "boolean", short: "h" }
-      }
+      options: OPTION_SPEC
     });
   } catch (parseError) {
     const message = parseError instanceof Error ? parseError.message : String(parseError);
@@ -16704,51 +17492,89 @@ async function run8(args) {
     await writeStdout(HELP8);
     return EXIT.OK;
   }
-  const path = parsed.positionals[0];
-  if (!path)
+  setVerboseAck(Boolean(parsed.values.verbose));
+  const filePath = parsed.positionals[0];
+  if (!filePath)
     return fail("USAGE", "Missing FILE argument", HELP8);
-  const at = parsed.values.at;
-  if (!at)
+  const locator = parsed.values.at;
+  if (!locator)
     return fail("USAGE", "Missing --at LOCATOR", HELP8);
-  const view = await openOrFail(path);
-  if (typeof view === "number")
-    return view;
-  const blockRef = await resolveBlockOrFail(view, at);
-  if (typeof blockRef === "number")
-    return blockRef;
+  return {
+    filePath,
+    locator,
+    authorFlag: parsed.values.author,
+    outputPath: parsed.values.output,
+    dryRun: Boolean(parsed.values["dry-run"])
+  };
+}
+async function commitSectionDelete(view, blockRef, opts) {
+  const bodyChildren = findBodyChildren(view);
+  if (bodyChildren && isTrailingSectPr(bodyChildren, blockRef.parent)) {
+    return fail("USAGE", "Cannot delete the trailing section break (mandatory in OOXML)", "Use `docx edit --at sN --columns 1` to reset its properties instead.");
+  }
+  if (opts.dryRun)
+    return respondDryRun(opts);
+  const trackingOn = isTrackChangesEnabled(view);
+  const owningParagraph = trackingOn ? findContainingParagraph(view.documentTree, blockRef.node) : null;
+  const anchorRun = owningParagraph?.children.find((child) => child.tag === "w:r") ?? null;
+  removeInlineSectPr(blockRef.node, blockRef.parent);
+  if (trackingOn && owningParagraph && anchorRun) {
+    emitAuditComment(view, { kind: "run", paragraph: owningParagraph, run: anchorRun }, {
+      body: `[docx-cli] section break removed (${opts.locator})`,
+      author: resolveAuthor(opts.authorFlag),
+      date: resolveDate()
+    });
+  }
+  await saveDocView(view, opts.outputPath);
+  return emitDeleteAck(opts);
+}
+async function commitBlockDelete(view, blockRef, opts) {
   const targetIndex = blockRef.parent.indexOf(blockRef.node);
   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,
-      ...outputPath ? { output: outputPath } : {}
-    });
-    return EXIT.OK;
-  }
+  if (opts.dryRun)
+    return respondDryRun(opts);
   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, parsed.values.author);
+    applyTrackedDeletion(view, blockRef.node, opts.authorFlag);
   } else {
     blockRef.parent.splice(targetIndex, 1);
   }
-  await saveDocView(view, outputPath);
+  await saveDocView(view, opts.outputPath);
+  return emitDeleteAck(opts);
+}
+async function respondDryRun(opts) {
   await respond({
     ok: true,
     operation: "delete",
-    path: outputPath ?? path,
-    locator: at
+    dryRun: true,
+    path: opts.filePath,
+    locator: opts.locator,
+    ...opts.outputPath ? { output: opts.outputPath } : {}
+  });
+  return EXIT.OK;
+}
+async function emitDeleteAck(opts) {
+  await respondAck({
+    ok: true,
+    operation: "delete",
+    path: opts.outputPath ?? opts.filePath,
+    locator: opts.locator
   });
   return EXIT.OK;
 }
+function findBodyChildren(view) {
+  const root = XmlNode2.findRoot(view.documentTree, "w:document");
+  if (!root)
+    return null;
+  const body = root.findChild("w:body");
+  if (!body)
+    return null;
+  return body.children;
+}
 function applyTrackedDeletion(view, paragraph, authorFlag) {
   const allocator = createRevisionAllocator(view);
   const baseMeta = { author: resolveAuthor(authorFlag), date: resolveDate() };
@@ -16786,21 +17612,47 @@ Usage:
   docx delete FILE [options]
 
 Locator (required):
-  --at LOCATOR      Block to remove (e.g., p3, t0)
+  --at LOCATOR      Block to remove
+                    pN  paragraph (whole block, with all its runs)
+                    tN  table (entire table)
+                    sN  inline section break \u2014 strips the <w:sectPr> from
+                        its owning paragraph (the paragraph itself stays);
+                        rejects the trailing section break (mandatory in OOXML)
 
   --author NAME     Author for tracked changes (default: $DOCX_AUTHOR)
   -o, --output PATH Write to PATH instead of overwriting FILE
   --dry-run         Print what would be removed; do not write the file
+  -v, --verbose     Print the success ack JSON (default: silent on success)
   -h, --help        Show this help
 
+Tracked behavior:
+  When tracking is on, paragraph deletion wraps runs in <w:del> and marks
+  the paragraph mark as deleted (accept removes the paragraph by merging it
+  forward). Section deletion under tracking emits a [docx-cli] audit comment
+  on the owning paragraph if it has runs to anchor on; otherwise (sentinel
+  paragraphs from "insert --section" have no runs) the mutation is silent.
+  delete --at tN under tracking is rejected (tracked table-row deletion is
+  not supported).
+
 Examples:
   docx delete doc.docx --at p3
   docx delete doc.docx --at t0
-`;
+  docx delete doc.docx --at s2
+`, OPTION_SPEC;
 var init_delete2 = __esm(() => {
   init_core();
+  init_parser();
+  init_helpers();
   init_respond();
   init_jsx_dev_runtime();
+  OPTION_SPEC = {
+    at: { type: "string" },
+    author: { type: "string" },
+    output: { type: "string", short: "o" },
+    "dry-run": { type: "boolean" },
+    verbose: { type: "boolean", short: "v" },
+    help: { type: "boolean", short: "h" }
+  };
 });
 
 // src/cli/insert/emit.tsx
@@ -16920,32 +17772,399 @@ var init_emit2 = __esm(() => {
   ];
 });
 
-// src/cli/edit/index.tsx
-var exports_edit = {};
-__export(exports_edit, {
-  run: () => run9
-});
-import { parseArgs as parseArgs8 } from "util";
-async function run9(args) {
+// src/cli/edit/preserve-formatting.tsx
+function extractOldTokens(paragraph) {
+  let fullText = "";
+  const charToRpr = [];
+  function walk(node) {
+    for (const child of node.children) {
+      if (child.tag === "w:r") {
+        const segText = collectRunText(child);
+        if (segText.length === 0)
+          continue;
+        const rPr = child.findChild("w:rPr") ?? null;
+        fullText += segText;
+        for (let index = 0;index < segText.length; index++) {
+          charToRpr.push(rPr);
+        }
+        continue;
+      }
+      if (isAcceptedViewVisibleWrapper(child.tag)) {
+        walk(child);
+      }
+    }
+  }
+  walk(paragraph);
+  const tokenTexts = tokenize(fullText);
+  const tokens = [];
+  let offset = 0;
+  for (const text of tokenTexts) {
+    const rPrSource = charToRpr[offset] ?? null;
+    tokens.push({
+      text,
+      rPr: rPrSource ? rPrSource.clone() : null
+    });
+    offset += text.length;
+  }
+  return tokens;
+}
+function isAcceptedViewVisibleWrapper(tag) {
+  if (!isRunBearingWrapper(tag))
+    return false;
+  return tag !== "w:del" && tag !== "w:moveFrom";
+}
+function collectRunText(run9) {
+  let out = "";
+  for (const child of run9.children) {
+    if (child.tag === "w:t")
+      out += child.collectText();
+  }
+  return out;
+}
+function tokenize(text) {
+  if (text.length === 0)
+    return [];
+  return text.match(/\S+|\s+/g) ?? [];
+}
+function diffTokens(oldTokens, newTokens) {
+  const m = oldTokens.length;
+  const n = newTokens.length;
+  const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+  for (let i2 = 1;i2 <= m; i2++) {
+    for (let j2 = 1;j2 <= n; j2++) {
+      const oldText = oldTokens[i2 - 1]?.text;
+      const newText = newTokens[j2 - 1];
+      const left = dp[i2 - 1] ?? [];
+      const here = dp[i2] ?? [];
+      if (oldText === newText) {
+        here[j2] = (left[j2 - 1] ?? 0) + 1;
+      } else {
+        here[j2] = Math.max(left[j2] ?? 0, here[j2 - 1] ?? 0);
+      }
+    }
+  }
+  const ops = [];
+  let i = m;
+  let j = n;
+  while (i > 0 || j > 0) {
+    const oldToken = i > 0 ? oldTokens[i - 1] : undefined;
+    const newText = j > 0 ? newTokens[j - 1] : undefined;
+    if (i > 0 && j > 0 && oldToken !== undefined && oldToken.text === newText) {
+      ops.unshift({ kind: "keep", old: oldToken });
+      i--;
+      j--;
+      continue;
+    }
+    const upScore = i > 0 ? dp[i - 1]?.[j] ?? 0 : -1;
+    const leftScore = j > 0 ? dp[i]?.[j - 1] ?? 0 : -1;
+    if (j > 0 && newText !== undefined && (i === 0 || leftScore >= upScore)) {
+      ops.unshift({ kind: "insert", text: newText });
+      j--;
+      continue;
+    }
+    if (i > 0 && oldToken !== undefined) {
+      ops.unshift({ kind: "delete", old: oldToken });
+      i--;
+      continue;
+    }
+    break;
+  }
+  return consolidateEditGroups(demoteOrphanWhitespaceKeeps(ops));
+}
+function demoteOrphanWhitespaceKeeps(ops) {
+  const out = [];
+  for (let index = 0;index < ops.length; index++) {
+    const op = ops[index];
+    if (!op)
+      continue;
+    if (op.kind !== "keep") {
+      out.push(op);
+      continue;
+    }
+    if (!isWhitespaceOnly(op.old.text)) {
+      out.push(op);
+      continue;
+    }
+    const prev = ops[index - 1];
+    const next = ops[index + 1];
+    const prevIsEdit = prev !== undefined && prev.kind !== "keep";
+    const nextIsEdit = next !== undefined && next.kind !== "keep";
+    if (!prevIsEdit && !nextIsEdit) {
+      out.push(op);
+      continue;
+    }
+    out.push({ kind: "delete", old: op.old });
+    out.push({ kind: "insert", text: op.old.text });
+  }
+  return out;
+}
+function consolidateEditGroups(ops) {
+  const out = [];
+  let cursor = 0;
+  while (cursor < ops.length) {
+    const op = ops[cursor];
+    if (!op) {
+      cursor++;
+      continue;
+    }
+    if (op.kind === "keep") {
+      out.push(op);
+      cursor++;
+      continue;
+    }
+    const groupEnd = (() => {
+      let end = cursor;
+      while (end < ops.length) {
+        const candidate = ops[end];
+        if (!candidate || candidate.kind === "keep")
+          break;
+        end++;
+      }
+      return end;
+    })();
+    const deletes = [];
+    const inserts = [];
+    for (let index = cursor;index < groupEnd; index++) {
+      const groupOp = ops[index];
+      if (!groupOp)
+        continue;
+      if (groupOp.kind === "delete")
+        deletes.push(groupOp);
+      else if (groupOp.kind === "insert")
+        inserts.push(groupOp);
+    }
+    out.push(...deletes, ...inserts);
+    cursor = groupEnd;
+  }
+  return out;
+}
+function isWhitespaceOnly(text) {
+  return text.length > 0 && /^\s+$/.test(text);
+}
+function buildUntrackedRuns(ops) {
+  const flow = [];
+  for (let index = 0;index < ops.length; index++) {
+    const op = ops[index];
+    if (!op)
+      continue;
+    if (op.kind === "delete")
+      continue;
+    if (op.kind === "keep") {
+      flow.push({ text: op.old.text, rPr: cloneOrNull(op.old.rPr) });
+      continue;
+    }
+    const inherited = inheritedRprForInsert(ops, index);
+    flow.push({ text: op.text, rPr: cloneOrNull(inherited) });
+  }
+  return groupAndEmitPlainRuns(flow);
+}
+function inheritedRprForInsert(ops, index) {
+  let groupStart = index;
+  while (groupStart > 0) {
+    const prev = ops[groupStart - 1];
+    if (!prev || prev.kind === "keep")
+      break;
+    groupStart--;
+  }
+  let groupEnd = index;
+  while (groupEnd < ops.length - 1) {
+    const next = ops[groupEnd + 1];
+    if (!next || next.kind === "keep")
+      break;
+    groupEnd++;
+  }
+  const deletes = [];
+  let insertOrdinal = 0;
+  let myInsertOrdinal = -1;
+  for (let cursor = groupStart;cursor <= groupEnd; cursor++) {
+    const op = ops[cursor];
+    if (!op)
+      continue;
+    if (op.kind === "delete") {
+      deletes.push(op.old.rPr);
+      continue;
+    }
+    if (op.kind === "insert") {
+      if (cursor === index)
+        myInsertOrdinal = insertOrdinal;
+      insertOrdinal++;
+    }
+  }
+  if (deletes.length > 0 && myInsertOrdinal >= 0) {
+    const paired = myInsertOrdinal < deletes.length ? deletes[myInsertOrdinal] : deletes[deletes.length - 1];
+    if (paired !== undefined)
+      return paired;
+  }
+  for (let cursor = groupStart - 1;cursor >= 0; cursor--) {
+    const op = ops[cursor];
+    if (op?.kind === "keep")
+      return op.old.rPr;
+  }
+  for (let cursor = groupEnd + 1;cursor < ops.length; cursor++) {
+    const op = ops[cursor];
+    if (op?.kind === "keep")
+      return op.old.rPr;
+  }
+  return null;
+}
+function buildTrackedRuns(ops, mintMeta) {
+  const grouping = [];
+  for (let index = 0;index < ops.length; index++) {
+    const op = ops[index];
+    if (!op)
+      continue;
+    if (op.kind === "keep") {
+      pushOpTo(grouping, "keep", {
+        text: op.old.text,
+        rPr: cloneOrNull(op.old.rPr)
+      });
+      continue;
+    }
+    if (op.kind === "insert") {
+      const inherited = inheritedRprForInsert(ops, index);
+      pushOpTo(grouping, "insert", {
+        text: op.text,
+        rPr: cloneOrNull(inherited)
+      });
+      continue;
+    }
+    pushOpTo(grouping, "delete", {
+      text: op.old.text,
+      rPr: cloneOrNull(op.old.rPr)
+    });
+  }
+  const out = [];
+  for (const group of grouping) {
+    const runs = group.kind === "delete" ? groupAndEmitDeletedRuns(group.flow) : groupAndEmitPlainRuns(group.flow);
+    if (runs.length === 0)
+      continue;
+    if (group.kind === "keep") {
+      out.push(...runs);
+    } else if (group.kind === "insert") {
+      out.push(/* @__PURE__ */ jsxDEV(Ins, {
+        meta: mintMeta(),
+        children: runs
+      }, undefined, false, undefined, this));
+    } else {
+      out.push(/* @__PURE__ */ jsxDEV(Del, {
+        meta: mintMeta(),
+        children: runs
+      }, undefined, false, undefined, this));
+    }
+  }
+  return out;
+}
+function pushOpTo(grouping, kind, entry) {
+  const last = grouping[grouping.length - 1];
+  if (last && last.kind === kind) {
+    last.flow.push(entry);
+    return;
+  }
+  grouping.push({ kind, flow: [entry] });
+}
+function groupAndEmitPlainRuns(flow) {
+  const out = [];
+  let current = null;
+  for (const entry of flow) {
+    if (entry.text.length === 0)
+      continue;
+    if (current && rPrEqual(current.rPr, entry.rPr)) {
+      current.text += entry.text;
+      continue;
+    }
+    if (current)
+      out.push(emitPlainRun(current.text, current.rPr));
+    current = { text: entry.text, rPr: entry.rPr };
+  }
+  if (current)
+    out.push(emitPlainRun(current.text, current.rPr));
+  return out;
+}
+function groupAndEmitDeletedRuns(flow) {
+  const out = [];
+  let current = null;
+  for (const entry of flow) {
+    if (entry.text.length === 0)
+      continue;
+    if (current && rPrEqual(current.rPr, entry.rPr)) {
+      current.text += entry.text;
+      continue;
+    }
+    if (current)
+      out.push(emitDeletedRun(current.text, current.rPr));
+    current = { text: entry.text, rPr: entry.rPr };
+  }
+  if (current)
+    out.push(emitDeletedRun(current.text, current.rPr));
+  return out;
+}
+function emitPlainRun(text, rPr) {
+  return /* @__PURE__ */ jsxDEV(w.r, {
+    children: [
+      rPr,
+      /* @__PURE__ */ jsxDEV(w.t, {
+        "xml:space": "preserve",
+        children: text
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+function emitDeletedRun(text, rPr) {
+  return /* @__PURE__ */ jsxDEV(w.r, {
+    children: [
+      rPr,
+      /* @__PURE__ */ jsxDEV(w.delText, {
+        "xml:space": "preserve",
+        children: text
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+function cloneOrNull(node) {
+  return node ? node.clone() : null;
+}
+function rPrEqual(a2, b) {
+  if (a2 === null && b === null)
+    return true;
+  if (a2 === null || b === null)
+    return false;
+  return XmlNode2.serialize([a2]) === XmlNode2.serialize([b]);
+}
+var init_preserve_formatting = __esm(() => {
+  init_core();
+  init_jsx();
+  init_parser();
+  init_jsx_dev_runtime();
+});
+
+// src/cli/edit/index.tsx
+var exports_edit = {};
+__export(exports_edit, {
+  run: () => run9
+});
+import { parseArgs as parseArgs8 } from "util";
+async function run9(args) {
+  const opts = await parseAndValidateOptions2(args);
+  if (typeof opts === "number")
+    return opts;
+  const view = await openOrFail(opts.filePath);
+  if (typeof view === "number")
+    return view;
+  const blockRef = await resolveBlockOrFail(view, opts.locator);
+  if (typeof blockRef === "number")
+    return blockRef;
+  if (opts.spec.kind === "section") {
+    return commitSectionPropertyEdit(view, blockRef, opts.spec, opts);
+  }
+  return commitParagraphReplacement(view, blockRef, opts.spec, opts);
+}
+async function parseAndValidateOptions2(args) {
   let parsed;
   try {
     parsed = parseArgs8({
       args,
       allowPositionals: true,
-      options: {
-        at: { type: "string" },
-        text: { type: "string" },
-        runs: { type: "string" },
-        style: { type: "string" },
-        alignment: { type: "string" },
-        color: { type: "string" },
-        bold: { type: "boolean" },
-        italic: { type: "boolean" },
-        author: { type: "string" },
-        output: { type: "string", short: "o" },
-        "dry-run": { type: "boolean" },
-        help: { type: "boolean", short: "h" }
-      }
+      options: OPTION_SPEC2
     });
   } catch (parseError) {
     const message = parseError instanceof Error ? parseError.message : String(parseError);
@@ -16955,90 +18174,255 @@ async function run9(args) {
     await writeStdout(HELP9);
     return EXIT.OK;
   }
-  const path = parsed.positionals[0];
-  if (!path)
+  setVerboseAck(Boolean(parsed.values.verbose));
+  const filePath = parsed.positionals[0];
+  if (!filePath)
     return fail("USAGE", "Missing FILE argument", HELP9);
-  const at = parsed.values.at;
-  if (!at)
+  const locator = parsed.values.at;
+  if (!locator)
     return fail("USAGE", "Missing --at LOCATOR", HELP9);
-  const text = parsed.values.text;
-  const runsJson = parsed.values.runs;
+  const paragraphOptions = await parseParagraphOptions(parsed.values);
+  if (typeof paragraphOptions === "number")
+    return paragraphOptions;
+  const isSectionLocator = /^s\d+$/.test(locator);
+  const spec = isSectionLocator ? await validateSectionEdit(parsed.values) : await validateParagraphEdit(parsed.values, paragraphOptions);
+  if (typeof spec === "number")
+    return spec;
+  return {
+    filePath,
+    locator,
+    spec,
+    authorFlag: parsed.values.author,
+    outputPath: parsed.values.output,
+    dryRun: Boolean(parsed.values["dry-run"]),
+    noFormatting: Boolean(parsed.values["no-formatting"])
+  };
+}
+async function validateSectionEdit(values) {
+  if (values.text !== undefined || values.runs !== undefined) {
+    return fail("USAGE", "Section locators (sN) take --columns and --type, not --text/--runs", HELP9);
+  }
+  if (values.columns === undefined && values.type === undefined) {
+    return fail("USAGE", "Section edit requires --columns and/or --type", HELP9);
+  }
+  const sectionFlags = await parseSectionFlags(values);
+  if (typeof sectionFlags === "number")
+    return sectionFlags;
+  return { kind: "section", ...sectionFlags };
+}
+async function validateParagraphEdit(values, paragraphOptions) {
+  if (values.columns !== undefined || values.type !== undefined) {
+    return fail("USAGE", "--columns and --type require a section locator (sN)", HELP9);
+  }
+  const text = values.text;
+  const runsJson = values.runs;
   if (!text && !runsJson) {
     return fail("USAGE", "Missing content: pass --text or --runs", HELP9);
   }
   if (text && runsJson) {
     return fail("USAGE", "Pass either --text or --runs, not both", HELP9);
   }
-  const paragraphOptions = {};
-  const styleValue = parsed.values.style;
+  if (text !== undefined) {
+    return {
+      kind: "text",
+      text,
+      format: {
+        color: values.color,
+        bold: values.bold,
+        italic: values.italic
+      },
+      paragraphOptions
+    };
+  }
+  const runs = await parseRunsArg(runsJson);
+  if (typeof runs === "number")
+    return runs;
+  return { kind: "runs", runs, paragraphOptions };
+}
+async function parseSectionFlags(values) {
+  const out = {};
+  const columnsRaw = values.columns;
+  if (columnsRaw !== undefined) {
+    const columns = Number.parseInt(columnsRaw, 10);
+    if (!Number.isFinite(columns) || columns <= 0) {
+      return fail("USAGE", `--columns must be a positive integer, got "${columnsRaw}"`);
+    }
+    out.columns = columns;
+  }
+  const sectionTypeRaw = values.type;
+  if (sectionTypeRaw !== undefined) {
+    if (!isSectionType(sectionTypeRaw)) {
+      return fail("USAGE", `Invalid --type: ${sectionTypeRaw}`, "Valid values: continuous, nextPage, evenPage, oddPage, nextColumn");
+    }
+    out.sectionType = sectionTypeRaw;
+  }
+  return out;
+}
+async function parseRunsArg(json) {
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch (jsonError) {
+    const message = jsonError instanceof Error ? jsonError.message : String(jsonError);
+    return fail("USAGE", `Invalid --runs JSON: ${message}`);
+  }
+  if (!Array.isArray(parsed)) {
+    return fail("USAGE", "--runs must be a JSON array of Run objects");
+  }
+  return parsed;
+}
+async function parseParagraphOptions(values) {
+  const out = {};
+  const styleValue = values.style;
   if (styleValue)
-    paragraphOptions.style = styleValue;
-  const alignmentValue = parsed.values.alignment;
+    out.style = styleValue;
+  const alignmentValue = values.alignment;
   if (alignmentValue) {
     if (alignmentValue !== "left" && alignmentValue !== "center" && alignmentValue !== "right" && alignmentValue !== "justify") {
       return fail("USAGE", `Invalid --alignment: ${alignmentValue}`, "Valid values: left, center, right, justify");
     }
-    paragraphOptions.alignment = alignmentValue;
+    out.alignment = alignmentValue;
   }
-  const view = await openOrFail(path);
-  if (typeof view === "number")
-    return view;
-  const blockRef = await resolveBlockOrFail(view, at);
-  if (typeof blockRef === "number")
-    return blockRef;
-  let paragraphNode;
-  if (text !== undefined) {
-    const color = parsed.values.color;
-    paragraphNode = /* @__PURE__ */ jsxDEV(Paragraph, {
-      text,
-      ...paragraphOptions,
-      ...color ? { color } : {},
-      ...parsed.values.bold ? { bold: true } : {},
-      ...parsed.values.italic ? { italic: true } : {}
-    }, undefined, false, undefined, this);
-  } else {
-    let runsValue;
-    try {
-      runsValue = JSON.parse(runsJson);
-    } catch (jsonError) {
-      const message = jsonError instanceof Error ? jsonError.message : String(jsonError);
-      return fail("USAGE", `Invalid --runs JSON: ${message}`);
-    }
-    if (!Array.isArray(runsValue)) {
-      return fail("USAGE", "--runs must be a JSON array of Run objects");
-    }
-    paragraphNode = /* @__PURE__ */ jsxDEV(Paragraph, {
-      runs: runsValue,
-      ...paragraphOptions
-    }, undefined, false, undefined, this);
+  return out;
+}
+async function commitSectionPropertyEdit(view, blockRef, spec, opts) {
+  if (blockRef.node.tag !== "w:sectPr") {
+    return fail("BLOCK_NOT_FOUND", `Locator ${opts.locator} did not resolve to a section break`);
   }
+  if (opts.dryRun)
+    return respondDryRun2(opts);
+  if (isTrackChangesEnabled(view)) {
+    const allocator = createRevisionAllocator(view);
+    const meta = {
+      author: resolveAuthor(opts.authorFlag),
+      date: resolveDate(),
+      revisionId: allocator.next()
+    };
+    wrapSectPrChange(blockRef.node, meta);
+  }
+  applyColumns(blockRef.node, spec.columns);
+  applySectionType(blockRef.node, spec.sectionType);
+  await saveDocView(view, opts.outputPath);
+  return emitEditAck(opts);
+}
+async function commitParagraphReplacement(view, blockRef, spec, opts) {
   const targetIndex = blockRef.parent.indexOf(blockRef.node);
   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,
-      ...outputPath ? { output: outputPath } : {}
-    });
-    return EXIT.OK;
+  if (opts.dryRun)
+    return respondDryRun2(opts);
+  const tracked = isTrackChangesEnabled(view);
+  if (canPreserveFormatting(spec, opts)) {
+    applyFormattingPreservingEdit(view, blockRef.node, spec, opts.authorFlag, tracked);
+    await saveDocView(view, opts.outputPath);
+    return emitEditAck(opts);
+  }
+  const newParagraph = buildReplacementParagraph(spec);
+  if (tracked) {
+    applyTrackedEdit(view, blockRef.node, newParagraph, opts.authorFlag);
+  } else {
+    blockRef.parent.splice(targetIndex, 1, newParagraph);
   }
-  if (isTrackChangesEnabled(view)) {
-    applyTrackedEdit(view, blockRef.node, paragraphNode, parsed.values.author);
+  await saveDocView(view, opts.outputPath);
+  return emitEditAck(opts);
+}
+function canPreserveFormatting(spec, opts) {
+  if (opts.noFormatting)
+    return false;
+  if (spec.kind !== "text")
+    return false;
+  const format = spec.format;
+  if (format.color || format.bold || format.italic)
+    return false;
+  return true;
+}
+function applyFormattingPreservingEdit(view, existingParagraph, spec, authorFlag, tracked) {
+  const oldTokens = extractOldTokens(existingParagraph);
+  const newTokens = tokenize(spec.text);
+  const ops = diffTokens(oldTokens, newTokens);
+  let runChildren;
+  if (tracked) {
+    const allocator = createRevisionAllocator(view);
+    const baseMeta = { author: resolveAuthor(authorFlag), date: resolveDate() };
+    const mintMeta = () => ({
+      ...baseMeta,
+      revisionId: allocator.next()
+    });
+    runChildren = buildTrackedRuns(ops, mintMeta);
   } else {
-    blockRef.parent.splice(targetIndex, 1, paragraphNode);
+    runChildren = buildUntrackedRuns(ops);
   }
-  await saveDocView(view, outputPath);
+  const rebuilt = [];
+  for (const child of existingParagraph.children) {
+    if (child.tag === "w:r")
+      continue;
+    if (isRunBearingWrapper(child.tag))
+      continue;
+    rebuilt.push(child);
+  }
+  applyParagraphOptionsInPlace(rebuilt, spec.paragraphOptions);
+  rebuilt.push(...runChildren);
+  existingParagraph.children = rebuilt;
+}
+function applyParagraphOptionsInPlace(rebuilt, options) {
+  if (!options.style && !options.alignment)
+    return;
+  let pPr = rebuilt.find((child) => child.tag === "w:pPr");
+  if (!pPr) {
+    pPr = new XmlNode2("w:pPr");
+    rebuilt.unshift(pPr);
+  }
+  if (options.style) {
+    const existingStyle = pPr.findChild("w:pStyle");
+    if (existingStyle) {
+      existingStyle.setAttribute("w:val", options.style);
+    } else {
+      const styleNode = new XmlNode2("w:pStyle", { "w:val": options.style });
+      pPr.children.unshift(styleNode);
+    }
+  }
+  if (options.alignment) {
+    const existingJc = pPr.findChild("w:jc");
+    if (existingJc) {
+      existingJc.setAttribute("w:val", options.alignment);
+    } else {
+      pPr.children.push(new XmlNode2("w:jc", { "w:val": options.alignment }));
+    }
+  }
+}
+function buildReplacementParagraph(spec) {
+  if (spec.kind === "text") {
+    return /* @__PURE__ */ jsxDEV(Paragraph, {
+      text: spec.text,
+      ...spec.paragraphOptions,
+      ...spec.format.color ? { color: spec.format.color } : {},
+      ...spec.format.bold ? { bold: true } : {},
+      ...spec.format.italic ? { italic: true } : {}
+    }, undefined, false, undefined, this);
+  }
+  return /* @__PURE__ */ jsxDEV(Paragraph, {
+    runs: spec.runs,
+    ...spec.paragraphOptions
+  }, undefined, false, undefined, this);
+}
+async function respondDryRun2(opts) {
   await respond({
     ok: true,
     operation: "edit",
-    path: outputPath ?? path,
-    locator: at
+    dryRun: true,
+    path: opts.filePath,
+    locator: opts.locator,
+    ...opts.outputPath ? { output: opts.outputPath } : {}
+  });
+  return EXIT.OK;
+}
+async function emitEditAck(opts) {
+  await respondAck({
+    ok: true,
+    operation: "edit",
+    path: opts.outputPath ?? opts.filePath,
+    locator: opts.locator
   });
   return EXIT.OK;
 }
@@ -17052,10 +18436,15 @@ function applyTrackedEdit(view, existingParagraph, newParagraph, authorFlag) {
   const oldRuns = [];
   const oldNonRuns = [];
   for (const child of existingParagraph.children) {
-    if (child.tag === "w:r")
+    if (child.tag === "w:r") {
       oldRuns.push(child);
-    else
-      oldNonRuns.push(child);
+      continue;
+    }
+    if (isRunBearingWrapper(child.tag)) {
+      collectRunsFromWrapper(child, oldRuns);
+      continue;
+    }
+    oldNonRuns.push(child);
   }
   let newPPr = null;
   const newRuns = [];
@@ -17090,145 +18479,91 @@ function applyTrackedEdit(view, existingParagraph, newParagraph, authorFlag) {
   }
   existingParagraph.children = rebuilt;
 }
-var HELP9 = `docx edit \u2014 replace a paragraph at a locator
+function collectRunsFromWrapper(wrapper, out) {
+  for (const child of wrapper.children) {
+    if (child.tag === "w:r") {
+      out.push(child);
+      continue;
+    }
+    if (isRunBearingWrapper(child.tag)) {
+      collectRunsFromWrapper(child, out);
+    }
+  }
+}
+var HELP9 = `docx edit \u2014 replace a paragraph or modify a section at a locator
 
 Usage:
   docx edit FILE [options]
 
 Locator (required):
-  --at LOCATOR      Block to replace (e.g., p3)
+  --at LOCATOR      Block to edit (paragraph pN or section sN)
 
-Content (one required):
+Paragraph content (one required for paragraph locators):
   --text TEXT       Replace with a single-run paragraph
   --runs JSON       Replace with custom runs (Run[] JSON)
 
-Paragraph options:
-  --style NAME       Paragraph style (e.g., Heading1)
-  --alignment ALIGN  left | center | right | justify
-
-Run options (only with --text):
-  --color HEX       Run color, hex (e.g., 800080 for purple)
-  --bold            Bold
-  --italic          Italic
-
-  --author NAME     Author for tracked changes (default: $DOCX_AUTHOR)
-  -o, --output PATH Write to PATH instead of overwriting FILE
-  --dry-run         Print what would change; do not write the file
-  -h, --help        Show this help
-
-Examples:
-  docx edit doc.docx --at p3 --text "Replaced." --style Heading2
-  docx edit doc.docx --at p0 --runs '[{"type":"text","text":"X","bold":true}]'
-`;
-var init_edit = __esm(() => {
-  init_core();
-  init_emit2();
-  init_respond();
-  init_jsx_dev_runtime();
-});
-
-// src/core/find/index.ts
-function findTextSpans(doc, query, options = {}) {
-  const matcher = options.regex ? regexMatcher(query, options.ignoreCase ?? false) : literalMatcher(query, options.ignoreCase ?? false);
-  const out = [];
-  collectMatches(doc.blocks, matcher, out);
-  return out;
-}
-function literalMatcher(query, ignoreCase) {
-  if (query.length === 0) {
-    throw new Error("query cannot be empty");
-  }
-  const needle = ignoreCase ? query.toLowerCase() : query;
-  return (paragraphText2) => {
-    const haystack = ignoreCase ? paragraphText2.toLowerCase() : paragraphText2;
-    const matches = [];
-    let cursor = haystack.indexOf(needle);
-    while (cursor !== -1) {
-      matches.push({
-        start: cursor,
-        end: cursor + needle.length,
-        text: paragraphText2.slice(cursor, cursor + needle.length)
-      });
-      cursor = haystack.indexOf(needle, cursor + needle.length);
-    }
-    return matches;
-  };
-}
-function regexMatcher(pattern, ignoreCase) {
-  const flags = `g${ignoreCase ? "i" : ""}`;
-  const regex = new RegExp(pattern, flags);
-  return (paragraphText2) => {
-    const matches = [];
-    regex.lastIndex = 0;
-    let result = regex.exec(paragraphText2);
-    while (result !== null) {
-      const matched = result[0];
-      if (matched.length === 0) {
-        regex.lastIndex += 1;
-        result = regex.exec(paragraphText2);
-        continue;
-      }
-      matches.push({
-        start: result.index,
-        end: result.index + matched.length,
-        text: matched
-      });
-      result = regex.exec(paragraphText2);
-    }
-    return matches;
-  };
-}
-function collectMatches(blocks, matcher, out) {
-  for (const block of blocks) {
-    if (block.type === "paragraph") {
-      const paragraphText2 = block.runs.map((run10) => run10.type === "text" ? run10.text : "").join("");
-      for (const span of matcher(paragraphText2)) {
-        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;
-    }
-    if (block.type === "table") {
-      for (const row of block.rows) {
-        for (const cell of row.cells) {
-          collectMatches(cell.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;
-    if (seen.has(change.id))
-      continue;
-    seen.add(change.id);
-    out.push(change);
-  }
-  return out;
-}
-
+Paragraph options:
+  --style NAME       Paragraph style (e.g., Heading1)
+  --alignment ALIGN  left | center | right | justify
+
+Run options (only with --text):
+  --color HEX       Run color, hex (e.g., 800080 for purple)
+  --bold            Bold
+  --italic          Italic
+
+Section options (for section locators sN):
+  --columns N        Number of columns for the targeted section
+  --type T           continuous | nextPage | evenPage | oddPage | nextColumn
+
+Formatting (for --text):
+  By default --text preserves run-level formatting (bold/italic/color/etc.)
+  on words shared between the old and new text via a word-level diff. New
+  words inherit formatting from the nearest unchanged neighbor. Pass
+  --no-formatting to fall back to a single fresh run with no formatting.
+  Passing --color/--bold/--italic also bypasses preservation \u2014 those flags
+  apply uniformly to the new paragraph.
+
+General options:
+  --author NAME     Author for tracked changes (default: $DOCX_AUTHOR)
+  --no-formatting   Replace with a single fresh run; do not preserve rPr
+                    on unchanged words
+  -o, --output PATH Write to PATH instead of overwriting FILE
+  --dry-run         Print what would change; do not write the file
+  -v, --verbose     Print the success ack JSON (default: silent on success)
+  -h, --help        Show this help
+
+Examples:
+  docx edit doc.docx --at p3 --text "Replaced." --style Heading2
+  docx edit doc.docx --at p0 --runs '[{"type":"text","text":"X","bold":true}]'
+  docx edit doc.docx --at s0 --columns 2 --type continuous
+`, OPTION_SPEC2;
+var init_edit = __esm(() => {
+  init_core();
+  init_parser();
+  init_emit2();
+  init_respond();
+  init_preserve_formatting();
+  init_jsx_dev_runtime();
+  OPTION_SPEC2 = {
+    at: { type: "string" },
+    text: { type: "string" },
+    runs: { type: "string" },
+    columns: { type: "string" },
+    type: { type: "string" },
+    style: { type: "string" },
+    alignment: { type: "string" },
+    color: { type: "string" },
+    bold: { type: "boolean" },
+    italic: { type: "boolean" },
+    author: { type: "string" },
+    "no-formatting": { type: "boolean" },
+    output: { type: "string", short: "o" },
+    "dry-run": { type: "boolean" },
+    verbose: { type: "boolean", short: "v" },
+    help: { type: "boolean", short: "h" }
+  };
+});
+
 // src/cli/find/index.ts
 var exports_find = {};
 __export(exports_find, {
@@ -17246,6 +18581,9 @@ async function run10(args) {
         "ignore-case": { type: "boolean" },
         all: { type: "boolean" },
         nth: { type: "string" },
+        current: { type: "boolean" },
+        baseline: { type: "boolean" },
+        exact: { type: "boolean" },
         help: { type: "boolean", short: "h" }
       }
     });
@@ -17266,6 +18604,13 @@ async function run10(args) {
   const ignoreCase = Boolean(parsed.values["ignore-case"]);
   const useRegex = Boolean(parsed.values.regex);
   const wantAll = Boolean(parsed.values.all);
+  const wantCurrent = Boolean(parsed.values.current);
+  const wantBaseline = Boolean(parsed.values.baseline);
+  const exact = Boolean(parsed.values.exact);
+  if (wantCurrent && wantBaseline) {
+    return fail("USAGE", "--current and --baseline are mutually exclusive");
+  }
+  const findView = wantCurrent ? "current" : wantBaseline ? "baseline" : "accepted";
   const nthRaw = parsed.values.nth;
   const nth = nthRaw === undefined ? undefined : Number(nthRaw);
   if (nth !== undefined && (!Number.isInteger(nth) || nth < 0)) {
@@ -17274,16 +18619,19 @@ async function run10(args) {
   const view = await openOrFail(path);
   if (typeof view === "number")
     return view;
-  let allMatches;
+  let result;
   try {
-    allMatches = findTextSpans(view.doc, query, {
+    result = findTextSpans(view.doc, query, {
       regex: useRegex,
-      ignoreCase
+      ignoreCase,
+      view: findView,
+      exact
     });
   } catch (matcherError) {
     const message = matcherError instanceof Error ? matcherError.message : String(matcherError);
     return fail("USAGE", `Invalid query: ${message}`);
   }
+  const allMatches = result.matches;
   let selected;
   if (nth !== undefined) {
     const single = allMatches[nth];
@@ -17303,11 +18651,16 @@ async function run10(args) {
     query,
     regex: useRegex,
     ignoreCase,
+    view: findView,
     totalMatches: allMatches.length,
     matches: selected.map((match) => ({
       locator: `${match.blockId}:${match.start}-${match.end}`,
       ...match
-    }))
+    })),
+    ...result.normalizedQuery !== undefined ? {
+      normalizedQuery: result.normalizedQuery,
+      normalizationApplied: result.normalizationApplied
+    } : {}
   });
   return EXIT.OK;
 }
@@ -17324,6 +18677,12 @@ Options:
   --ignore-case     case-insensitive match
   --all             return every match (default: just the first)
   --nth N           return only the Nth match (0-indexed)
+  --current         search the raw concatenation (both ins and del text)
+  --baseline        search the pre-change text (skip ins/moveTo)
+                    default: accepted view (skip del/moveFrom) \u2014 matches
+                    "docx read --markdown" / "docx wc" / "docx comments add"
+  --exact           disable query normalization (no markdown-emphasis stripping,
+                    no smart/straight quote or em/en-dash equivalence)
   -h, --help        show this help
 
 Within-paragraph matches only \u2014 cross-paragraph ranges aren't supported
@@ -17331,6 +18690,11 @@ yet. Searches the concatenated text of each paragraph in document order,
 including paragraphs nested in table cells (locators look like
 tT:rRcC:pK:S-E for those).
 
+By default the query is normalized: balanced markdown emphasis around
+non-whitespace (**X**, __X__, *X*, \`X\`) is stripped; smart quotes match
+straight quotes; em-dash and en-dash match the hyphen. Pass --exact to
+match the raw query verbatim. --regex is always verbatim.
+
 Examples:
   docx find doc.docx "fox"
   docx find doc.docx "Action Item:" --all
@@ -17444,6 +18808,7 @@ async function run11(args) {
         author: { type: "string" },
         output: { type: "string", short: "o" },
         "dry-run": { type: "boolean" },
+        verbose: { type: "boolean", short: "v" },
         help: { type: "boolean", short: "h" }
       }
     });
@@ -17455,6 +18820,7 @@ async function run11(args) {
     await writeStdout(HELP11);
     return EXIT.OK;
   }
+  setVerboseAck(Boolean(parsed.values.verbose));
   const path = parsed.positionals[0];
   if (!path)
     return fail("USAGE", "Missing FILE argument", HELP11);
@@ -17518,7 +18884,7 @@ async function run11(args) {
     });
   }
   await saveDocView(view, outputPath);
-  await respond({
+  await respondAck({
     ok: true,
     operation: "hyperlinks.add",
     path: outputPath ?? path,
@@ -17543,6 +18909,7 @@ Optional:
                     (default: $DOCX_AUTHOR)
   -o, --output PATH Write to PATH instead of overwriting FILE
   --dry-run         Print what would change; do not write the file
+  -v, --verbose     Print the success ack JSON (default: silent on success)
   -h, --help        Show this help
 
 The span must lie inside a single paragraph and must not overlap an existing
@@ -17581,6 +18948,7 @@ async function run12(args) {
         author: { type: "string" },
         output: { type: "string", short: "o" },
         "dry-run": { type: "boolean" },
+        verbose: { type: "boolean", short: "v" },
         help: { type: "boolean", short: "h" }
       }
     });
@@ -17592,6 +18960,7 @@ async function run12(args) {
     await writeStdout(HELP12);
     return EXIT.OK;
   }
+  setVerboseAck(Boolean(parsed.values.verbose));
   const path = parsed.positionals[0];
   if (!path)
     return fail("USAGE", "Missing FILE argument", HELP12);
@@ -17643,7 +19012,7 @@ async function run12(args) {
     });
   }
   await saveDocView(view, outputPath);
-  await respond({
+  await respondAck({
     ok: true,
     operation: "hyperlinks.delete",
     path: outputPath ?? path,
@@ -17688,6 +19057,7 @@ Optional:
                     (default: $DOCX_AUTHOR)
   -o, --output PATH Write to PATH instead of overwriting FILE
   --dry-run         Print what would change; do not write the file
+  -v, --verbose     Print the success ack JSON (default: silent on success)
   -h, --help        Show this help
 
 The display text stays in place; only the <w:hyperlink> wrapper is removed.
@@ -17816,6 +19186,7 @@ async function run14(args) {
         author: { type: "string" },
         output: { type: "string", short: "o" },
         "dry-run": { type: "boolean" },
+        verbose: { type: "boolean", short: "v" },
         help: { type: "boolean", short: "h" }
       }
     });
@@ -17827,6 +19198,7 @@ async function run14(args) {
     await writeStdout(HELP14);
     return EXIT.OK;
   }
+  setVerboseAck(Boolean(parsed.values.verbose));
   const path = parsed.positionals[0];
   if (!path)
     return fail("USAGE", "Missing FILE argument", HELP14);
@@ -17887,7 +19259,7 @@ async function run14(args) {
     }
   }
   await saveDocView(view, outputPath);
-  await respond({
+  await respondAck({
     ok: true,
     operation: "hyperlinks.replace",
     path: outputPath ?? path,
@@ -17938,6 +19310,7 @@ Optional:
                     (default: $DOCX_AUTHOR)
   -o, --output PATH Write to PATH instead of overwriting FILE
   --dry-run         Print what would change; do not write the file
+  -v, --verbose     Print the success ack JSON (default: silent on success)
   -h, --help        Show this help
 
 Replaces only the targeted hyperlink. If multiple hyperlinks shared the same
@@ -18217,6 +19590,7 @@ async function run18(args) {
         author: { type: "string" },
         output: { type: "string", short: "o" },
         "dry-run": { type: "boolean" },
+        verbose: { type: "boolean", short: "v" },
         help: { type: "boolean", short: "h" }
       }
     });
@@ -18228,6 +19602,7 @@ async function run18(args) {
     await writeStdout(HELP18);
     return EXIT.OK;
   }
+  setVerboseAck(Boolean(parsed.values.verbose));
   const path = parsed.positionals[0];
   if (!path)
     return fail("USAGE", "Missing FILE argument", HELP18);
@@ -18294,7 +19669,7 @@ async function run18(args) {
     }
   }
   await saveDocView(view, outputPath);
-  await respond({
+  await respondAck({
     ok: true,
     operation: "images.replace",
     path: outputPath ?? path,
@@ -18382,6 +19757,7 @@ Optional:
                     (default: $DOCX_AUTHOR)
   -o, --output PATH Write to PATH instead of overwriting FILE
   --dry-run         Print what would change; do not write the file
+  -v, --verbose     Print the success ack JSON (default: silent on success)
   -h, --help        Show this help
 
 If the replacement uses a different format from the original, the part is
@@ -18500,8 +19876,17 @@ export type TableCell = {
 export type SectionBreak = {
 	id: string;
 	type: "sectionBreak";
+	columns?: number;
+	sectionType?: SectionType;
 };
 
+export type SectionType =
+	| "continuous"
+	| "nextPage"
+	| "evenPage"
+	| "oddPage"
+	| "nextColumn";
+
 export type Run =
 	| TextRun
 	| ImageRun
@@ -18598,8 +19983,17 @@ export type TrackedChange = {
  *    of a tracked move. moveFrom behaves like a delete (text leaves this
  *    location, stored as <w:delText> internally); moveTo behaves like an
  *    insert (text arrives at this location).
+ *  - \`sectPrChange\`: <w:sectPrChange> \u2014 section-property revision marker
+ *    embedded inside a <w:sectPr>. Carries a snapshot of the prior section
+ *    properties (e.g. columns / type) so accept/reject can drop or restore
+ *    them. Has no run text.
  */
-export type TrackedChangeKind = "ins" | "del" | "moveFrom" | "moveTo";
+export type TrackedChangeKind =
+	| "ins"
+	| "del"
+	| "moveFrom"
+	| "moveTo"
+	| "sectPrChange";
 
 export type Comment = {
 	id: string;
@@ -18760,7 +20154,9 @@ var init_schema = __esm(() => {
             required: ["id", "kind", "author", "date", "revisionId"],
             properties: {
               id: { type: "string" },
-              kind: { enum: ["ins", "del", "moveFrom", "moveTo"] },
+              kind: {
+                enum: ["ins", "del", "moveFrom", "moveTo"]
+              },
               author: { type: "string" },
               date: { type: "string" },
               revisionId: { type: "string" }
@@ -18872,7 +20268,11 @@ var init_schema = __esm(() => {
         required: ["id", "type"],
         properties: {
           id: { type: "string" },
-          type: { const: "sectionBreak" }
+          type: { const: "sectionBreak" },
+          columns: { type: "number" },
+          sectionType: {
+            enum: ["continuous", "nextPage", "evenPage", "oddPage", "nextColumn"]
+          }
         }
       },
       Comment: {
@@ -18967,13 +20367,17 @@ Entity locators:
   imgN            Image id (e.g., img2)
   linkN           Hyperlink id (e.g., link0)
   tcN             Tracked change id (e.g., tc0) \u2014 the Nth revision wrapper
-                  (<w:ins>/<w:del>/<w:moveFrom>/<w:moveTo>) in document order
+                  in document order. Includes run-level <w:ins>/<w:del>/
+                  <w:moveFrom>/<w:moveTo>, section-property revisions
+                  <w:sectPrChange>, and paragraph-mark <w:ins>/<w:del>
+                  (a self-closing element inside <w:pPr><w:rPr>).
   tN:rRcC         Cell at row R, column C of table tN
 
 Examples:
   p3              -> the entire paragraph p3
   p3:5-20         -> characters 5..20 of p3
   p3:5-p5:10      -> from char 5 of p3 to char 10 of p5
+  s0              -> first section break (typically the front-matter section)
   c1              -> comment c1
   img0            -> image img0
   link0           -> hyperlink link0
@@ -19011,7 +20415,11 @@ var init_locators2 = __esm(() => {
       comment: { syntax: "cN", example: "c1" },
       image: { syntax: "imgN", example: "img0" },
       hyperlink: { syntax: "linkN", example: "link0" },
-      trackedChange: { syntax: "tcN", example: "tc0" },
+      trackedChange: {
+        syntax: "tcN",
+        example: "tc0",
+        notes: "Covers run-level <w:ins>/<w:del>/<w:moveFrom>/<w:moveTo>, <w:sectPrChange>, and paragraph-mark <w:ins>/<w:del>."
+      },
       cell: { syntax: "tN:rRcC", example: "t0:r1c2" },
       nestedCell: { syntax: "tN:rRcC:pK", example: "t0:r1c2:p0" }
     },
@@ -19067,27 +20475,25 @@ __export(exports_insert, {
 });
 import { parseArgs as parseArgs19 } from "util";
 async function run23(args) {
+  const opts = await parseAndValidateOptions3(args);
+  if (typeof opts === "number")
+    return opts;
+  const view = await openOrFail(opts.filePath);
+  if (typeof view === "number")
+    return view;
+  const blockRef = await resolveBlockOrFail(view, opts.placement.locator);
+  if (typeof blockRef === "number")
+    return blockRef;
+  const paragraph = buildInsertedParagraph(view, opts.spec, opts.paragraphOptions);
+  return commitInsertedParagraph(view, blockRef, paragraph, opts);
+}
+async function parseAndValidateOptions3(args) {
   let parsed;
   try {
     parsed = parseArgs19({
       args,
       allowPositionals: true,
-      options: {
-        after: { type: "string" },
-        before: { type: "string" },
-        text: { type: "string" },
-        runs: { type: "string" },
-        style: { type: "string" },
-        alignment: { type: "string" },
-        color: { type: "string" },
-        bold: { type: "boolean" },
-        italic: { type: "boolean" },
-        url: { type: "string" },
-        author: { type: "string" },
-        output: { type: "string", short: "o" },
-        "dry-run": { type: "boolean" },
-        help: { type: "boolean", short: "h" }
-      }
+      options: OPTION_SPEC3
     });
   } catch (parseError) {
     const message = parseError instanceof Error ? parseError.message : String(parseError);
@@ -19097,104 +20503,200 @@ async function run23(args) {
     await writeStdout(HELP23);
     return EXIT.OK;
   }
-  const path = parsed.positionals[0];
-  if (!path)
+  setVerboseAck(Boolean(parsed.values.verbose));
+  const filePath = parsed.positionals[0];
+  if (!filePath)
     return fail("USAGE", "Missing FILE argument", HELP23);
-  const after = parsed.values.after;
-  const before = parsed.values.before;
+  const placement = await parseTargetPlacement(parsed.values);
+  if (typeof placement === "number")
+    return placement;
+  const spec = await chooseContentSpec(parsed.values);
+  if (typeof spec === "number")
+    return spec;
+  const paragraphOptions = await parseParagraphOptions2(parsed.values);
+  if (typeof paragraphOptions === "number")
+    return paragraphOptions;
+  return {
+    filePath,
+    placement,
+    spec,
+    paragraphOptions,
+    authorFlag: parsed.values.author,
+    outputPath: parsed.values.output,
+    dryRun: Boolean(parsed.values["dry-run"])
+  };
+}
+async function parseTargetPlacement(values) {
+  const after = values.after;
+  const before = values.before;
   if (!after && !before) {
     return fail("USAGE", "Missing locator: pass --after or --before", HELP23);
   }
   if (after && before) {
     return fail("USAGE", "Pass either --after or --before, not both", HELP23);
   }
-  const text = parsed.values.text;
-  const runsJson = parsed.values.runs;
-  const url = parsed.values.url;
-  if (!text && !runsJson) {
-    return fail("USAGE", "Missing content: pass --text or --runs", HELP23);
+  if (after !== undefined)
+    return { mode: "after", locator: after };
+  return { mode: "before", locator: before };
+}
+async function chooseContentSpec(values) {
+  const text = values.text;
+  const runsJson = values.runs;
+  const url = values.url;
+  const pageBreak = values["page-break"] ?? false;
+  const columnBreak = values["column-break"] ?? false;
+  const sectionFlag = values.section ?? false;
+  const columnsRaw = values.columns;
+  const sectionTypeRaw = values.type;
+  const contentFlagCount = (text !== undefined ? 1 : 0) + (runsJson !== undefined ? 1 : 0) + (pageBreak ? 1 : 0) + (columnBreak ? 1 : 0) + (sectionFlag ? 1 : 0);
+  if (contentFlagCount === 0) {
+    return fail("USAGE", "Missing content: pass --text, --runs, --page-break, --column-break, or --section", HELP23);
+  }
+  if (contentFlagCount > 1) {
+    return fail("USAGE", "Pass only one of --text, --runs, --page-break, --column-break, --section", HELP23);
+  }
+  if (url !== undefined && text === undefined) {
+    return fail("USAGE", "--url requires --text", HELP23);
   }
-  if (text && runsJson) {
-    return fail("USAGE", "Pass either --text or --runs, not both", HELP23);
+  if ((columnsRaw !== undefined || sectionTypeRaw !== undefined) && !sectionFlag) {
+    return fail("USAGE", "--columns and --type require --section", HELP23);
   }
-  if (url && !text) {
-    return fail("USAGE", "--url requires --text", HELP23);
+  if (text !== undefined) {
+    return {
+      kind: "text",
+      text,
+      format: {
+        color: values.color,
+        bold: values.bold,
+        italic: values.italic
+      },
+      ...url ? { hyperlinkUrl: url } : {}
+    };
+  }
+  if (runsJson !== undefined) {
+    const runs = await parseRunsArg2(runsJson);
+    if (typeof runs === "number")
+      return runs;
+    return { kind: "runs", runs };
+  }
+  if (pageBreak)
+    return { kind: "break", breakKind: "page" };
+  if (columnBreak)
+    return { kind: "break", breakKind: "column" };
+  const sectionFlags = await parseSectionFlags2(values);
+  if (typeof sectionFlags === "number")
+    return sectionFlags;
+  return { kind: "section", ...sectionFlags };
+}
+async function parseRunsArg2(json) {
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch (jsonError) {
+    const message = jsonError instanceof Error ? jsonError.message : String(jsonError);
+    return fail("USAGE", `Invalid --runs JSON: ${message}`);
+  }
+  if (!Array.isArray(parsed)) {
+    return fail("USAGE", "--runs must be a JSON array of Run objects");
+  }
+  return parsed;
+}
+async function parseSectionFlags2(values) {
+  const out = {};
+  const columnsRaw = values.columns;
+  if (columnsRaw !== undefined) {
+    const columns = Number.parseInt(columnsRaw, 10);
+    if (!Number.isFinite(columns) || columns <= 0) {
+      return fail("USAGE", `--columns must be a positive integer, got "${columnsRaw}"`);
+    }
+    out.columns = columns;
+  }
+  const sectionTypeRaw = values.type;
+  if (sectionTypeRaw !== undefined) {
+    if (!isSectionType(sectionTypeRaw)) {
+      return fail("USAGE", `Invalid --type: ${sectionTypeRaw}`, "Valid values: continuous, nextPage, evenPage, oddPage, nextColumn");
+    }
+    out.sectionType = sectionTypeRaw;
   }
-  const paragraphOptions = {};
-  const styleValue = parsed.values.style;
+  return out;
+}
+async function parseParagraphOptions2(values) {
+  const out = {};
+  const styleValue = values.style;
   if (styleValue)
-    paragraphOptions.style = styleValue;
-  const alignmentValue = parsed.values.alignment;
+    out.style = styleValue;
+  const alignmentValue = values.alignment;
   if (alignmentValue) {
     if (alignmentValue !== "left" && alignmentValue !== "center" && alignmentValue !== "right" && alignmentValue !== "justify") {
       return fail("USAGE", `Invalid --alignment: ${alignmentValue}`, "Valid values: left, center, right, justify");
     }
-    paragraphOptions.alignment = alignmentValue;
+    out.alignment = alignmentValue;
   }
-  const view = await openOrFail(path);
-  if (typeof view === "number")
-    return view;
-  const targetLocator = after ?? before;
-  const blockRef = await resolveBlockOrFail(view, targetLocator);
-  if (typeof blockRef === "number")
-    return blockRef;
-  let paragraphNode;
-  if (text !== undefined) {
-    const color = parsed.values.color;
-    paragraphNode = /* @__PURE__ */ jsxDEV(Paragraph, {
-      text,
-      ...paragraphOptions,
-      ...color ? { color } : {},
-      ...parsed.values.bold ? { bold: true } : {},
-      ...parsed.values.italic ? { italic: true } : {}
-    }, undefined, false, undefined, this);
-    if (url)
-      wrapFirstRunInHyperlink(view, paragraphNode, url);
-  } else {
-    let runsValue;
-    try {
-      runsValue = JSON.parse(runsJson);
-    } catch (jsonError) {
-      const message = jsonError instanceof Error ? jsonError.message : String(jsonError);
-      return fail("USAGE", `Invalid --runs JSON: ${message}`);
-    }
-    if (!Array.isArray(runsValue)) {
-      return fail("USAGE", "--runs must be a JSON array of Run objects");
-    }
-    paragraphNode = /* @__PURE__ */ jsxDEV(Paragraph, {
-      runs: runsValue,
-      ...paragraphOptions
-    }, undefined, false, undefined, this);
+  return out;
+}
+function buildInsertedParagraph(view, spec, paragraphOptions) {
+  switch (spec.kind) {
+    case "text":
+      return buildTextParagraph(view, spec, paragraphOptions);
+    case "runs":
+      return /* @__PURE__ */ jsxDEV(Paragraph, {
+        runs: spec.runs,
+        ...paragraphOptions
+      }, undefined, false, undefined, this);
+    case "break":
+      return /* @__PURE__ */ jsxDEV(Paragraph, {
+        runs: [{ type: "break", kind: spec.breakKind }],
+        ...paragraphOptions
+      }, undefined, false, undefined, this);
+    case "section":
+      return /* @__PURE__ */ jsxDEV(SentinelSectionParagraph, {
+        ...spec.columns !== undefined ? { columns: spec.columns } : {},
+        ...spec.sectionType ? { sectionType: spec.sectionType } : {}
+      }, undefined, false, undefined, this);
+  }
+}
+function buildTextParagraph(view, spec, paragraphOptions) {
+  const paragraphNode = /* @__PURE__ */ jsxDEV(Paragraph, {
+    text: spec.text,
+    ...paragraphOptions,
+    ...spec.format.color ? { color: spec.format.color } : {},
+    ...spec.format.bold ? { bold: true } : {},
+    ...spec.format.italic ? { italic: true } : {}
+  }, undefined, false, undefined, this);
+  if (spec.hyperlinkUrl) {
+    wrapFirstRunInHyperlink(view, paragraphNode, spec.hyperlinkUrl);
   }
+  return paragraphNode;
+}
+async function commitInsertedParagraph(view, blockRef, paragraph, opts) {
   const targetIndex = blockRef.parent.indexOf(blockRef.node);
   if (targetIndex === -1) {
     return fail("BLOCK_NOT_FOUND", "Block reference is stale (parent does not contain it)");
   }
-  const insertIndex = after !== undefined ? targetIndex + 1 : targetIndex;
+  const insertIndex = opts.placement.mode === "after" ? targetIndex + 1 : targetIndex;
   if (isTrackChangesEnabled(view)) {
-    applyTrackedInsertion(paragraphNode, view, parsed.values.author);
+    applyTrackedInsertion(paragraph, view, opts.authorFlag);
   }
-  const outputPath = parsed.values.output;
-  if (parsed.values["dry-run"]) {
+  if (opts.dryRun) {
     await respond({
       ok: true,
       operation: "insert",
       dryRun: true,
-      path,
-      locator: targetLocator,
-      placement: after !== undefined ? "after" : "before",
-      ...outputPath ? { output: outputPath } : {}
+      path: opts.filePath,
+      locator: opts.placement.locator,
+      placement: opts.placement.mode,
+      ...opts.outputPath ? { output: opts.outputPath } : {}
     });
     return EXIT.OK;
   }
-  blockRef.parent.splice(insertIndex, 0, paragraphNode);
-  await saveDocView(view, outputPath);
-  await respond({
+  blockRef.parent.splice(insertIndex, 0, paragraph);
+  await saveDocView(view, opts.outputPath);
+  await respondAck({
     ok: true,
     operation: "insert",
-    path: outputPath ?? path,
-    locator: targetLocator,
-    placement: after !== undefined ? "after" : "before"
+    path: opts.outputPath ?? opts.filePath,
+    locator: opts.placement.locator,
+    placement: opts.placement.mode
   });
   return EXIT.OK;
 }
@@ -19263,6 +20765,9 @@ Locator (one required):
 Content (one required):
   --text TEXT       Insert a paragraph with this text
   --runs JSON       Insert a paragraph with custom runs (Run[] JSON)
+  --page-break      Insert an empty paragraph containing a page break
+  --column-break    Insert an empty paragraph containing a column break
+  --section         Insert a section boundary (sentinel paragraph w/ inline sectPr)
 
 Paragraph options:
   --style NAME       Apply paragraph style (e.g., Heading1)
@@ -19274,9 +20779,15 @@ Run options (only with --text):
   --italic          Italic
   --url URL         Wrap the inserted text in a hyperlink to URL
 
+Section options (only with --section):
+  --columns N       Number of columns for the section ending at this boundary
+  --type T          continuous | nextPage | evenPage | oddPage | nextColumn
+
+General options:
   --author NAME     Author for tracked changes (default: $DOCX_AUTHOR)
   -o, --output PATH Write to PATH instead of overwriting FILE
   --dry-run         Print what would be inserted; do not write the file
+  -v, --verbose     Print the success ack JSON (default: silent on success)
   -h, --help        Show this help
 
 Examples:
@@ -19284,7 +20795,9 @@ Examples:
   docx insert doc.docx --before p0 --text "ALERT" --color CC0000 --bold
   docx insert doc.docx --after p2 --runs '[{"type":"text","text":"X","bold":true}]'
   docx insert doc.docx --after p3 --text "click here" --url https://example.com
-`;
+  docx insert doc.docx --after p3 --page-break
+  docx insert doc.docx --after p9 --section --columns 2 --type continuous
+`, OPTION_SPEC3;
 var init_insert = __esm(() => {
   init_core();
   init_jsx();
@@ -19292,6 +20805,28 @@ var init_insert = __esm(() => {
   init_respond();
   init_emit2();
   init_jsx_dev_runtime();
+  OPTION_SPEC3 = {
+    after: { type: "string" },
+    before: { type: "string" },
+    text: { type: "string" },
+    runs: { type: "string" },
+    "page-break": { type: "boolean" },
+    "column-break": { type: "boolean" },
+    section: { type: "boolean" },
+    columns: { type: "string" },
+    type: { type: "string" },
+    style: { type: "string" },
+    alignment: { type: "string" },
+    color: { type: "string" },
+    bold: { type: "boolean" },
+    italic: { type: "boolean" },
+    url: { type: "string" },
+    author: { type: "string" },
+    output: { type: "string", short: "o" },
+    "dry-run": { type: "boolean" },
+    verbose: { type: "boolean", short: "v" },
+    help: { type: "boolean", short: "h" }
+  };
 });
 
 // src/cli/outline/build.ts
@@ -19485,7 +21020,7 @@ function isRunVisible(run25, view) {
   return true;
 }
 function buildCommentIndex(blocks, options) {
-  const view = options.view ?? "current";
+  const view = options.view ?? "accepted";
   const lastSlot = new Map;
   const spanText = new Map;
   const orderedIds = [];
@@ -19557,7 +21092,7 @@ function headingLevelFor(style) {
   return parsed;
 }
 function renderRuns(paragraphId, runs, ctx) {
-  const view = ctx.options.view ?? "current";
+  const view = ctx.options.view ?? "accepted";
   const visibleEntries = [];
   runs.forEach((run25, index) => {
     if (run25.type === "text" && !isRunVisible(run25, view))
@@ -19915,6 +21450,7 @@ async function run25(args) {
         to: { type: "string" },
         accepted: { type: "boolean" },
         baseline: { type: "boolean" },
+        current: { type: "boolean" },
         comments: { type: "boolean" },
         help: { type: "boolean", short: "h" }
       }
@@ -19934,14 +21470,16 @@ async function run25(args) {
   const to = parsed.values.to;
   const accepted = Boolean(parsed.values.accepted);
   const baseline = Boolean(parsed.values.baseline);
+  const current = Boolean(parsed.values.current);
   const showComments = Boolean(parsed.values.comments);
-  if (!markdown && (from || to || accepted || baseline || showComments)) {
-    return fail("USAGE", "--from, --to, --accepted, --baseline, and --comments require --markdown", HELP25);
+  if (!markdown && (from || to || accepted || baseline || current || showComments)) {
+    return fail("USAGE", "--from, --to, --accepted, --baseline, --current, and --comments require --markdown", HELP25);
   }
-  if (accepted && baseline) {
-    return fail("USAGE", "--accepted and --baseline are mutually exclusive", HELP25);
+  const viewFlagCount = (accepted ? 1 : 0) + (baseline ? 1 : 0) + (current ? 1 : 0);
+  if (viewFlagCount > 1) {
+    return fail("USAGE", "--accepted, --baseline, and --current are mutually exclusive", HELP25);
   }
-  const view = accepted ? "accepted" : baseline ? "baseline" : "current";
+  const view = current ? "current" : baseline ? "baseline" : "accepted";
   const docView = await openOrFail(path);
   if (typeof docView === "number")
     return docView;
@@ -19982,18 +21520,19 @@ Options:
                     Accepts pN, tN, tN:rRcC[:pK[:S-E]], pN:S-E, pN:S-pM:E.
                     Cell/span/range locators collapse to their enclosing
                     top-level block (the table or paragraph).
-  --accepted        With --markdown, render the post-accept view: drop
-                    subtractive wrappers (<w:del>, <w:moveFrom>), inline
+  --accepted        Default with --markdown: render the post-accept view \u2014
+                    drop subtractive wrappers (<w:del>, <w:moveFrom>), inline
                     additive wrappers (<w:ins>, <w:moveTo>) as plain text,
-                    no markers/refs.
+                    no markers/refs. Kept as an explicit alias for clarity.
   --baseline        With --markdown, render the pre-change view: drop
                     additive wrappers (<w:ins>, <w:moveTo>), inline
                     subtractive wrappers (<w:del>, <w:moveFrom>) as plain
-                    text, no markers/refs. Mutually exclusive with --accepted.
-                    Default --markdown shows all four: additive wrappers as
-                    {++text++}[^tcN] and subtractive as {--text--}[^tcN]
-                    (CriticMarkup); the [^tcN] footnote spells out the kind
-                    (insertion / deletion / moveTo / moveFrom).
+                    text, no markers/refs.
+  --current         With --markdown, render the raw concatenation: additive
+                    wrappers as {++text++}[^tcN] and subtractive as
+                    {--text--}[^tcN] (CriticMarkup); the [^tcN] footnote
+                    spells out the kind (insertion / deletion / moveTo /
+                    moveFrom). Mutually exclusive with --accepted/--baseline.
   --comments        With --markdown, append [^cN] after each commented span
                     and emit a footnote definition for each comment at the
                     end of the output (author, date, body).
@@ -20014,11 +21553,33 @@ var init_read2 = __esm(() => {
 });
 
 // src/cli/replace/replace-span.tsx
-function replaceSpanInParagraph(paragraph, span, replacement, tracked) {
+function isWrapperVisibleInView2(tag, view) {
+  if (!isRunBearingWrapper(tag))
+    return false;
+  if (view === "current")
+    return true;
+  if (view === "accepted")
+    return tag !== "w:del" && tag !== "w:moveFrom";
+  return tag !== "w:ins" && tag !== "w:moveTo";
+}
+function sumVisibleTextLength2(children, view) {
+  let total = 0;
+  for (const child of children) {
+    if (child.tag === "w:r") {
+      total += runTextLength(child);
+      continue;
+    }
+    if (isWrapperVisibleInView2(child.tag, view)) {
+      total += sumVisibleTextLength2(child.children, view);
+    }
+  }
+  return total;
+}
+function replaceSpanInParagraph(paragraph, span, replacement, tracked, view = "accepted") {
   if (span.start > span.end) {
     throw new Error(`replaceSpanInParagraph: invalid span ${span.start}-${span.end}`);
   }
-  const slots = collectRunSlots(paragraph);
+  const slots = collectRunSlots(paragraph, view);
   const overlapping = slots.filter((slot) => slot.offsetBefore + slot.length > span.start && slot.offsetBefore < span.end);
   const firstSlot = overlapping[0];
   if (!firstSlot) {
@@ -20033,12 +21594,12 @@ function replaceSpanInParagraph(paragraph, span, replacement, tracked) {
   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);
+    rebuildContainer(firstParent, containerStart, span, replacement, inheritedProperties, firstParent === paragraph, tracked ?? null, view);
     return;
   }
-  rebuildAcrossBoundaries(paragraph, span, replacement, inheritedProperties, tracked ?? null);
+  rebuildAcrossBoundaries(paragraph, span, replacement, inheritedProperties, tracked ?? null, view);
 }
-function collectRunSlots(paragraph) {
+function collectRunSlots(paragraph, view) {
   const slots = [];
   let offset = 0;
   function walk(parent, children) {
@@ -20054,7 +21615,7 @@ function collectRunSlots(paragraph) {
         offset += length;
         continue;
       }
-      if (isRunBearingWrapper(child.tag)) {
+      if (isWrapperVisibleInView2(child.tag, view)) {
         walk(child, child.children);
       }
     }
@@ -20062,7 +21623,7 @@ function collectRunSlots(paragraph) {
   walk(paragraph, paragraph.children);
   return slots;
 }
-function rebuildContainer(container, baseOffset, span, replacement, runProperties, isParagraph, tracked) {
+function rebuildContainer(container, baseOffset, span, replacement, runProperties, isParagraph, tracked, view) {
   const newChildren = [];
   let offset = baseOffset;
   let placed = false;
@@ -20113,8 +21674,8 @@ function rebuildContainer(container, baseOffset, span, replacement, runPropertie
       }
       continue;
     }
-    if (isParagraph && isRunBearingWrapper(child.tag)) {
-      offset += sumRunBearingTextLength(child.children);
+    if (isParagraph && isWrapperVisibleInView2(child.tag, view)) {
+      offset += sumVisibleTextLength2(child.children, view);
       newChildren.push(child);
       continue;
     }
@@ -20124,7 +21685,7 @@ function rebuildContainer(container, baseOffset, span, replacement, runPropertie
     placeReplacement();
   container.children = newChildren;
 }
-function rebuildAcrossBoundaries(paragraph, span, replacement, runProperties, tracked) {
+function rebuildAcrossBoundaries(paragraph, span, replacement, runProperties, tracked, view) {
   const newChildren = [];
   let offset = 0;
   let placed = false;
@@ -20175,8 +21736,12 @@ function rebuildAcrossBoundaries(paragraph, span, replacement, runProperties, tr
       }
       continue;
     }
+    if ((child.tag === "w:ins" || child.tag === "w:del" || child.tag === "w:moveFrom" || child.tag === "w:moveTo") && !isWrapperVisibleInView2(child.tag, view)) {
+      newChildren.push(child);
+      continue;
+    }
     if (child.tag === "w:ins" || child.tag === "w:del" || child.tag === "w:moveFrom" || child.tag === "w:moveTo") {
-      const innerLength = sumRunBearingTextLength(child.children);
+      const innerLength = sumVisibleTextLength2(child.children, view);
       const wrapperStart = offset;
       const wrapperEnd = offset + innerLength;
       offset = wrapperEnd;
@@ -20193,7 +21758,7 @@ function rebuildAcrossBoundaries(paragraph, span, replacement, runProperties, tr
       continue;
     }
     if (child.tag === "w:hyperlink") {
-      const innerLength = sumRunBearingTextLength(child.children);
+      const innerLength = sumVisibleTextLength2(child.children, view);
       const wrapperStart = offset;
       const wrapperEnd = offset + innerLength;
       offset = wrapperEnd;
@@ -20206,13 +21771,13 @@ function rebuildAcrossBoundaries(paragraph, span, replacement, runProperties, tr
         newChildren.push(child);
         continue;
       }
-      splitHyperlinkAcrossSpan(child, wrapperStart, span, runProperties, replacement, tracked, newChildren, placeReplacement, () => {
+      splitHyperlinkAcrossSpan(child, wrapperStart, span, runProperties, replacement, tracked, view, newChildren, placeReplacement, () => {
         placed = true;
       });
       continue;
     }
     if (isRunBearingWrapper(child.tag)) {
-      const innerLength = sumRunBearingTextLength(child.children);
+      const innerLength = sumVisibleTextLength2(child.children, view);
       const wrapperStart = offset;
       const wrapperEnd = offset + innerLength;
       offset = wrapperEnd;
@@ -20328,8 +21893,8 @@ function splitTransparentWrapperAcrossSpan(wrapper, wrapperStart, span, out, pla
     out.push(postWrapper);
   }
 }
-function splitHyperlinkAcrossSpan(wrapper, wrapperStart, span, runProperties, replacement, tracked, out, placeReplacement, markReplacementPlaced) {
-  const wrapperEnd = wrapperStart + sumRunBearingTextLength(wrapper.children);
+function splitHyperlinkAcrossSpan(wrapper, wrapperStart, span, runProperties, replacement, tracked, view, out, placeReplacement, markReplacementPlaced) {
+  const wrapperEnd = wrapperStart + sumVisibleTextLength2(wrapper.children, view);
   const startsInside = span.start > wrapperStart && span.start < wrapperEnd;
   const preInner = [];
   const postInner = [];
@@ -20431,8 +21996,12 @@ async function run26(args) {
         all: { type: "boolean" },
         limit: { type: "string" },
         author: { type: "string" },
+        current: { type: "boolean" },
+        baseline: { type: "boolean" },
+        exact: { type: "boolean" },
         output: { type: "string", short: "o" },
         "dry-run": { type: "boolean" },
+        verbose: { type: "boolean", short: "v" },
         help: { type: "boolean", short: "h" }
       }
     });
@@ -20444,6 +22013,7 @@ async function run26(args) {
     await writeStdout(HELP26);
     return EXIT.OK;
   }
+  setVerboseAck(Boolean(parsed.values.verbose));
   const path = parsed.positionals[0];
   const pattern = parsed.positionals[1];
   const replacement = parsed.positionals[2];
@@ -20457,6 +22027,13 @@ async function run26(args) {
   const ignoreCase = Boolean(parsed.values["ignore-case"]);
   const useRegex = Boolean(parsed.values.regex);
   const wantAll = Boolean(parsed.values.all);
+  const wantCurrent = Boolean(parsed.values.current);
+  const wantBaseline = Boolean(parsed.values.baseline);
+  const exact = Boolean(parsed.values.exact);
+  if (wantCurrent && wantBaseline) {
+    return fail("USAGE", "--current and --baseline are mutually exclusive");
+  }
+  const findView = wantCurrent ? "current" : wantBaseline ? "baseline" : "accepted";
   const limitRaw = parsed.values.limit;
   const limit = limitRaw === undefined ? undefined : Number(limitRaw);
   if (limit !== undefined && (!Number.isInteger(limit) || limit <= 0)) {
@@ -20465,16 +22042,23 @@ async function run26(args) {
   const view = await openOrFail(path);
   if (typeof view === "number")
     return view;
-  let allMatches;
+  let findResult;
   try {
-    allMatches = findTextSpans(view.doc, pattern, {
+    findResult = findTextSpans(view.doc, pattern, {
       regex: useRegex,
-      ignoreCase
+      ignoreCase,
+      view: findView,
+      exact
     });
   } catch (matcherError) {
     const message = matcherError instanceof Error ? matcherError.message : String(matcherError);
     return fail("USAGE", `Invalid pattern: ${message}`);
   }
+  const allMatches = findResult.matches;
+  const normalizationFields = findResult.normalizedQuery !== undefined ? {
+    normalizedPattern: findResult.normalizedQuery,
+    normalizationApplied: findResult.normalizationApplied
+  } : {};
   let selected;
   if (limit !== undefined) {
     selected = allMatches.slice(0, limit);
@@ -20501,15 +22085,17 @@ async function run26(args) {
       replacement,
       regex: useRegex,
       ignoreCase,
+      view: findView,
       totalMatches: allMatches.length,
       replaced: selected.length,
       matches: matchesPayload,
+      ...normalizationFields,
       ...outputPath ? { output: outputPath } : {}
     });
     return EXIT.OK;
   }
   if (selected.length === 0) {
-    await respond({
+    await respondAck({
       ok: true,
       operation: "replace",
       path,
@@ -20517,9 +22103,11 @@ async function run26(args) {
       replacement,
       regex: useRegex,
       ignoreCase,
+      view: findView,
       totalMatches: 0,
       replaced: 0,
-      matches: []
+      matches: [],
+      ...normalizationFields
     });
     return EXIT.OK;
   }
@@ -20538,10 +22126,10 @@ async function run26(args) {
   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);
+    replaceSpanInParagraph(blockRef.node, { start: match.start, end: match.end }, concreteReplacement, tracked, findView);
   }
   await saveDocView(view, outputPath);
-  await respond({
+  await respondAck({
     ok: true,
     operation: "replace",
     path: outputPath ?? path,
@@ -20549,9 +22137,11 @@ async function run26(args) {
     replacement,
     regex: useRegex,
     ignoreCase,
+    view: findView,
     totalMatches: allMatches.length,
     replaced: selected.length,
-    matches: matchesPayload
+    matches: matchesPayload,
+    ...normalizationFields
   });
   return EXIT.OK;
 }
@@ -20566,8 +22156,15 @@ Options:
   --all             replace every match (default: just the first)
   --limit N         replace at most N matches (in document order)
   --author NAME     author for tracked changes (default: $DOCX_AUTHOR)
+  --current         operate on the raw concatenation (both ins and del text)
+  --baseline        operate on the pre-change text (skip ins/moveTo)
+                    default: accepted view (skip del/moveFrom) \u2014 matches
+                    "docx find" / "docx read --markdown"
+  --exact           disable pattern normalization (no markdown-emphasis stripping,
+                    no smart/straight quote or em/en-dash equivalence)
   -o, --output PATH write to PATH instead of overwriting FILE
   --dry-run         report what would change without writing the file
+  -v, --verbose     print the success ack JSON (default: silent on success)
   -h, --help        show this help
 
 Within-paragraph matches only. Run formatting (rPr) on the surrounding text
@@ -20576,6 +22173,12 @@ overlaps the matched span. When a single invocation produces multiple
 replacements in the same paragraph, they're applied in reverse offset order
 so earlier offsets don't shift before being applied.
 
+By default the PATTERN is normalized: balanced markdown emphasis around
+non-whitespace (**X**, __X__, *X*, \`X\`) is stripped; smart quotes match
+straight quotes; em-dash and en-dash match the hyphen. The REPLACEMENT
+is always literal \u2014 whatever bytes you pass go in as-is. Pass --exact
+to match the raw pattern verbatim. --regex is always verbatim.
+
 With --regex, REPLACEMENT supports JS String.replace substitution syntax:
   $1, $2, ...   numbered capture groups
   $&            the matched substring
@@ -20650,7 +22253,7 @@ async function run27(args) {
     const kind = trackedChangeKindForTag(reference.node.tag);
     if (!kind)
       continue;
-    byId.set(id, {
+    const record = {
       id,
       kind,
       author: reference.node.getAttribute("w:author") ?? "",
@@ -20658,7 +22261,14 @@ async function run27(args) {
       revisionId: reference.node.getAttribute("w:id") ?? "",
       blockId: reference.blockId,
       text: ""
-    });
+    };
+    if (kind === "sectPrChange") {
+      const liveSiblings = reference.parent.filter((child) => child !== reference.node);
+      record.current = readSectionProperties(liveSiblings);
+      const snapshot = reference.node.findChild("w:sectPr");
+      record.prior = snapshot ? readSectionProperties(snapshot.children) : {};
+    }
+    byId.set(id, record);
   }
   const sorted = [...byId.values()].sort((a2, b) => trackedChangeIndex(a2.id) - trackedChangeIndex(b.id));
   await respond(sorted);
@@ -20677,6 +22287,8 @@ function trackedChangeKindForTag(tag) {
     return "moveFrom";
   if (tag === "w:moveTo")
     return "moveTo";
+  if (tag === "w:sectPrChange")
+    return "sectPrChange";
   return null;
 }
 var HELP27 = `docx track-changes list \u2014 inventory every revision wrapper
@@ -20687,18 +22299,28 @@ Usage:
 Options:
   -h, --help    Show this help
 
-Lists every <w:ins>, <w:del>, <w:moveFrom>, and <w:moveTo> wrapper with
-stable tcN ids. moveFrom/moveTo halves of the same logical move appear
-as separate entries (one for each side); their kind tells them apart.
+Lists every revision wrapper with stable tcN ids \u2014 run-level <w:ins>, <w:del>,
+<w:moveFrom>, <w:moveTo>; section-property revisions <w:sectPrChange>; and
+paragraph-mark <w:ins>/<w:del> markers (a self-closing element inside
+<w:pPr><w:rPr> that tracks a paragraph break itself). moveFrom/moveTo halves
+of the same logical move appear as separate entries; their kind tells them
+apart.
 
 Output: JSON array of { id, kind, author, date, revisionId, blockId, text }
 sorted by id (document order). kind is one of: "ins", "del", "moveFrom",
-"moveTo".
+"moveTo", "sectPrChange". Paragraph-mark entries have kind "ins"/"del" with
+text "" \u2014 their blockId is the owning paragraph's pN.
+
+Section-property revisions (kind="sectPrChange") additionally include
+{ prior, current } objects with the section's columns/sectionType from
+before and after the tracked edit, so agents can see the diff without
+re-reading XML.
 
 Examples:
   docx track-changes list doc.docx
   docx track-changes list doc.docx | jq '.[] | select(.kind == "del")'
   docx track-changes list doc.docx | jq '.[] | select(.kind | test("move"))'
+  docx track-changes list doc.docx | jq '.[] | select(.kind == "sectPrChange") | .prior, .current'
 `;
 var init_list4 = __esm(() => {
   init_core();
@@ -20714,10 +22336,11 @@ async function runApply(args, verb, help) {
       args,
       allowPositionals: true,
       options: {
-        at: { type: "string" },
+        at: { type: "string", multiple: true },
         all: { type: "boolean" },
         output: { type: "string", short: "o" },
         "dry-run": { type: "boolean" },
+        verbose: { type: "boolean", short: "v" },
         help: { type: "boolean", short: "h" }
       }
     });
@@ -20729,16 +22352,17 @@ async function runApply(args, verb, help) {
     await writeStdout(help);
     return EXIT.OK;
   }
+  setVerboseAck(Boolean(parsed.values.verbose));
   const path = parsed.positionals[0];
   if (!path)
     return fail("USAGE", "Missing FILE argument", help);
-  const at = parsed.values.at;
+  const atRaw = parsed.values.at;
   const all = Boolean(parsed.values.all);
-  if (at && all) {
+  if (atRaw && atRaw.length > 0 && all) {
     return fail("USAGE", "--at and --all are mutually exclusive", help);
   }
-  if (!at && !all) {
-    return fail("USAGE", "Specify --at tcN or --all", help);
+  if ((!atRaw || atRaw.length === 0) && !all) {
+    return fail("USAGE", "Specify --at tcN (repeatable) or --all", help);
   }
   const view = await openOrFail(path);
   if (typeof view === "number")
@@ -20748,16 +22372,33 @@ async function runApply(args, verb, help) {
   if (all) {
     targets = allChanges;
   } else {
-    const found = allChanges.find((change) => change.id === at);
-    if (!found) {
-      return fail("TRACKED_CHANGE_NOT_FOUND", `Tracked change not found: ${at}`);
-    }
-    targets = [found];
+    const seen = new Set;
+    const ordered = [];
+    for (const id of atRaw ?? []) {
+      if (seen.has(id))
+        continue;
+      seen.add(id);
+      ordered.push(id);
+    }
+    const byId = new Map(allChanges.map((change) => [change.id, change]));
+    targets = [];
+    for (const id of ordered) {
+      const found = byId.get(id);
+      if (!found) {
+        return fail("TRACKED_CHANGE_NOT_FOUND", `Tracked change not found: ${id}`);
+      }
+      targets.push(found);
+    }
+    targets.sort((left, right) => {
+      const leftIndex = allChanges.indexOf(left);
+      const rightIndex = allChanges.indexOf(right);
+      return leftIndex - rightIndex;
+    });
   }
   const records = targets.map((target) => ({
     id: target.id,
     kind: target.kind,
-    action: actionFor(target.kind, verb),
+    action: actionFor(target, verb),
     author: target.author,
     date: target.date
   }));
@@ -20775,12 +22416,12 @@ async function runApply(args, verb, help) {
   }
   for (const target of [...targets].reverse()) {
     if (verb === "accept")
-      applyAccept(target.node, target.parent);
+      applyAccept(target);
     else
-      applyReject(target.node, target.parent);
+      applyReject(target);
   }
   await saveDocView(view, outputPath);
-  await respond({
+  await respondAck({
     ok: true,
     operation: `track-changes.${verb}`,
     path: outputPath ?? path,
@@ -20790,26 +22431,95 @@ async function runApply(args, verb, help) {
 }
 function collectTrackedChanges(tree) {
   const out = [];
-  let counter = 0;
-  function walk(children) {
-    for (const node of children) {
-      const kind = trackedChangeKindForTag2(node.tag);
-      if (kind) {
-        out.push({
-          node,
-          parent: children,
-          kind,
-          id: `tc${counter++}`,
-          author: node.getAttribute("w:author") ?? "",
-          date: node.getAttribute("w:date") ?? ""
-        });
+  const counter = { value: 0 };
+  const documentNode = XmlNode2.findRoot(tree, "w:document");
+  if (!documentNode)
+    return out;
+  const body = documentNode.findChild("w:body");
+  if (!body)
+    return out;
+  visitBlocks(body.children, out, counter);
+  return out;
+}
+function visitBlocks(blocks, out, counter) {
+  for (const block of blocks) {
+    if (block.tag === "w:p") {
+      visitParagraph(block, blocks, out, counter);
+      continue;
+    }
+    if (block.tag === "w:tbl") {
+      for (const row of block.findChildren("w:tr")) {
+        for (const cell of row.findChildren("w:tc")) {
+          visitBlocks(cell.children, out, counter);
+        }
       }
-      if (node.children.length > 0)
-        walk(node.children);
+      continue;
+    }
+    if (block.tag === "w:sectPr") {
+      visitSectPrChange(block, out, counter);
     }
   }
-  walk(tree);
-  return out;
+}
+function visitParagraph(paragraph, paragraphParent, out, counter) {
+  visitRunContainer(paragraph, out, counter);
+  const pPr = paragraph.findChild("w:pPr");
+  if (!pPr)
+    return;
+  const sectPr = pPr.findChild("w:sectPr");
+  if (sectPr)
+    visitSectPrChange(sectPr, out, counter);
+  const rPr = pPr.findChild("w:rPr");
+  if (!rPr)
+    return;
+  for (const child of rPr.children) {
+    const kind = trackedChangeKindForTag2(child.tag);
+    if (kind !== "ins" && kind !== "del")
+      continue;
+    out.push({
+      node: child,
+      parent: rPr.children,
+      kind,
+      id: `tc${counter.value++}`,
+      author: child.getAttribute("w:author") ?? "",
+      date: child.getAttribute("w:date") ?? "",
+      paragraph,
+      paragraphParent
+    });
+  }
+}
+function visitRunContainer(container, out, counter) {
+  for (const child of container.children) {
+    if (child.tag === "w:pPr")
+      continue;
+    const kind = trackedChangeKindForTag2(child.tag);
+    if (kind === "ins" || kind === "del" || kind === "moveFrom" || kind === "moveTo") {
+      out.push({
+        node: child,
+        parent: container.children,
+        kind,
+        id: `tc${counter.value++}`,
+        author: child.getAttribute("w:author") ?? "",
+        date: child.getAttribute("w:date") ?? ""
+      });
+      visitRunContainer(child, out, counter);
+      continue;
+    }
+    if (child.children.length > 0)
+      visitRunContainer(child, out, counter);
+  }
+}
+function visitSectPrChange(sectPr, out, counter) {
+  const change = sectPr.findChild("w:sectPrChange");
+  if (!change)
+    return;
+  out.push({
+    node: change,
+    parent: sectPr.children,
+    kind: "sectPrChange",
+    id: `tc${counter.value++}`,
+    author: change.getAttribute("w:author") ?? "",
+    date: change.getAttribute("w:date") ?? ""
+  });
 }
 function trackedChangeKindForTag2(tag) {
   if (tag === "w:ins")
@@ -20820,28 +22530,96 @@ function trackedChangeKindForTag2(tag) {
     return "moveFrom";
   if (tag === "w:moveTo")
     return "moveTo";
+  if (tag === "w:sectPrChange")
+    return "sectPrChange";
   return null;
 }
-function actionFor(kind, verb) {
-  const isAdditive = kind === "ins" || kind === "moveTo";
+function actionFor(target, verb) {
+  if (target.paragraph) {
+    if (target.kind === "ins") {
+      return verb === "accept" ? "delete" : "deleteParagraph";
+    }
+    if (target.kind === "del") {
+      return verb === "accept" ? "merge" : "delete";
+    }
+  }
+  if (target.kind === "sectPrChange") {
+    return verb === "accept" ? "delete" : "restore";
+  }
+  const isAdditive = target.kind === "ins" || target.kind === "moveTo";
   if (verb === "accept")
     return isAdditive ? "unwrap" : "delete";
   return isAdditive ? "delete" : "unwrap";
 }
-function applyAccept(node, parent) {
-  if (node.tag === "w:ins" || node.tag === "w:moveTo") {
-    unwrapNode(node, parent);
+function applyAccept(target) {
+  if (target.paragraph && target.paragraphParent) {
+    if (target.kind === "ins") {
+      deleteNode(target.node, target.parent);
+      return;
+    }
+    if (target.kind === "del") {
+      deleteNode(target.node, target.parent);
+      mergeParagraphWithNext(target.paragraph, target.paragraphParent);
+      return;
+    }
+  }
+  if (target.node.tag === "w:ins" || target.node.tag === "w:moveTo") {
+    unwrapNode(target.node, target.parent);
+    return;
+  }
+  if (target.node.tag === "w:sectPrChange") {
+    deleteNode(target.node, target.parent);
+    return;
+  }
+  deleteNode(target.node, target.parent);
+}
+function applyReject(target) {
+  if (target.paragraph && target.paragraphParent) {
+    if (target.kind === "ins") {
+      const idx = target.paragraphParent.indexOf(target.paragraph);
+      if (idx !== -1)
+        target.paragraphParent.splice(idx, 1);
+      return;
+    }
+    if (target.kind === "del") {
+      deleteNode(target.node, target.parent);
+      return;
+    }
+  }
+  if (target.node.tag === "w:ins" || target.node.tag === "w:moveTo") {
+    deleteNode(target.node, target.parent);
+    return;
+  }
+  if (target.node.tag === "w:sectPrChange") {
+    restoreSectPrSnapshot(target.node, target.parent);
     return;
   }
-  deleteNode(node, parent);
+  renameDelTextToText(target.node);
+  unwrapNode(target.node, target.parent);
 }
-function applyReject(node, parent) {
-  if (node.tag === "w:ins" || node.tag === "w:moveTo") {
-    deleteNode(node, parent);
+function mergeParagraphWithNext(paragraph, paragraphParent) {
+  const idx = paragraphParent.indexOf(paragraph);
+  if (idx === -1)
     return;
+  const next = paragraphParent[idx + 1];
+  if (!next || next.tag !== "w:p")
+    return;
+  const toMove = [];
+  for (const child of next.children) {
+    if (child.tag === "w:pPr")
+      continue;
+    toMove.push(child);
+  }
+  paragraph.children.push(...toMove);
+  paragraphParent.splice(idx + 1, 1);
+}
+function restoreSectPrSnapshot(node, parent) {
+  const snapshot = node.findChild("w:sectPr");
+  parent.length = 0;
+  if (snapshot) {
+    for (const child of snapshot.children)
+      parent.push(child);
   }
-  renameDelTextToText(node);
-  unwrapNode(node, parent);
 }
 function unwrapNode(node, parent) {
   const index = parent.indexOf(node);
@@ -20863,6 +22641,7 @@ function renameDelTextToText(node) {
 }
 var init_apply = __esm(() => {
   init_core();
+  init_parser();
   init_respond();
 });
 
@@ -20885,19 +22664,33 @@ wrapper \u2014 the content becomes plain runs at this location. Accepting a
 deletion (<w:del>) or move source (<w:moveFrom>) removes the element and its
 <w:delText> entirely (the text disappears for real).
 
-Out of scope: tracked paragraph marks (<w:rPr><w:ins/></w:rPr> inside <w:pPr>)
-and formatting changes (<w:rPrChange>/<w:pPrChange>). These aren't modeled in
-the AST today and --all silently skips them.
+Section-property revisions (<w:sectPrChange>): accept drops the prior-state
+snapshot, leaving the live section properties in place.
+
+Paragraph-mark trackings (<w:ins>/<w:del> inside <w:pPr><w:rPr>): accepting
+a paragraph-mark insertion just removes the marker (the inserted paragraph
+stays as a regular paragraph). Accepting a paragraph-mark deletion merges
+the owning paragraph with the next paragraph \u2014 the next paragraph's runs
+are appended to this one and the next paragraph is removed (per ECMA-376
+\xA717.13.5.4).
+
+Out of scope: formatting changes (<w:rPrChange>/<w:pPrChange>). These aren't
+modeled in the AST today and --all silently skips them.
 
 Options:
-  --at tcN          Accept a single tracked change by id
+  --at tcN          Accept a tracked change by id. Repeat for multiple ids
+                    (--at tc1 --at tc2 --at tc3) \u2014 all targets are resolved
+                    against the pre-mutation tree, so renumbering during the
+                    batch is not a concern.
   --all             Accept every tracked change (mutually exclusive with --at)
   -o, --output PATH Write to PATH instead of overwriting FILE
   --dry-run         Print what would change; do not write the file
+  -v, --verbose     Print the success ack JSON (default: silent on success)
   -h, --help        Show this help
 
 Examples:
   docx track-changes accept doc.docx --at tc0
+  docx track-changes accept doc.docx --at tc1 --at tc3 --at tc5
   docx track-changes accept doc.docx --all
   docx track-changes accept doc.docx --all --dry-run
 `;
@@ -20925,23 +22718,37 @@ Rejecting a deletion (<w:del>) or move source (<w:moveFrom>) unwraps the
 wrapper and converts <w:delText> back to <w:t>, so the text reappears as
 plain runs.
 
+Section-property revisions (<w:sectPrChange>): reject restores the prior-state
+snapshot \u2014 the live section's columns/type are replaced with the values that
+were in effect before the tracked edit.
+
+Paragraph-mark trackings (<w:ins>/<w:del> inside <w:pPr><w:rPr>): rejecting
+a paragraph-mark insertion removes the entire owning paragraph (the inserted
+break disappears \u2014 for sentinels created by "insert --section" this also
+removes the section break the sentinel was carrying). Rejecting a
+paragraph-mark deletion just removes the marker (the paragraph stays).
+
 moveFrom and moveTo are processed independently. To fully undo a move, target
 both halves (or use --all). The runtime treats them as paired only by their
 shared revision id, not by atomic accept/reject.
 
-Out of scope: tracked paragraph marks (<w:rPr><w:del/></w:rPr> inside <w:pPr>)
-and formatting changes (<w:rPrChange>/<w:pPrChange>). These aren't modeled in
-the AST today and --all silently skips them.
+Out of scope: formatting changes (<w:rPrChange>/<w:pPrChange>). These aren't
+modeled in the AST today and --all silently skips them.
 
 Options:
-  --at tcN          Reject a single tracked change by id
+  --at tcN          Reject a tracked change by id. Repeat for multiple ids
+                    (--at tc1 --at tc2 --at tc3) \u2014 all targets are resolved
+                    against the pre-mutation tree, so renumbering during the
+                    batch is not a concern.
   --all             Reject every tracked change (mutually exclusive with --at)
   -o, --output PATH Write to PATH instead of overwriting FILE
   --dry-run         Print what would change; do not write the file
+  -v, --verbose     Print the success ack JSON (default: silent on success)
   -h, --help        Show this help
 
 Examples:
   docx track-changes reject doc.docx --at tc0
+  docx track-changes reject doc.docx --at tc1 --at tc3 --at tc5
   docx track-changes reject doc.docx --all
   docx track-changes reject doc.docx --all --dry-run
 `;
@@ -20964,6 +22771,7 @@ async function run30(args) {
       options: {
         output: { type: "string", short: "o" },
         "dry-run": { type: "boolean" },
+        verbose: { type: "boolean", short: "v" },
         help: { type: "boolean", short: "h" }
       }
     });
@@ -20975,6 +22783,7 @@ async function run30(args) {
     await writeStdout(HELP30);
     return EXIT.OK;
   }
+  setVerboseAck(Boolean(parsed.values.verbose));
   const path = parsed.positionals[0];
   if (!path)
     return fail("USAGE", "Missing FILE argument", HELP30);
@@ -21023,7 +22832,7 @@ async function run30(args) {
     });
   }
   await saveDocView(view, outputPath);
-  await respond({
+  await respondAck({
     ok: true,
     operation: "track-changes",
     path: outputPath ?? path,
@@ -21045,6 +22854,7 @@ insert/edit/delete/replace commands also emit <w:ins>/<w:del> markers
 Options:
   -o, --output PATH Write to PATH instead of overwriting FILE
   --dry-run         Print what would change; do not write the file
+  -v, --verbose     Print the success ack JSON (default: silent on success)
   -h, --help        Show this help
 
 Examples:
@@ -21100,18 +22910,23 @@ Usage:
 Verbs:
   on        Set <w:trackChanges/> in word/settings.xml
   off       Remove <w:trackChanges/>
-  list      Inventory every <w:ins>/<w:del>/<w:moveFrom>/<w:moveTo> with
-            id, kind, author, date, location
-  accept    Accept tracked changes \u2014 additive wrappers (<w:ins>, <w:moveTo>)
-            unwrap; subtractive wrappers (<w:del>, <w:moveFrom>) are removed
-  reject    Reject tracked changes \u2014 additive wrappers are removed;
-            subtractive wrappers unwrap (with <w:delText> \u2192 <w:t> rename)
+  list      Inventory every revision wrapper (run-level ins/del/move,
+            <w:sectPrChange>, paragraph-mark <w:ins>/<w:del>) with stable
+            tcN ids
+  accept    Accept tracked changes \u2014 ins/moveTo unwrap; del/moveFrom are
+            removed; sectPrChange drops its snapshot (live state stays);
+            paragraph-mark del merges with the next paragraph
+  reject    Reject tracked changes \u2014 ins/moveTo are removed (and for a
+            paragraph-mark ins the entire paragraph is removed); del/moveFrom
+            unwrap (with <w:delText> \u2192 <w:t> rename); sectPrChange restores
+            its snapshot
 
 When tracking is on, this CLI's insert/edit/delete/replace commands
-emit <w:ins>/<w:del> markers (attributed via --author or $DOCX_AUTHOR).
-moveFrom/moveTo are read, listed, and accept/reject independently \u2014 we
-don't emit them ourselves (Word does that interactively).
-Accept/reject themselves bypass tracking \u2014 they're doc surgery, not edits.
+emit <w:ins>/<w:del> markers (attributed via --author or $DOCX_AUTHOR);
+edit --at sN under tracking emits <w:sectPrChange>. moveFrom/moveTo are
+read, listed, and accept/reject independently \u2014 we don't emit them
+ourselves (Word does that interactively). Accept/reject themselves
+bypass tracking \u2014 they're doc surgery, not edits.
 
 Run "docx track-changes <verb> --help" for verb-specific help.
 `;
@@ -21121,16 +22936,48 @@ var init_track_changes2 = __esm(() => {
 
 // src/cli/wc/count.ts
 function textFor(options) {
-  if (options.view === "accepted")
-    return paragraphTextAccepted;
-  if (options.view === "baseline")
+  const view = options.view ?? "accepted";
+  if (view === "current")
+    return paragraphText;
+  if (view === "baseline")
     return paragraphTextBaseline;
-  return paragraphText;
+  return paragraphTextAccepted;
 }
 function countWords(text) {
   const matches = text.match(/\S+/g);
   return matches?.length ?? 0;
 }
+function countWordsInSection(blocks, targetId, options = {}) {
+  let bucket = [];
+  for (const block of blocks) {
+    if (block.type === "sectionBreak") {
+      if (block.id === targetId) {
+        return countWordsInBlocks(bucket, options);
+      }
+      bucket = [];
+      continue;
+    }
+    bucket.push(block);
+  }
+  return null;
+}
+function countSectionsInBlocks(blocks) {
+  let total = 0;
+  for (const block of blocks) {
+    if (block.type === "sectionBreak") {
+      total += 1;
+      continue;
+    }
+    if (block.type === "table") {
+      for (const row of block.rows) {
+        for (const cell of row.cells) {
+          total += countSectionsInBlocks(cell.blocks);
+        }
+      }
+    }
+  }
+  return total;
+}
 function countWordsInBlocks(blocks, options = {}) {
   const text = textFor(options);
   let total = 0;
@@ -21201,6 +23048,7 @@ async function run32(args) {
       options: {
         accepted: { type: "boolean" },
         baseline: { type: "boolean" },
+        current: { type: "boolean" },
         help: { type: "boolean", short: "h" }
       }
     });
@@ -21218,10 +23066,12 @@ async function run32(args) {
     return fail("USAGE", "Missing FILE argument", HELP32);
   const wantAccepted = Boolean(parsed.values.accepted);
   const wantBaseline = Boolean(parsed.values.baseline);
-  if (wantAccepted && wantBaseline) {
-    return fail("USAGE", "--accepted and --baseline are mutually exclusive", HELP32);
+  const wantCurrent = Boolean(parsed.values.current);
+  const viewFlagCount = (wantAccepted ? 1 : 0) + (wantBaseline ? 1 : 0) + (wantCurrent ? 1 : 0);
+  if (viewFlagCount > 1) {
+    return fail("USAGE", "--accepted, --baseline, and --current are mutually exclusive", HELP32);
   }
-  const view = wantAccepted ? "accepted" : wantBaseline ? "baseline" : "current";
+  const view = wantCurrent ? "current" : wantBaseline ? "baseline" : "accepted";
   const pickText = paragraphTextFor(view);
   const docView = await openOrFail(path);
   if (typeof docView === "number")
@@ -21233,7 +23083,8 @@ async function run32(args) {
       path,
       scope: "document",
       view,
-      words: countWordsInBlocks(docView.doc.blocks, { view })
+      words: countWordsInBlocks(docView.doc.blocks, { view }),
+      sections: countSectionsInBlocks(docView.doc.blocks)
     });
     return EXIT.OK;
   }
@@ -21255,6 +23106,24 @@ async function run32(args) {
     if (!block) {
       return fail("BLOCK_NOT_FOUND", `Block not found: ${locator.blockId}`);
     }
+    if (block.type === "sectionBreak") {
+      const sectionWords = countWordsInSection(blocks, locator.blockId, {
+        view
+      });
+      if (sectionWords === null) {
+        return fail("BLOCK_NOT_FOUND", `Section not found: ${locator.blockId}`);
+      }
+      await respond({
+        ok: true,
+        operation: "wc",
+        path,
+        locator: locatorInput,
+        scope: "section",
+        view,
+        words: sectionWords
+      });
+      return EXIT.OK;
+    }
     const words = block.type === "paragraph" ? countWords(pickText(block)) : block.type === "table" ? countWordsInBlocks([block], { view }) : 0;
     await respond({
       ok: true,
@@ -21379,22 +23248,27 @@ Locators (optional; default: whole document):
   tN:rRcC         whole cell
   tN:rRcC:pK      paragraph K inside that cell
   tN:rRcC:pK:S-E  span within a cell paragraph
+  sN              section N \u2014 every paragraph and table from the prior section
+                  boundary up to and including the paragraph that holds sN's
+                  inline sectPr (or to end of body for the trailing section)
 
 Options:
-  --accepted        Count the accepted view: skip subtractive wrappers
-                    (<w:del>, <w:moveFrom>); keep additive wrappers
-                    (<w:ins>, <w:moveTo>) as plain text. Mirrors
-                    "docx read --markdown --accepted".
+  --accepted        Default. Count the accepted view: skip subtractive
+                    wrappers (<w:del>, <w:moveFrom>); keep additive
+                    wrappers (<w:ins>, <w:moveTo>) as plain text. Mirrors
+                    "docx read --markdown" / "docx find" defaults.
   --baseline        Count the baseline view: skip additive wrappers
                     (<w:ins>, <w:moveTo>); keep subtractive wrappers
                     (<w:del>, <w:moveFrom>) as plain text \u2014 i.e., the doc as
                     it was before any tracked changes were made.
+  --current         Count the raw concatenation: every tracked-change
+                    wrapper's text counts (everything on disk).
   -h, --help        show this help
 
 Counting is whitespace-segmented (\\S+) over the joined paragraph text. Hidden
-content like images/breaks/tabs contributes no words. By default, every
-tracked-change wrapper's text counts (they're all on disk); pass --accepted
-or --baseline (mutually exclusive) to count a tracked-change-aware slice.
+content like images/breaks/tabs contributes no words. The three view flags
+are mutually exclusive; default (no flag) is --accepted, matching what a
+reader would see if every tracked change were accepted.
 
 Examples:
   docx wc doc.docx
@@ -21402,6 +23276,7 @@ Examples:
   docx wc doc.docx p3:0-120
   docx wc doc.docx p5:10-p9:42
   docx wc doc.docx t0:r1c0
+  docx wc doc.docx s2
 `;
 var init_wc = __esm(() => {
   init_core();
@@ -21411,7 +23286,7 @@ var init_wc = __esm(() => {
 // package.json
 var package_default = {
   name: "bun-docx",
-  version: "0.7.0",
+  version: "0.8.0",
   description: "CLI for AI agents (Claude, Codex) to read, edit, and comment on .docx files with full format fidelity.",
   keywords: [
     "docx",
@@ -21503,12 +23378,21 @@ Environment:
 
 Tracked changes:
   Toggle:    docx track-changes FILE on|off
-  Inventory: docx track-changes list FILE  (JSON: id, kind, author, date, blockId, text)
+  Inventory: docx track-changes list FILE  (JSON array of { id, kind, author,
+             date, revisionId, blockId, text }; sectPrChange entries also
+             include { prior, current } with the section properties on each
+             side of the edit)
   Accept:    docx track-changes accept FILE (--at tcN | --all)
   Reject:    docx track-changes reject FILE (--at tcN | --all)
 
   When <w:trackChanges/> is set, insert/edit/delete/replace automatically emit
   <w:ins>/<w:del> markers attributed via --author (or $DOCX_AUTHOR, or "docx-cli").
+  edit --at sN under tracking emits <w:sectPrChange> snapshots on the section.
+
+  Accept/reject handle: run-level ins/del/moveFrom/moveTo, sectPrChange
+  (snapshot drop or restore), and paragraph-mark ins/del (accept-del merges
+  with the next paragraph; reject-ins removes the entire owning paragraph).
+  Out of scope: rPrChange / pPrChange formatting revisions.
 
   "docx read --markdown" surfaces them as CriticMarkup:
     {++inserted++}[^tcN]   {--deleted--}[^tcN]