bun-docx 0.13.0 → 0.14.0

package/dist/index.js

@@ -16632,6 +16632,7 @@ var init_jsx = __esm(() => {
     "rFonts",
     "br",
     "tab",
+    "tabs",
     "drawing",
     "sectPr",
     "sectPrChange",
@@ -21616,6 +21617,15 @@ function applyParagraphProperties(document2, paragraph, paragraphProperties) {
       paragraph.alignment = value;
     }
   }
+  const tabsNode = paragraphProperties.findChild("w:tabs");
+  if (tabsNode) {
+    const stops = tabsNode.findChildren("w:tab").map((tab) => ({
+      align: tab.getAttribute("w:val") ?? "left",
+      pos: Number(tab.getAttribute("w:pos") ?? "0")
+    })).filter((stop) => Number.isFinite(stop.pos));
+    if (stops.length > 0)
+      paragraph.tabStops = stops;
+  }
   const numberingProperties = paragraphProperties.findChild("w:numPr");
   if (numberingProperties) {
     const indentLevel = numberingProperties.findChild("w:ilvl");
@@ -34067,6 +34077,7 @@ function Paragraph({
   alignment,
   list,
   taskState,
+  tabs,
   text: text2,
   runs,
   ...formatting
@@ -34075,7 +34086,7 @@ function Paragraph({
   return /* @__PURE__ */ jsxDEV(w.p, {
     children: [
       /* @__PURE__ */ jsxDEV(ParagraphProperties, {
-        options: { style, alignment, list }
+        options: { style, alignment, list, tabs }
       }, undefined, false, undefined, this),
       taskState && /* @__PURE__ */ jsxDEV(TaskCheckbox, {
         checked: taskState === "checked"
@@ -34131,13 +34142,26 @@ function RunElement({ run }) {
   return null;
 }
 function applyParagraphOptionsInPlace(rebuilt, options) {
-  if (!options.style && !options.alignment)
+  if (!options.style && !options.alignment && !options.tabs)
     return;
   let pPr = rebuilt.find((child2) => child2.tag === "w:pPr");
   if (!pPr) {
     pPr = new XmlNode2("w:pPr");
     rebuilt.unshift(pPr);
   }
+  if (options.tabs) {
+    pPr.children = pPr.children.filter((child2) => child2.tag !== "w:tabs");
+    if (options.tabs.length > 0) {
+      const tabsNode = new XmlNode2("w:tabs");
+      for (const stop of options.tabs) {
+        tabsNode.children.push(new XmlNode2("w:tab", {
+          "w:val": stop.align,
+          "w:pos": String(Math.round(stop.pos))
+        }));
+      }
+      insertPprChildInOrder(pPr, tabsNode);
+    }
+  }
   if (options.style) {
     const existingStyle = pPr.findChild("w:pStyle");
     if (existingStyle) {
@@ -34244,7 +34268,8 @@ function RunProperties({ run }) {
 function ParagraphProperties({
   options
 }) {
-  if (!options.style && !options.alignment && !options.list)
+  const hasTabs = options.tabs !== undefined && options.tabs.length > 0;
+  if (!options.style && !options.alignment && !options.list && !hasTabs)
     return null;
   return /* @__PURE__ */ jsxDEV(w.pPr, {
     children: [
@@ -34261,6 +34286,12 @@ function ParagraphProperties({
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this),
+      hasTabs && /* @__PURE__ */ jsxDEV(w.tabs, {
+        children: options.tabs?.map((stop) => /* @__PURE__ */ jsxDEV(w.tab, {
+          "w-val": stop.align,
+          "w-pos": String(Math.round(stop.pos))
+        }, undefined, false, undefined, this))
+      }, undefined, false, undefined, this),
       options.alignment && /* @__PURE__ */ jsxDEV(w.jc, {
         "w-val": options.alignment
       }, undefined, false, undefined, this)
@@ -49400,7 +49431,7 @@ function collectRunText(run) {
 function tokenize(text2) {
   if (text2.length === 0)
     return [];
-  return text2.match(/\S+|\s+/g) ?? [];
+  return text2.match(/\S+|\t+|[^\S\t]+/g) ?? [];
 }
 function diffTokens(oldTokens, newTokens) {
   const m2 = oldTokens.length;
@@ -49461,6 +49492,10 @@ function demoteOrphanWhitespaceKeeps(ops) {
       out.push(op2);
       continue;
     }
+    if (op2.old.text.includes("\t")) {
+      out.push(op2);
+      continue;
+    }
     const prev = ops[index - 1];
     const next = ops[index + 1];
     const prevIsEdit = prev !== undefined && prev.kind !== "keep";
@@ -49549,25 +49584,45 @@ function inheritedRprForInsert(ops, index, fallbackRpr) {
       break;
     groupEnd++;
   }
-  const deletes = [];
-  let insertOrdinal = 0;
-  let myInsertOrdinal = -1;
+  const targetText = (() => {
+    const op2 = ops[index];
+    return op2 && op2.kind === "insert" ? op2.text : "";
+  })();
+  const targetIsWord = !isWhitespaceOnly(targetText);
+  const allDeletes = [];
+  const wordDeletes = [];
+  let allInsertOrdinal = 0;
+  let wordInsertOrdinal = 0;
+  let myAllOrdinal = -1;
+  let myWordOrdinal = -1;
   for (let cursor = groupStart;cursor <= groupEnd; cursor++) {
     const op2 = ops[cursor];
     if (!op2)
       continue;
     if (op2.kind === "delete") {
-      deletes.push(op2.old.rPr);
+      allDeletes.push(op2.old.rPr);
+      if (!isWhitespaceOnly(op2.old.text))
+        wordDeletes.push(op2.old.rPr);
       continue;
     }
     if (op2.kind === "insert") {
-      if (cursor === index)
-        myInsertOrdinal = insertOrdinal;
-      insertOrdinal++;
+      const isWord = !isWhitespaceOnly(op2.text);
+      if (cursor === index) {
+        myAllOrdinal = allInsertOrdinal;
+        myWordOrdinal = isWord ? wordInsertOrdinal : -1;
+      }
+      allInsertOrdinal++;
+      if (isWord)
+        wordInsertOrdinal++;
     }
   }
-  if (deletes.length > 0 && myInsertOrdinal >= 0) {
-    const paired = myInsertOrdinal < deletes.length ? deletes[myInsertOrdinal] : deletes[deletes.length - 1];
+  if (targetIsWord && wordDeletes.length > 0 && myWordOrdinal >= 0) {
+    const paired = myWordOrdinal < wordDeletes.length ? wordDeletes[myWordOrdinal] : wordDeletes[wordDeletes.length - 1];
+    if (paired !== undefined)
+      return paired;
+  }
+  if (!targetIsWord && allDeletes.length > 0 && myAllOrdinal >= 0) {
+    const paired = myAllOrdinal < allDeletes.length ? allDeletes[myAllOrdinal] : allDeletes[allDeletes.length - 1];
     if (paired !== undefined)
       return paired;
   }
@@ -49964,6 +50019,14 @@ class Edit {
     }
     return anchorTarget ?? blockRef.node;
   }
+  paragraphProperties(blockRef, options) {
+    if (blockRef.node.tag !== "w:p") {
+      throw new EditError("USAGE", "--style/--alignment alone restyle a paragraph; this locator is not a paragraph.");
+    }
+    this.document.ensureStyles().ensureReferencedStyle(options.style);
+    applyParagraphOptionsInPlace(blockRef.node.children, options);
+    return blockRef.node;
+  }
   span(blockRef, span, replacement, opts = {}) {
     if (blockRef.node.tag !== "w:p") {
       throw new EditError("USAGE", "A character-span locator (pN:S-E) edits text inside a paragraph; this locator does not resolve to a paragraph.");
@@ -80368,16 +80431,20 @@ async function respond(payload) {
 function setVerboseAck(verbose) {
   verboseAck = verbose;
 }
-async function respondAck(payload) {
+async function respondAck(payload, layoutHint) {
   if (verboseAck) {
     await respond(payload);
     return;
   }
-  const line = summarizeAck(payload);
-  if (line)
-    await writeStdout(`${line}
+  const parts = [summarizeAck(payload), layoutHint].filter((part) => Boolean(part));
+  if (parts.length > 0)
+    await writeStdout(`${parts.join(`
+`)}
 `);
 }
+function renderVerifyHint(path2) {
+  return `\u21B3 layout changed \u2014 verify it renders right: docx render ${path2} --out pages/ (read shows text/structure, NOT page layout: columns, wraps, image sizing)`;
+}
 function summarizeAck(payload) {
   if (!payload || typeof payload !== "object")
     return null;
@@ -80425,13 +80492,16 @@ function ackTarget(ack) {
     return str(ack.path);
   return null;
 }
-async function respondMinted(locators, verbosePayload) {
+async function respondMinted(locators, verbosePayload, layoutHint) {
   if (verboseAck) {
     await respond(verbosePayload);
     return;
   }
-  if (locators.length > 0)
-    await writeStdout(`${locators.join(`
+  const parts = [...locators];
+  if (layoutHint)
+    parts.push(layoutHint);
+  if (parts.length > 0)
+    await writeStdout(`${parts.join(`
 `)}
 `);
 }
@@ -80571,254 +80641,36 @@ var init_respond = __esm(() => {
   };
 });
 
-// src/cli/columns/index.tsx
-var exports_columns = {};
-__export(exports_columns, {
-  run: () => run
-});
-async function run(args) {
-  const parsed = await tryParseArgs(args, OPTION_SPEC, HELP);
-  if (typeof parsed === "number")
-    return parsed;
-  if (parsed.values.help) {
-    await writeStdout(HELP);
-    return EXIT2.OK;
-  }
-  setVerboseAck(Boolean(parsed.values.verbose));
-  const filePath = parsed.positionals[0];
-  if (!filePath)
-    return fail("USAGE", "Missing FILE argument", HELP);
-  const at = parsed.values.at;
-  if (!at) {
-    return fail("USAGE", "Missing --at LOCATOR (a range pN-pM or a section sN)", HELP);
-  }
-  const count = parseCount(parsed.values.count);
-  if (typeof count === "number" && Number.isNaN(count)) {
-    return fail("USAGE", `--count must be a positive integer`, HELP);
-  }
-  if (count === undefined)
-    return fail("USAGE", "Missing --count N", HELP);
-  const typeRaw = parsed.values.type;
-  if (typeRaw !== undefined && !isSectionType(typeRaw)) {
-    return fail("USAGE", `Invalid --type: ${typeRaw}`, "Valid values: continuous, nextPage, evenPage, oddPage, nextColumn");
-  }
-  let locator;
-  try {
-    locator = parseLocator(at);
-  } catch (error) {
-    if (error instanceof LocatorParseError) {
-      return fail("INVALID_LOCATOR", error.message, HELP);
-    }
-    throw error;
-  }
-  const document4 = await openOrFail(filePath);
-  if (typeof document4 === "number")
-    return document4;
-  const opts = {
-    filePath,
-    count,
-    sectionType: typeRaw,
-    authorFlag: parsed.values.author,
-    trackFlag: Boolean(parsed.values.track),
-    outputPath: parsed.values.output,
-    dryRun: Boolean(parsed.values["dry-run"])
-  };
-  if (locator.kind === "blockRange") {
-    const range = await resolveBlockRangeOrFail(document4, at);
-    if (typeof range === "number")
-      return range;
-    return wrapRange(document4, range.parent, range.startIndex, range.endIndex, at, opts);
-  }
-  const blockRef = await resolveBlockOrFail(document4, at);
-  if (typeof blockRef === "number")
-    return blockRef;
-  if (blockRef.node.tag === "w:sectPr") {
-    return editSection(document4, blockRef, at, opts);
-  }
-  if (blockRef.node.tag === "w:p") {
-    const index2 = blockRef.parent.indexOf(blockRef.node);
-    return wrapRange(document4, blockRef.parent, index2, index2, at, opts);
-  }
-  return fail("INVALID_LOCATOR", `columns needs a section (sN) or a paragraph range (pN-pM); ${at} is neither`, HELP);
-}
-async function editSection(document4, blockRef, at, opts) {
-  try {
-    new Edit(document4).section(blockRef, { columns: opts.count, sectionType: opts.sectionType }, { authorFlag: opts.authorFlag, track: opts.trackFlag });
-  } catch (error) {
-    if (error instanceof EditError)
-      return fail(error.code, error.message);
-    throw error;
-  }
-  return commit(document4, opts, { at, mode: "section" });
-}
-async function wrapRange(document4, parent, startIndex, endIndex, at, opts) {
-  if (parent !== document4.body.findBodyChildren()) {
-    return fail("USAGE", `columns can only wrap body-level paragraphs; ${at} is inside a table cell`, "Section breaks carry column layout and cannot live in a table cell.");
-  }
-  for (let index2 = startIndex;index2 <= endIndex; index2++) {
-    if (containsSectionBreak(parent[index2])) {
-      return fail("USAGE", `The range ${at} already contains a section break`, "Target the existing section directly with `--at sN`, or pick a range without one.");
-    }
-  }
-  const governing = governingColumns(parent, endIndex + 1);
-  const track = resolveTracked(document4, opts.trackFlag);
-  const insert = new Insert(document4);
-  const allocator = track ? new TrackChanges(document4).createAllocator() : undefined;
-  const endNode = parent[endIndex];
-  if (!endNode) {
-    return fail("BLOCK_NOT_FOUND", "Range end is stale (parent does not contain it)");
-  }
-  const startNode = startIndex > 0 ? parent[startIndex] : undefined;
-  if (startIndex > 0 && !startNode) {
-    return fail("BLOCK_NOT_FOUND", "Range start is stale (parent does not contain it)");
-  }
-  let afterBlocks;
-  let beforeBlocks = [];
-  try {
-    afterBlocks = await insert.paragraph({ node: endNode, parent }, {
-      kind: "section",
-      columns: opts.count,
-      sectionType: opts.sectionType ?? "continuous"
-    }, {}, { placement: "after", authorFlag: opts.authorFlag, track, allocator });
-    if (startNode) {
-      beforeBlocks = await insert.paragraph({ node: startNode, parent }, {
-        kind: "section",
-        ...governing > 1 ? { columns: governing } : {},
-        sectionType: "continuous"
-      }, {}, { placement: "before", authorFlag: opts.authorFlag, track, allocator });
-    }
-  } catch (error) {
-    if (error instanceof InsertError)
-      return fail(error.code, error.message, error.hint);
-    throw error;
-  }
-  if (opts.dryRun) {
-    return commit(document4, opts, { at, mode: "range", dryRunOnly: true });
-  }
-  parent.splice(endIndex + 1, 0, ...afterBlocks);
-  parent.splice(startIndex, 0, ...beforeBlocks);
-  return commit(document4, opts, { at, mode: "range" });
-}
-function containsSectionBreak(node2) {
-  if (!node2)
-    return false;
-  if (node2.tag === "w:sectPr")
-    return true;
-  if (node2.tag !== "w:p")
-    return false;
-  return Boolean(node2.findChild("w:pPr")?.findChild("w:sectPr"));
-}
-function governingColumns(parent, fromIndex) {
-  for (let index2 = fromIndex;index2 < parent.length; index2++) {
-    const node2 = parent[index2];
-    if (!node2)
-      continue;
-    if (node2.tag === "w:sectPr")
-      return columnsOf(node2);
-    if (node2.tag === "w:p") {
-      const inline = node2.findChild("w:pPr")?.findChild("w:sectPr");
-      if (inline)
-        return columnsOf(inline);
-    }
-  }
-  return 1;
+// src/cli/parse-helpers.ts
+function detectMarkdownInPlainText(text6) {
+  if (/\*\*[^*\n]+\*\*/.test(text6))
+    return "bold (**\u2026**)";
+  if (/__[^_\n]+__/.test(text6))
+    return "bold (__\u2026__)";
+  if (/(^|\n) {0,3}#{1,6}\s/.test(text6))
+    return "a heading (#\u2026)";
+  if (/\[[^\]\n]+\]\([^)\n]+\)/.test(text6))
+    return "a link ([text](url))";
+  return null;
 }
-function columnsOf(sectPr) {
-  const raw = sectPr.findChild("w:cols")?.getAttribute("w:num");
-  const parsed = raw ? Number.parseInt(raw, 10) : 1;
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : 1;
+async function rejectMarkdownInText(text6, help) {
+  const found = detectMarkdownInPlainText(text6);
+  if (!found)
+    return null;
+  return await fail("USAGE", `--text writes literal characters, but this value looks like markdown: ${found}. It would be baked in verbatim (e.g. literal ** around the word), not rendered.`, `Use --markdown to parse it (handles ${found}, headings, lists, links), --bold/--italic for a uniformly-emphasized run, or --runs for literal text that really contains these characters. Help:
+${help}`);
 }
-function parseCount(raw) {
-  if (raw === undefined)
-    return;
-  if (!/^\d+$/.test(raw.trim()))
-    return Number.NaN;
-  const parsed = Number.parseInt(raw, 10);
-  if (!Number.isFinite(parsed) || parsed < 1)
-    return Number.NaN;
-  return parsed;
+function detectShellMangledCurrency(text6) {
+  const match = text6.match(/(?<![\d$])([.,]\d{2,})/);
+  return match?.[1] ?? null;
 }
-async function commit(document4, opts, meta) {
-  if (opts.dryRun || meta.dryRunOnly) {
-    await respond({
-      operation: "columns",
-      dryRun: true,
-      path: opts.filePath,
-      locator: meta.at,
-      columnCount: opts.count,
-      mode: meta.mode,
-      ...opts.outputPath ? { output: opts.outputPath } : {}
-    });
-    return EXIT2.OK;
-  }
-  await document4.save(opts.outputPath);
-  await respondAck({
-    ok: true,
-    operation: "columns",
-    path: opts.outputPath ?? opts.filePath,
-    locator: meta.at,
-    columnCount: opts.count,
-    mode: meta.mode
-  });
-  return EXIT2.OK;
+async function rejectShellMangledValue(text6, help, label = "this value") {
+  const fragment = detectShellMangledCurrency(text6);
+  if (!fragment)
+    return null;
+  return await fail("USAGE", `${label} contains "${fragment}" \u2014 a number with no integer part, the signature of a "$" amount gutted by the shell (bash turns double-quoted "$300.00" into ".00" and "$10,000" into ",000"). docx would write the corrupted value verbatim.`, `Wrap any "$"-bearing value in SINGLE quotes ('$300.00') so bash leaves it alone, or supply it via --batch FILE (JSONL never touches the shell). If you really mean "${fragment}", write its integer part (0${fragment}) or use --batch. Help:
+${help}`);
 }
-var HELP = `docx columns \u2014 lay text out in multiple columns
-
-Usage:
-  docx columns FILE --at LOCATOR --count N [options]
-
-The intuitive verb for column layout, so you don't have to hand-build section
-breaks. Two addressing modes:
-
-  --at pN-pM   Wrap the paragraph range pN\u2026pM in its own N-column section
-               (inserts the bounding continuous section breaks for you). Also
-               accepts a single paragraph (--at pN).
-  --at sN      Set the column count on an EXISTING section break sN (the section
-               whose content ENDS at sN). Equivalent to \`edit --at sN --columns N\`.
-
-Options:
-  --at LOCATOR      Paragraph range (pN-pM), single paragraph (pN), or section (sN)
-  --count N         Number of columns (>= 1; use 1 to collapse back to single column)
-  --type T          Section type for the wrapping break: continuous (default),
-                    nextPage, evenPage, oddPage, nextColumn. Only meaningful with
-                    a pN-pM/pN range; with sN it overrides the section's type.
-  --author NAME     Author for tracked changes (default: $DOCX_AUTHOR)
-  --track           Record as a tracked change even when the doc toggle is off
-  -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 full success ack JSON
-  -h, --help        Show this help
-
-Agent tip: VERIFY LAYOUT VISUALLY. \`docx read\` shows the section as a
-\`<!-- docx:section \u2026 cols="N" -->\` annotation but NOT how the columns actually
-flow on the page (balance, overflow). After setting columns, render and look:
-  docx render FILE --out pages/
-Adjust the range and re-render until the columns read the way you intended.
-
-Output:
-  Prints a one-line confirmation on success (exit 0); --verbose prints {ok:true, \u2026}. Positional ids shift
-  after a range wrap (two section breaks are inserted), so re-read before further
-  edits. Errors print {code, error, hint?} + nonzero exit.
-
-Examples:
-  docx columns doc.docx --at p4-p9 --count 2
-  docx columns doc.docx --at p4-p9 --count 3 --type continuous
-  docx columns doc.docx --at s2 --count 1        # collapse section s2 to one column
-`, OPTION_SPEC;
-var init_columns = __esm(() => {
-  init_core2();
-  init_respond();
-  OPTION_SPEC = {
-    at: { type: "string" },
-    count: { type: "string" },
-    type: { type: "string" },
-    author: { type: "string" },
-    track: { type: "boolean" },
-    ...SAVE_FLAGS
-  };
-});
-
-// src/cli/parse-helpers.ts
 function parseTaskFlag(value) {
   const normalized = value.toLowerCase();
   if (normalized === "checked" || normalized === "true" || normalized === "1")
@@ -80849,9 +80701,9 @@ async function parseRunsArg(json2) {
     return fail("USAGE", "--runs must be a JSON array of Run objects");
   }
   const runs = parsed;
-  for (const run2 of runs) {
-    if (run2 !== null && typeof run2 === "object" && run2.type === "text") {
-      const invalid = firstInvalidRunFormat(run2);
+  for (const run of runs) {
+    if (run !== null && typeof run === "object" && run.type === "text") {
+      const invalid = firstInvalidRunFormat(run);
       if (invalid) {
         return fail("USAGE", `Invalid ${invalid.field} "${invalid.value}" in a --runs text run`, `Use ${invalid.valid}.`);
       }
@@ -80937,9 +80789,9 @@ var init_parse_helpers = __esm(() => {
 // src/cli/comments/add.tsx
 var exports_add = {};
 __export(exports_add, {
-  run: () => run2
+  run: () => run
 });
-async function run2(args) {
+async function run(args) {
   const parsed = await tryParseArgs(args, {
     at: { type: "string" },
     anchor: { type: "string" },
@@ -80950,17 +80802,17 @@ async function run2(args) {
     current: { type: "boolean" },
     baseline: { type: "boolean" },
     ...SAVE_FLAGS
-  }, HELP2);
+  }, HELP);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP2);
+    await writeStdout(HELP);
     return EXIT2.OK;
   }
   setVerboseAck(Boolean(parsed.values.verbose));
   const path2 = parsed.positionals[0];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP2);
+    return fail("USAGE", "Missing FILE argument", HELP);
   const atInput = parsed.values.at;
   const anchorInput = parsed.values.anchor;
   const batchInput = parsed.values.batch;
@@ -80975,10 +80827,10 @@ async function run2(args) {
   }
   const anchorCount = (atInput ? 1 : 0) + (anchorInput ? 1 : 0) + (batchInput ? 1 : 0);
   if (anchorCount === 0) {
-    return fail("USAGE", "Specify exactly one of --at, --anchor, or --batch", HELP2);
+    return fail("USAGE", "Specify exactly one of --at, --anchor, or --batch", HELP);
   }
   if (anchorCount > 1) {
-    return fail("USAGE", "--at, --anchor, and --batch are mutually exclusive", HELP2);
+    return fail("USAGE", "--at, --anchor, and --batch are mutually exclusive", HELP);
   }
   const document4 = await openOrFail(path2);
   if (typeof document4 === "number")
@@ -80986,7 +80838,7 @@ async function run2(args) {
   let rawEntries;
   if (batchInput) {
     if (text6 !== undefined || atInput || anchorInput || occurrenceRaw) {
-      return fail("USAGE", "--batch reads each entry's at/anchor/text/author from JSONL \u2014 do not pass them on the CLI", HELP2);
+      return fail("USAGE", "--batch reads each entry's at/anchor/text/author from JSONL \u2014 do not pass them on the CLI", HELP);
     }
     try {
       rawEntries = await readJsonlObjects(batchInput);
@@ -80999,7 +80851,7 @@ async function run2(args) {
     }
   } else {
     if (!text6)
-      return fail("USAGE", "Missing --text TEXT", HELP2);
+      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}"`);
@@ -81173,14 +81025,14 @@ function resolveAnchorEntry(document4, anchor, occurrence, occurrenceExplicit, t
     locatorString
   };
 }
-var AT_FORMS, HELP2, EntryError;
+var AT_FORMS, HELP, EntryError;
 var init_add = __esm(() => {
   init_core2();
   init_find();
   init_parse_helpers();
   init_respond();
   AT_FORMS = describeForms(["paragraph", "span", "crossSpan", "cellParagraph", "cellSpan"], "                        ");
-  HELP2 = `docx comments add \u2014 anchor a new comment to a locator or phrase
+  HELP = `docx comments add \u2014 anchor a new comment to a locator or phrase
 
 Usage:
   docx comments add FILE --at LOCATOR --text TEXT [options]
@@ -81254,31 +81106,31 @@ Batch JSONL example:
 // src/cli/comments/delete.ts
 var exports_delete = {};
 __export(exports_delete, {
-  run: () => run3
+  run: () => run2
 });
-async function run3(args) {
+async function run2(args) {
   const parsed = await tryParseArgs(args, {
     at: { type: "string", multiple: true },
     batch: { type: "string" },
     ...SAVE_FLAGS
-  }, HELP3);
+  }, HELP2);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP3);
+    await writeStdout(HELP2);
     return EXIT2.OK;
   }
   setVerboseAck(Boolean(parsed.values.verbose));
   const path2 = parsed.positionals[0];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP3);
+    return fail("USAGE", "Missing FILE argument", HELP2);
   const atValues = parsed.values.at ?? [];
   const batchInput = parsed.values.batch;
   if (atValues.length > 0 && batchInput) {
-    return fail("USAGE", "--at and --batch are mutually exclusive", HELP3);
+    return fail("USAGE", "--at and --batch are mutually exclusive", HELP2);
   }
   if (atValues.length === 0 && !batchInput) {
-    return fail("USAGE", "Specify --at cN (repeatable) or --batch FILE", HELP3);
+    return fail("USAGE", "Specify --at cN (repeatable) or --batch FILE", HELP2);
   }
   let rawIds;
   if (batchInput) {
@@ -81333,7 +81185,7 @@ async function run3(args) {
   });
   return EXIT2.OK;
 }
-var HELP3 = `docx comments delete \u2014 remove one or more comments
+var HELP2 = `docx comments delete \u2014 remove one or more comments
 
 Usage:
   docx comments delete FILE --at cN [--at cM ...] [options]
@@ -81372,23 +81224,23 @@ var init_delete = __esm(() => {
 // src/cli/comments/list.ts
 var exports_list = {};
 __export(exports_list, {
-  run: () => run4
+  run: () => run3
 });
-async function run4(args) {
+async function run3(args) {
   const parsed = await tryParseArgs(args, {
     "include-resolved": { type: "boolean" },
     thread: { type: "string" },
     help: { type: "boolean", short: "h" }
-  }, HELP4);
+  }, HELP3);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP4);
+    await writeStdout(HELP3);
     return EXIT2.OK;
   }
   const path2 = parsed.positionals[0];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP4);
+    return fail("USAGE", "Missing FILE argument", HELP3);
   const document4 = await openOrFail(path2);
   if (typeof document4 === "number")
     return document4;
@@ -81399,7 +81251,7 @@ async function run4(args) {
   await respond(comments);
   return EXIT2.OK;
 }
-var HELP4 = `docx comments list \u2014 print existing comments as JSON
+var HELP3 = `docx comments list \u2014 print existing comments as JSON
 
 Usage:
   docx comments list FILE [options]
@@ -81427,31 +81279,31 @@ var init_list3 = __esm(() => {
 // src/cli/comments/reply.tsx
 var exports_reply = {};
 __export(exports_reply, {
-  run: () => run5
+  run: () => run4
 });
-async function run5(args) {
+async function run4(args) {
   const parsed = await tryParseArgs(args, {
     at: { type: "string" },
     text: { type: "string" },
     author: { type: "string" },
     ...SAVE_FLAGS
-  }, HELP5);
+  }, HELP4);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP5);
+    await writeStdout(HELP4);
     return EXIT2.OK;
   }
   setVerboseAck(Boolean(parsed.values.verbose));
   const path2 = parsed.positionals[0];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP5);
+    return fail("USAGE", "Missing FILE argument", HELP4);
   const parentInput = parsed.values.at;
   const text6 = parsed.values.text;
   if (!parentInput)
-    return fail("USAGE", "Missing --at cN", HELP5);
+    return fail("USAGE", "Missing --at cN", HELP4);
   if (!text6)
-    return fail("USAGE", "Missing --text TEXT", HELP5);
+    return fail("USAGE", "Missing --text TEXT", HELP4);
   const document4 = await openOrFail(path2);
   if (typeof document4 === "number")
     return document4;
@@ -81492,7 +81344,7 @@ async function run5(args) {
   });
   return EXIT2.OK;
 }
-var HELP5 = `docx comments reply \u2014 reply to an existing comment
+var HELP4 = `docx comments reply \u2014 reply to an existing comment
 
 Usage:
   docx comments reply FILE --at cN --text TEXT [options]
@@ -81525,33 +81377,33 @@ var init_reply = __esm(() => {
 // src/cli/comments/resolve.ts
 var exports_resolve = {};
 __export(exports_resolve, {
-  run: () => run6
+  run: () => run5
 });
-async function run6(args) {
+async function run5(args) {
   const parsed = await tryParseArgs(args, {
     at: { type: "string", multiple: true },
     batch: { type: "string" },
     unset: { type: "boolean" },
     ...SAVE_FLAGS
-  }, HELP6);
+  }, HELP5);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP6);
+    await writeStdout(HELP5);
     return EXIT2.OK;
   }
   setVerboseAck(Boolean(parsed.values.verbose));
   const path2 = parsed.positionals[0];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP6);
+    return fail("USAGE", "Missing FILE argument", HELP5);
   const atValues = parsed.values.at ?? [];
   const batchInput = parsed.values.batch;
   const resolved = !parsed.values.unset;
   if (atValues.length > 0 && batchInput) {
-    return fail("USAGE", "--at and --batch are mutually exclusive", HELP6);
+    return fail("USAGE", "--at and --batch are mutually exclusive", HELP5);
   }
   if (atValues.length === 0 && !batchInput) {
-    return fail("USAGE", "Specify --at cN (repeatable) or --batch FILE", HELP6);
+    return fail("USAGE", "Specify --at cN (repeatable) or --batch FILE", HELP5);
   }
   let rawIds;
   if (batchInput) {
@@ -81608,7 +81460,7 @@ async function run6(args) {
   });
   return EXIT2.OK;
 }
-var HELP6 = `docx comments resolve \u2014 mark one or more comments resolved
+var HELP5 = `docx comments resolve \u2014 mark one or more comments resolved
 
 Usage:
   docx comments resolve FILE --at cN [--at cM ...] [options]
@@ -81649,12 +81501,12 @@ var init_resolve2 = __esm(() => {
 // src/cli/comments/index.ts
 var exports_comments = {};
 __export(exports_comments, {
-  run: () => run7
+  run: () => run6
 });
-async function run7(args) {
+async function run6(args) {
   const verb = args[0];
   if (!verb || verb === "--help" || verb === "-h" || verb === "help") {
-    await writeStdout(HELP7);
+    await writeStdout(HELP6);
     return verb ? 0 : 2;
   }
   const loader = SUBCOMMANDS[verb];
@@ -81664,7 +81516,7 @@ async function run7(args) {
   const module_ = await loader();
   return module_.run(args.slice(1));
 }
-var SUBCOMMANDS, HELP7 = `docx comments \u2014 manage Word comments
+var SUBCOMMANDS, HELP6 = `docx comments \u2014 manage Word comments
 
 Usage:
   docx comments <verb> FILE [options]
@@ -81984,9 +81836,9 @@ var init_create = __esm(() => {
 // src/cli/create/index.tsx
 var exports_create = {};
 __export(exports_create, {
-  run: () => run8
+  run: () => run7
 });
-async function run8(args) {
+async function run7(args) {
   const parsed = await tryParseArgs(args, {
     title: { type: "string" },
     author: { type: "string" },
@@ -81996,17 +81848,17 @@ async function run8(args) {
     "dry-run": { type: "boolean" },
     verbose: { type: "boolean", short: "v" },
     help: { type: "boolean", short: "h" }
-  }, HELP8);
+  }, HELP7);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP8);
+    await writeStdout(HELP7);
     return EXIT2.OK;
   }
   setVerboseAck(Boolean(parsed.values.verbose));
   const path2 = parsed.positionals[0];
   if (!path2) {
-    return fail("USAGE", "Missing FILE argument", HELP8);
+    return fail("USAGE", "Missing FILE argument", HELP7);
   }
   const text6 = parsed.values.text;
   const fromPath = parsed.values.from;
@@ -82078,7 +81930,7 @@ async function applyMarkdownToBody(docxPath, markdownPath) {
   await document4.save();
   return { blockCount: blocks.length };
 }
-var HELP8 = `docx create \u2014 create a new minimal .docx
+var HELP7 = `docx create \u2014 create a new minimal .docx
 
 Usage:
   docx create FILE [options]
@@ -82220,27 +82072,27 @@ var init_batch = __esm(() => {
 // src/cli/delete/index.tsx
 var exports_delete2 = {};
 __export(exports_delete2, {
-  run: () => run9
+  run: () => run8
 });
-async function run9(args) {
-  const parsed = await tryParseArgs(args, OPTION_SPEC2, HELP9);
+async function run8(args) {
+  const parsed = await tryParseArgs(args, OPTION_SPEC, HELP8);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP9);
+    await writeStdout(HELP8);
     return EXIT2.OK;
   }
   setVerboseAck(Boolean(parsed.values.verbose));
   const filePath = parsed.positionals[0];
   if (!filePath)
-    return fail("USAGE", "Missing FILE argument", HELP9);
+    return fail("USAGE", "Missing FILE argument", HELP8);
   const batchSource = parsed.values.batch;
   if (batchSource !== undefined) {
     return runDeleteBatch(filePath, batchSource, parsed.values);
   }
   const locator = parsed.values.at;
   if (!locator)
-    return fail("USAGE", "Missing --at LOCATOR (or --batch FILE)", HELP9);
+    return fail("USAGE", "Missing --at LOCATOR (or --batch FILE)", HELP8);
   const opts = {
     filePath,
     locator,
@@ -82358,7 +82210,7 @@ function findBodyChildren(document4) {
     return null;
   return body.children;
 }
-var HELP9 = `docx delete \u2014 remove a block at a locator
+var HELP8 = `docx delete \u2014 remove a block at a locator
 
 Usage:
   docx delete FILE --at LOCATOR [options]
@@ -82397,7 +82249,7 @@ Tracked behavior:
   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.
+  section sentinel paragraphs have no runs) the mutation is silent.
   delete --at tN under tracking is rejected (tracked table-row deletion is
   not supported).
 
@@ -82410,7 +82262,7 @@ Examples:
   docx delete doc.docx --at t0
   docx delete doc.docx --at s2
   docx delete doc.docx --batch drop.jsonl   # {"at":"p26"} per line
-`, OPTION_SPEC2;
+`, OPTION_SPEC;
 var init_delete2 = __esm(() => {
   init_core2();
   init_comments2();
@@ -82418,7 +82270,7 @@ var init_delete2 = __esm(() => {
   init_replace();
   init_respond();
   init_batch();
-  OPTION_SPEC2 = {
+  OPTION_SPEC = {
     at: { type: "string" },
     batch: { type: "string" },
     author: { type: "string" },
@@ -82427,6 +82279,42 @@ var init_delete2 = __esm(() => {
   };
 });
 
+// src/cli/edit/tabs.ts
+function parseTabsValue(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "right" || normalized === "right-margin")
+    return { kind: "right-margin" };
+  if (normalized === "clear" || normalized === "none" || normalized === "off")
+    return { kind: "clear" };
+  const stops = [];
+  for (const token of value.split(",")) {
+    const match = token.trim().match(/^(left|right|center)@([\d.]+)in$/i);
+    const align = (match?.[1] ?? "").toLowerCase();
+    const inches = Number(match?.[2] ?? Number.NaN);
+    if (!match || !TAB_ALIGNS.has(align) || !Number.isFinite(inches)) {
+      return {
+        error: `Invalid --tabs value: "${token.trim()}"`,
+        hint: TABS_HINT
+      };
+    }
+    stops.push({ align, pos: Math.round(inches * 1440) });
+  }
+  return { kind: "explicit", stops };
+}
+function resolveTabsDirective(directive, document4) {
+  if (directive.kind === "clear")
+    return [];
+  if (directive.kind === "explicit")
+    return directive.stops;
+  const marginTwips = Math.round(getPageContentWidthEmu(document4) / 635);
+  return [{ align: "right", pos: marginTwips }];
+}
+var TAB_ALIGNS, TABS_HINT = "Use `right` (a right tab at the margin \u2014 cures the wrapping LEFT-tab `docx:layout` warning from `read`), `clear`, or explicit stops like `right@7.5in` / `left@1in,right@7.5in`.";
+var init_tabs = __esm(() => {
+  init_core2();
+  TAB_ALIGNS = new Set(["left", "right", "center"]);
+});
+
 // src/cli/edit/batch.ts
 async function runEditBatch(filePath, batchSource, values2) {
   const conflicting = SINGLE_SHOT_FLAGS.find((flag) => values2[flag] !== undefined && values2[flag] !== false);
@@ -82512,13 +82400,14 @@ async function runEditBatch(filePath, batchSource, values2) {
 async function resolveEntry2(document4, raw, index2, opts) {
   const present = CONTENT_KEYS.filter((key) => raw[key] !== undefined);
   const hasClear = raw.clear !== undefined;
-  if (present.length === 0 && !hasClear) {
-    throw new EntryError2("USAGE", `entry ${index2}: no content \u2014 provide one of ${CONTENT_KEYS.join(", ")}, or "clear"`);
+  const hasProps = raw.style !== undefined || raw.alignment !== undefined || raw.tabs !== undefined;
+  if (present.length === 0 && !hasClear && !hasProps) {
+    throw new EntryError2("USAGE", `entry ${index2}: no content \u2014 provide one of ${CONTENT_KEYS.join(", ")}, "clear", or "style"/"alignment"/"tabs" to adjust in place`);
   }
   if (present.length > 1) {
     throw new EntryError2("USAGE", `entry ${index2}: provide exactly one content field, got ${present.join(", ")}`);
   }
-  const kind = present[0] ?? "clear";
+  const kind = present[0] ?? (hasClear ? "clear" : "props");
   const at = raw.at;
   if (typeof at !== "string" || at.length === 0) {
     throw new EntryError2("USAGE", `entry ${index2}: "at" is required`);
@@ -82557,6 +82446,13 @@ async function resolveEntry2(document4, raw, index2, opts) {
 async function buildApply(document4, raw, index2, kind, blockRef, span, opts) {
   const author = typeof raw.author === "string" ? raw.author : opts.authorFlag;
   const clearTags = raw.clear !== undefined ? resolveClearOrThrow(raw.clear, index2) : null;
+  if (kind === "props") {
+    if (span) {
+      throw new EntryError2("USAGE", `entry ${index2}: a character span (${raw.at}) can't take "style"/"alignment" \u2014 restyle the whole paragraph (pN).`);
+    }
+    const paragraphOptions = readParagraphOptions(document4, raw, index2);
+    return () => void new Edit(document4).paragraphProperties(blockRef, paragraphOptions);
+  }
   if (kind === "clear") {
     const tags = clearTags ?? new Set;
     return () => new Edit(document4).clearFormatting(blockRef, span, tags);
@@ -82591,9 +82487,12 @@ async function buildApply(document4, raw, index2, kind, blockRef, span, opts) {
   };
 }
 async function buildWholeParagraphContent(document4, raw, index2, kind, blockRef, author, opts) {
-  const paragraphOptions = readParagraphOptions(raw, index2);
+  const paragraphOptions = readParagraphOptions(document4, raw, index2);
   if (kind === "text") {
     const text6 = requireString(raw.text, index2, "text");
+    if (text6 === "") {
+      throw new EntryError2("USAGE", `entry ${index2}: empty "text" leaves a blank paragraph in place, it doesn't remove the line (${raw.at}).`, 'Remove lines with `docx delete --batch` ({ "at": "pN" } per line). To keep an empty spacer, use "runs": [] instead.');
+    }
     const format = readTextFormat(raw, index2);
     return () => new Edit(document4).paragraph(blockRef, { kind: "text", text: text6, format, paragraphOptions }, {
       authorFlag: author,
@@ -82691,8 +82590,8 @@ function rejectSpanFormatFlags(raw, index2) {
   if (raw.color !== undefined || raw.bold !== undefined || raw.italic !== undefined) {
     throw new EntryError2("USAGE", `entry ${index2}: --color/--bold/--italic aren't supported on a character span \u2014 the replacement inherits the run's formatting`);
   }
-  if (raw.style !== undefined || raw.alignment !== undefined) {
-    throw new EntryError2("USAGE", `entry ${index2}: style/alignment apply to a whole paragraph, not a character span`);
+  if (raw.style !== undefined || raw.alignment !== undefined || raw.tabs !== undefined) {
+    throw new EntryError2("USAGE", `entry ${index2}: style/alignment/tabs apply to a whole paragraph, not a character span`);
   }
 }
 function readTextFormat(raw, index2) {
@@ -82709,7 +82608,7 @@ function readTextFormat(raw, index2) {
     out.italic = Boolean(raw.italic);
   return out;
 }
-function readParagraphOptions(raw, index2) {
+function readParagraphOptions(document4, raw, index2) {
   const out = {};
   if (raw.style !== undefined) {
     if (typeof raw.style !== "string") {
@@ -82724,15 +82623,25 @@ function readParagraphOptions(raw, index2) {
     }
     out.alignment = alignment;
   }
+  if (raw.tabs !== undefined) {
+    if (typeof raw.tabs !== "string") {
+      throw new EntryError2("USAGE", `entry ${index2}: "tabs" must be a string`);
+    }
+    const parsed = parseTabsValue(raw.tabs);
+    if ("error" in parsed) {
+      throw new EntryError2("USAGE", `entry ${index2}: ${parsed.error}`, parsed.hint);
+    }
+    out.tabs = resolveTabsDirective(parsed, document4);
+  }
   return out;
 }
 function readRuns(value, index2) {
   if (!Array.isArray(value)) {
     throw new EntryError2("USAGE", `entry ${index2}: "runs" must be a JSON array of Run objects`);
   }
-  for (const run10 of value) {
-    if (run10 !== null && typeof run10 === "object" && run10.type === "text") {
-      const invalid = firstInvalidRunFormat(run10);
+  for (const run9 of value) {
+    if (run9 !== null && typeof run9 === "object" && run9.type === "text") {
+      const invalid = firstInvalidRunFormat(run9);
       if (invalid) {
         throw new EntryError2("USAGE", `entry ${index2}: invalid ${invalid.field} "${invalid.value}" in a run`, `Use ${invalid.valid}.`);
       }
@@ -82761,6 +82670,7 @@ var init_batch2 = __esm(() => {
   init_run_formatting();
   init_parse_helpers();
   init_respond();
+  init_tabs();
   SINGLE_SHOT_FLAGS = [
     "at",
     "text",
@@ -82778,6 +82688,7 @@ var init_batch2 = __esm(() => {
     "type",
     "style",
     "alignment",
+    "tabs",
     "color",
     "bold",
     "italic"
@@ -82798,20 +82709,20 @@ var init_batch2 = __esm(() => {
 // src/cli/edit/index.tsx
 var exports_edit = {};
 __export(exports_edit, {
-  run: () => run10
+  run: () => run9
 });
-async function run10(args) {
-  const parsed = await tryParseArgs(args, OPTION_SPEC3, HELP10);
+async function run9(args) {
+  const parsed = await tryParseArgs(args, OPTION_SPEC2, HELP9);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP10);
+    await writeStdout(HELP9);
     return EXIT2.OK;
   }
   setVerboseAck(Boolean(parsed.values.verbose));
   const filePath = parsed.positionals[0];
   if (!filePath)
-    return fail("USAGE", "Missing FILE argument", HELP10);
+    return fail("USAGE", "Missing FILE argument", HELP9);
   const batchInput = parsed.values.batch;
   if (batchInput !== undefined) {
     return runEditBatch(filePath, batchInput, parsed.values);
@@ -82822,9 +82733,12 @@ async function run10(args) {
   const document4 = await openOrFail(opts.filePath);
   if (typeof document4 === "number")
     return document4;
+  if (opts.tabsDirective) {
+    injectTabsIntoSpec(opts.spec, resolveTabsDirective(opts.tabsDirective, document4));
+  }
   if (isBlockRangeLocator2(opts.locator)) {
     if (opts.spec.kind === "section") {
-      return fail("USAGE", "Range locators (pN-pM) don't accept --columns/--type \u2014 use sN for section edits", HELP10);
+      return fail("USAGE", "Range locators (pN-pM) don't accept --columns/--type \u2014 use sN for section edits", HELP9);
     }
     return commitRangeEdit(document4, opts);
   }
@@ -82857,14 +82771,14 @@ function spanLocatorTarget(locator) {
 async function commitSpanEdit(document4, spanTarget, opts) {
   const spec = opts.spec;
   if (spec.kind !== "text" && spec.kind !== "clear") {
-    return fail("USAGE", "A character-span locator (pN:S-E) supports --text or --clear. Use a whole-paragraph locator (pN) for --markdown/--runs/--code.", HELP10);
+    return fail("USAGE", "A character-span locator (pN:S-E) supports --text or --clear. Use a whole-paragraph locator (pN) for --markdown/--runs/--code.", HELP9);
   }
   if (spec.kind === "text") {
     if (spec.format.color || spec.format.bold || spec.format.italic) {
-      return fail("USAGE", "--color/--bold/--italic aren't supported on a character span \u2014 the replacement inherits the existing run's formatting. Edit the whole paragraph (pN) to set uniform run formatting.", HELP10);
+      return fail("USAGE", "--color/--bold/--italic aren't supported on a character span \u2014 the replacement inherits the existing run's formatting. Edit the whole paragraph (pN) to set uniform run formatting.", HELP9);
     }
     if (spec.paragraphOptions.style || spec.paragraphOptions.alignment) {
-      return fail("USAGE", "--style/--alignment apply to a whole paragraph, not a character span (pN:S-E).", HELP10);
+      return fail("USAGE", "--style/--alignment apply to a whole paragraph, not a character span (pN:S-E).", HELP9);
     }
   }
   const blockRef = await resolveBlockOrFail(document4, spanTarget.blockId);
@@ -82928,6 +82842,8 @@ async function commitBlockEdit(document4, blockRef, opts) {
       });
     } else if (opts.spec.kind === "clear") {
       edit.clearFormatting(blockRef, null, opts.spec.tags);
+    } else if (opts.spec.kind === "paragraphProps") {
+      resultNode = edit.paragraphProperties(blockRef, opts.spec.paragraphOptions);
     } else {
       return fail("USAGE", "Unsupported edit spec for single-block locator");
     }
@@ -82945,13 +82861,16 @@ async function commitBlockEdit(document4, blockRef, opts) {
 }
 async function commitRangeEdit(document4, opts) {
   if (opts.spec.kind === "section") {
-    return fail("USAGE", "Section edits don't support range locators", HELP10);
+    return fail("USAGE", "Section edits don't support range locators", HELP9);
   }
   if (opts.spec.kind === "task") {
-    return fail("USAGE", "--task takes a single paragraph locator (pN), not a range", HELP10);
+    return fail("USAGE", "--task takes a single paragraph locator (pN), not a range", HELP9);
   }
   if (opts.spec.kind === "equation") {
-    return fail("USAGE", "--equation takes a single equation locator (eqN), not a paragraph range", HELP10);
+    return fail("USAGE", "--equation takes a single equation locator (eqN), not a paragraph range", HELP9);
+  }
+  if (opts.spec.kind === "paragraphProps") {
+    return commitRangeProps(document4, opts, opts.spec.paragraphOptions);
   }
   const rangeRef = await resolveBlockRangeOrFail(document4, opts.locator);
   if (typeof rangeRef === "number")
@@ -82983,6 +82902,53 @@ async function commitRangeEdit(document4, opts) {
   await document4.save(opts.outputPath);
   return emitEditAck(opts);
 }
+async function commitRangeProps(document4, opts, options) {
+  const rangeRef = await resolveBlockRangeOrFail(document4, opts.locator);
+  if (typeof rangeRef === "number")
+    return rangeRef;
+  if (opts.dryRun)
+    return respondDryRun2(opts);
+  let applied = 0;
+  try {
+    const edit = new Edit(document4);
+    for (let index2 = rangeRef.startIndex;index2 <= rangeRef.endIndex; index2++) {
+      const node2 = rangeRef.parent[index2];
+      if (!node2 || node2.tag !== "w:p")
+        continue;
+      const perParagraph = scopeRangeProps(node2, options);
+      if (!perParagraph)
+        continue;
+      edit.paragraphProperties({ node: node2, parent: rangeRef.parent }, perParagraph);
+      applied++;
+    }
+  } catch (error) {
+    if (error instanceof EditError) {
+      return fail(error.code, error.message, error.hint);
+    }
+    throw error;
+  }
+  if (applied === 0) {
+    return fail("BLOCK_NOT_FOUND", options.tabs !== undefined ? `No paragraphs with tab stops in ${opts.locator} \u2014 --tabs only adjusts tab-using lines (the ones \`read\` flags with docx:layout).` : `No paragraphs in ${opts.locator} to restyle.`);
+  }
+  await document4.save(opts.outputPath);
+  return emitEditAck(opts);
+}
+function scopeRangeProps(node2, options) {
+  const out = {};
+  if (options.style !== undefined)
+    out.style = options.style;
+  if (options.alignment !== undefined)
+    out.alignment = options.alignment;
+  if (options.tabs !== undefined && paragraphHasTabStops(node2)) {
+    out.tabs = options.tabs;
+  }
+  if (out.style === undefined && out.alignment === undefined && out.tabs === undefined)
+    return null;
+  return out;
+}
+function paragraphHasTabStops(node2) {
+  return node2.findChild("w:pPr")?.findChild("w:tabs") !== undefined;
+}
 async function commitEquationEdit(document4, spec, opts) {
   if (spec.latex === undefined && spec.display === undefined) {
     return fail("USAGE", "--equation requires --equation NEW_LATEX, --display, or --inline");
@@ -83013,10 +82979,17 @@ async function commitEquationEdit(document4, spec, opts) {
 async function validateSingleShotOptions(filePath, values2) {
   const locator = values2.at;
   if (!locator)
-    return fail("USAGE", "Missing --at LOCATOR", HELP10);
+    return fail("USAGE", "Missing --at LOCATOR", HELP9);
   const paragraphOptions = await parseParagraphOptions(values2);
   if (typeof paragraphOptions === "number")
     return paragraphOptions;
+  let tabsDirective;
+  if (values2.tabs !== undefined) {
+    const parsed = parseTabsValue(values2.tabs);
+    if ("error" in parsed)
+      return fail("USAGE", parsed.error, parsed.hint);
+    tabsDirective = parsed;
+  }
   const isSectionLocator = /^s\d+$/.test(locator);
   const spec = isSectionLocator ? await validateSectionEdit(values2) : await validateParagraphEdit(values2, paragraphOptions);
   if (typeof spec === "number")
@@ -83037,15 +83010,16 @@ async function validateSingleShotOptions(filePath, values2) {
     outputPath: values2.output,
     dryRun: Boolean(values2["dry-run"]),
     noFormatting: Boolean(values2["no-formatting"]),
-    ...clearTags ? { clearTags } : {}
+    ...clearTags ? { clearTags } : {},
+    ...tabsDirective ? { tabsDirective } : {}
   };
 }
 async function validateSectionEdit(values2) {
   if (values2.text !== undefined || values2.runs !== undefined) {
-    return fail("USAGE", "Section locators (sN) take --columns and --type, not --text/--runs", HELP10);
+    return fail("USAGE", "Section locators (sN) take --columns and --type, not --text/--runs", HELP9);
   }
   if (values2.columns === undefined && values2.type === undefined) {
-    return fail("USAGE", "Section edit requires --columns and/or --type", HELP10);
+    return fail("USAGE", "Section edit requires --columns and/or --type", HELP9);
   }
   const sectionFlags = await parseSectionFlags(values2);
   if (typeof sectionFlags === "number")
@@ -83056,22 +83030,22 @@ async function parseClearTagsOrFail(clearFlag) {
   const raw = Array.isArray(clearFlag) ? clearFlag : [clearFlag];
   const names = raw.flatMap((entry) => entry.split(",")).map((name) => name.trim().toLowerCase()).filter(Boolean);
   if (names.length === 0) {
-    return fail("USAGE", "--clear needs an attribute name, or 'all'", HELP10);
+    return fail("USAGE", "--clear needs an attribute name, or 'all'", HELP9);
   }
   const tags = resolveClearTags(names);
   if (!tags) {
-    return fail("USAGE", `--clear: unknown attribute in "${raw.join(",")}". Valid: ${CLEARABLE_ATTRS.join(", ")}, all`, HELP10);
+    return fail("USAGE", `--clear: unknown attribute in "${raw.join(",")}". Valid: ${CLEARABLE_ATTRS.join(", ")}, all`, HELP9);
   }
   return tags;
 }
 async function validateParagraphEdit(values2, paragraphOptions) {
   if (values2.columns !== undefined || values2.type !== undefined) {
-    return fail("USAGE", "--columns and --type require a section locator (sN)", HELP10);
+    return fail("USAGE", "--columns and --type require a section locator (sN)", HELP9);
   }
   const clearFlag = values2.clear;
   if (clearFlag !== undefined) {
     if (values2.equation !== undefined || values2.display === true || values2.inline === true) {
-      return fail("USAGE", "--clear can't be combined with --equation/--display/--inline", HELP10);
+      return fail("USAGE", "--clear can't be combined with --equation/--display/--inline", HELP9);
     }
     const hasContent = [
       "text",
@@ -83108,10 +83082,10 @@ async function validateParagraphEdit(values2, paragraphOptions) {
       taskFlag !== undefined
     ].filter(Boolean).length;
     if (otherContent > 0) {
-      return fail("USAGE", "--equation / --display / --inline cannot be combined with --text/--runs/--code/--code-file/--task", HELP10);
+      return fail("USAGE", "--equation / --display / --inline cannot be combined with --text/--runs/--code/--code-file/--task", HELP9);
     }
     if (displayFlag && inlineFlag) {
-      return fail("USAGE", "--display and --inline are mutually exclusive", HELP10);
+      return fail("USAGE", "--display and --inline are mutually exclusive", HELP9);
     }
     const displayMode = displayFlag ? true : inlineFlag ? false : undefined;
     return {
@@ -83129,11 +83103,11 @@ async function validateParagraphEdit(values2, paragraphOptions) {
       codeFile !== undefined
     ].filter(Boolean).length;
     if (otherFlags > 0) {
-      return fail("USAGE", "--task cannot be combined with --text, --runs, --code, or --code-file", HELP10);
+      return fail("USAGE", "--task cannot be combined with --text, --runs, --code, or --code-file", HELP9);
     }
     const checked = parseTaskFlag(taskFlag);
     if (checked === null) {
-      return fail("USAGE", `--task must be "checked" or "unchecked", got "${taskFlag}"`, HELP10);
+      return fail("USAGE", `--task must be "checked" or "unchecked", got "${taskFlag}"`, HELP9);
     }
     return { kind: "task", checked };
   }
@@ -83148,15 +83122,29 @@ async function validateParagraphEdit(values2, paragraphOptions) {
     markdownFile !== undefined
   ].filter(Boolean).length;
   if (contentFlags === 0) {
-    return fail("USAGE", "Missing content: pass --text, --runs, --code, --code-file, --markdown, --markdown-file, --task, or --equation", HELP10);
+    if (paragraphOptions.style || paragraphOptions.alignment || values2.tabs !== undefined) {
+      return { kind: "paragraphProps", paragraphOptions };
+    }
+    return fail("USAGE", "Missing content: pass --text, --runs, --code, --code-file, --markdown, --markdown-file, --task, or --equation \u2014 or --style/--alignment/--tabs to adjust the paragraph in place", HELP9);
   }
   if (contentFlags > 1) {
-    return fail("USAGE", "Pass only one of --text, --runs, --code, --code-file, --markdown, --markdown-file", HELP10);
+    return fail("USAGE", "Pass only one of --text, --runs, --code, --code-file, --markdown, --markdown-file", HELP9);
   }
   if (language !== undefined && codeInline === undefined && codeFile === undefined) {
-    return fail("USAGE", "--language requires --code or --code-file", HELP10);
+    return fail("USAGE", "--language requires --code or --code-file", HELP9);
   }
   if (text6 !== undefined) {
+    const at = values2.at;
+    if (text6 === "" && !(at && spanLocatorTarget(at))) {
+      return fail("USAGE", `Empty --text leaves a blank paragraph in place, it doesn't remove the line.`, `To DELETE the paragraph: \`docx delete --at ${at ?? "pN"}\` (or \`docx delete --batch\` for many). To delete just SOME characters, use a span locator (\`--at pN:S-E --text ""\`). To blank the paragraph but keep an empty spacer, pass --runs '[]'. Help:
+${HELP9}`);
+    }
+    const rejected = await rejectMarkdownInText(text6, HELP9);
+    if (typeof rejected === "number")
+      return rejected;
+    const mangled = await rejectShellMangledValue(text6, HELP9, "--text");
+    if (typeof mangled === "number")
+      return mangled;
     return {
       kind: "text",
       text: text6,
@@ -83182,7 +83170,7 @@ async function validateParagraphEdit(values2, paragraphOptions) {
   if (markdownInline !== undefined || markdownFile !== undefined) {
     const conflict = MARKDOWN_INCOMPATIBLE_FLAGS.find((flag) => values2[flag] !== undefined);
     if (conflict) {
-      return fail("USAGE", `--${conflict} can't be combined with --markdown / --markdown-file (the markdown source controls block-level styling)`, HELP10);
+      return fail("USAGE", `--${conflict} can't be combined with --markdown / --markdown-file (the markdown source controls block-level styling)`, HELP9);
     }
     const source2 = markdownInline !== undefined ? markdownInline : await loadMarkdownFile(markdownFile);
     if (typeof source2 === "number")
@@ -83239,6 +83227,11 @@ async function parseParagraphOptions(values2) {
   }
   return out;
 }
+function injectTabsIntoSpec(spec, tabs) {
+  if (spec.kind === "text" || spec.kind === "runs" || spec.kind === "code" || spec.kind === "markdown" || spec.kind === "paragraphProps") {
+    spec.paragraphOptions.tabs = tabs;
+  }
+}
 async function respondDryRun2(opts) {
   await respond({
     operation: "edit",
@@ -83258,13 +83251,14 @@ async function emitEditAck(opts) {
   });
   return EXIT2.OK;
 }
-var AT_FORMS2, HELP10, MARKDOWN_INCOMPATIBLE_FLAGS, OPTION_SPEC3;
+var AT_FORMS2, HELP9, MARKDOWN_INCOMPATIBLE_FLAGS, OPTION_SPEC2;
 var init_edit2 = __esm(() => {
   init_core2();
   init_equation();
   init_parse_helpers();
   init_respond();
   init_batch2();
+  init_tabs();
   AT_FORMS2 = describeForms([
     "paragraph",
     "span",
@@ -83274,7 +83268,7 @@ var init_edit2 = __esm(() => {
     "section",
     "equation"
   ], "                      ");
-  HELP10 = `docx edit \u2014 replace a paragraph (or paragraph range), a section, or an equation
+  HELP9 = `docx edit \u2014 replace a paragraph (or paragraph range), a section, or an equation
 
 Usage:
   docx edit FILE --at LOCATOR <content> [options]
@@ -83291,7 +83285,8 @@ ${AT_FORMS2}
                     inheriting the existing run's formatting \u2014 paste a locator
                     straight from \`docx find\`. See \`docx info locators\`.
 
-Paragraph content (one required for paragraph / range locators):
+Paragraph content (one required for paragraph / range locators \u2014 UNLESS you pass
+only --style/--alignment below, which restyle the paragraph in place):
   --text TEXT       Replace with a single-run paragraph
   --runs JSON       Replace with custom runs (Run[] JSON)
   --code TEXT       Replace with a code block \u2014 newlines split into one
@@ -83334,6 +83329,25 @@ Equation editing (requires --at eqN):
 Paragraph options:
   --style NAME       Paragraph style (e.g., Heading1)
   --alignment ALIGN  left | center | right | justify
+  --tabs SPEC        Replace the paragraph's tab stops. SPEC is:
+                       right   \u2014 a single RIGHT tab flush at the text margin.
+                                 This is the CURE for the \`docx:layout \u2026 warn=\u2026\`
+                                 hint \`read\` prints on a line whose trailing
+                                 content sits on a fixed LEFT tab: a long value
+                                 (e.g. "San Francisco, CA") overflows the margin
+                                 and WRAPS to a second line. A right tab at the
+                                 margin right-aligns it instead, so it never wraps.
+                       clear   \u2014 remove the paragraph's tab stops.
+                       <list>  \u2014 explicit stops, e.g. \`right@7.5in\` or
+                                 \`left@1in,right@7.5in\` (ALIGN@POSin, comma list).
+  Pass any of --style/--alignment/--tabs ALONE (no content flag) to adjust the
+  paragraph in place, keeping its text/runs: \`docx edit doc.docx --at p4 --style
+  Heading1\`, \`docx edit doc.docx --at p9 --tabs right\`. --tabs also rides along
+  with --text (fill the line AND fix its tab in one call), and works per-entry in
+  --batch ({"at":"p9","text":"Harvard University\\tCambridge, MA","tabs":"right"}).
+  ONE-CALL cure: a RANGE locator fixes every wrapping tab line at once \u2014
+  \`docx edit doc.docx --at p9-p38 --tabs right\` (the exact "fix-all" command
+  \`read\` prints at the top when lines wrap; it skips paragraphs with no tab stops).
 
 Run options (only with --text):
   --color HEX       Run color, hex (e.g., 800080 for purple)
@@ -83413,7 +83427,7 @@ Batch JSONL example (one edit per line):
   {"at": "p1", "markdown": "## Revised heading"}
 `;
   MARKDOWN_INCOMPATIBLE_FLAGS = ["style", "alignment"];
-  OPTION_SPEC3 = {
+  OPTION_SPEC2 = {
     at: { type: "string" },
     batch: { type: "string" },
     text: { type: "string" },
@@ -83432,6 +83446,7 @@ Batch JSONL example (one edit per line):
     type: { type: "string" },
     style: { type: "string" },
     alignment: { type: "string" },
+    tabs: { type: "string" },
     color: { type: "string" },
     bold: { type: "boolean" },
     italic: { type: "boolean" },
@@ -83446,7 +83461,7 @@ Batch JSONL example (one edit per line):
 var exports_add2 = {};
 __export(exports_add2, {
   runAddNote: () => runAddNote,
-  run: () => run11
+  run: () => run10
 });
 function helpFor(kind) {
   const verb = kind === "footnote" ? "footnotes" : "endnotes";
@@ -83712,8 +83727,8 @@ function splitMarkdownBlocks(blocks) {
 }
 function runsToXml(runs) {
   const out = [];
-  for (const run11 of runs) {
-    const element = RunElement({ run: run11 });
+  for (const run10 of runs) {
+    const element = RunElement({ run: run10 });
     if (element)
       out.push(element);
   }
@@ -83751,7 +83766,7 @@ function parseAnchor(input) {
   }
   return null;
 }
-async function run11(args) {
+async function run10(args) {
   return runAddNote(args, "footnote");
 }
 var ANCHOR_FORMS;
@@ -83773,7 +83788,7 @@ var init_add2 = __esm(() => {
 var exports_delete3 = {};
 __export(exports_delete3, {
   runDeleteNote: () => runDeleteNote,
-  run: () => run12
+  run: () => run11
 });
 function helpFor2(kind) {
   const verb = kind === "footnote" ? "footnotes" : "endnotes";
@@ -83882,7 +83897,7 @@ async function runDeleteNote(args, kind) {
   });
   return EXIT2.OK;
 }
-async function run12(args) {
+async function run11(args) {
   return runDeleteNote(args, "footnote");
 }
 var init_delete3 = __esm(() => {
@@ -83895,7 +83910,7 @@ var init_delete3 = __esm(() => {
 var exports_edit2 = {};
 __export(exports_edit2, {
   runEditNote: () => runEditNote,
-  run: () => run13
+  run: () => run12
 });
 function helpFor3(kind) {
   const verb = kind === "footnote" ? "footnotes" : "endnotes";
@@ -84086,8 +84101,8 @@ function splitMarkdownBlocks2(blocks) {
 }
 function runsToXml2(runs) {
   const out = [];
-  for (const run13 of runs) {
-    const element = RunElement({ run: run13 });
+  for (const run12 of runs) {
+    const element = RunElement({ run: run12 });
     if (element)
       out.push(element);
   }
@@ -84136,7 +84151,7 @@ function NoteParagraph({
     ]
   }, undefined, true, undefined, this);
 }
-async function run13(args) {
+async function run12(args) {
   return runEditNote(args, "footnote");
 }
 var init_edit3 = __esm(() => {
@@ -84154,7 +84169,7 @@ var init_edit3 = __esm(() => {
 var exports_list2 = {};
 __export(exports_list2, {
   runListNotes: () => runListNotes,
-  run: () => run14
+  run: () => run13
 });
 function helpFor4(kind) {
   const verb = kind === "footnote" ? "footnotes" : "endnotes";
@@ -84196,7 +84211,7 @@ async function runListNotes(args, kind) {
   await respond(notes);
   return EXIT2.OK;
 }
-async function run14(args) {
+async function run13(args) {
   return runListNotes(args, "footnote");
 }
 var init_list4 = __esm(() => {
@@ -84206,12 +84221,12 @@ var init_list4 = __esm(() => {
 // src/cli/endnotes/index.ts
 var exports_endnotes = {};
 __export(exports_endnotes, {
-  run: () => run15
+  run: () => run14
 });
-async function run15(args) {
+async function run14(args) {
   const verb = args[0];
   if (!verb || verb === "--help" || verb === "-h" || verb === "help") {
-    await writeStdout(HELP11);
+    await writeStdout(HELP10);
     return verb ? 0 : 2;
   }
   const handler = SUBCOMMANDS2[verb];
@@ -84220,7 +84235,7 @@ async function run15(args) {
   }
   return handler(args.slice(1));
 }
-var SUBCOMMANDS2, HELP11 = `docx endnotes \u2014 author endnotes
+var SUBCOMMANDS2, HELP10 = `docx endnotes \u2014 author endnotes
 
 Usage:
   docx endnotes <verb> FILE [options]
@@ -84250,7 +84265,7 @@ var init_endnotes = __esm(() => {
 // src/cli/find/index.ts
 var exports_find = {};
 __export(exports_find, {
-  run: () => run16
+  run: () => run15
 });
 function withBareHighlightAsAny(args) {
   const out = [];
@@ -84272,7 +84287,7 @@ function withBareHighlightAsAny(args) {
   }
   return out;
 }
-async function run16(args) {
+async function run15(args) {
   const parsed = await tryParseArgs(withBareHighlightAsAny(args), {
     regex: { type: "boolean" },
     "ignore-case": { type: "boolean" },
@@ -84288,17 +84303,17 @@ async function run16(args) {
     underline: { type: "boolean" },
     json: { type: "boolean" },
     help: { type: "boolean", short: "h" }
-  }, HELP12);
+  }, HELP11);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP12);
+    await writeStdout(HELP11);
     return EXIT2.OK;
   }
   const path2 = parsed.positionals[0];
   const query = parsed.positionals[1];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP12);
+    return fail("USAGE", "Missing FILE argument", HELP11);
   const formatFilter = {};
   if (parsed.values.highlight !== undefined)
     formatFilter.highlight = parsed.values.highlight;
@@ -84312,10 +84327,10 @@ async function run16(args) {
     formatFilter.underline = true;
   const hasFormatFilter = Object.keys(formatFilter).length > 0;
   if (query == null && !hasFormatFilter) {
-    return fail("USAGE", "Missing QUERY (or a --highlight/--color/--bold/--italic/--underline filter)", HELP12);
+    return fail("USAGE", "Missing QUERY (or a --highlight/--color/--bold/--italic/--underline filter)", HELP11);
   }
   if (query != null && hasFormatFilter) {
-    return fail("USAGE", "Pass a text QUERY or formatting filters (--highlight/--color/...), not both", HELP12);
+    return fail("USAGE", "Pass a text QUERY or formatting filters (--highlight/--color/...), not both", HELP11);
   }
   const ignoreCase = Boolean(parsed.values["ignore-case"]);
   const useRegex = Boolean(parsed.values.regex);
@@ -84390,7 +84405,7 @@ async function run16(args) {
   }
   return EXIT2.OK;
 }
-var HELP12 = `docx find \u2014 locate text spans and return their locators
+var HELP11 = `docx find \u2014 locate text spans and return their locators
 
 Usage:
   docx find FILE QUERY [options]
@@ -84463,12 +84478,12 @@ var init_find2 = __esm(() => {
 // src/cli/footnotes/index.ts
 var exports_footnotes = {};
 __export(exports_footnotes, {
-  run: () => run17
+  run: () => run16
 });
-async function run17(args) {
+async function run16(args) {
   const verb = args[0];
   if (!verb || verb === "--help" || verb === "-h" || verb === "help") {
-    await writeStdout(HELP13);
+    await writeStdout(HELP12);
     return verb ? 0 : 2;
   }
   const loader = SUBCOMMANDS3[verb];
@@ -84478,7 +84493,7 @@ async function run17(args) {
   const module_ = await loader();
   return module_.run(args.slice(1));
 }
-var SUBCOMMANDS3, HELP13 = `docx footnotes \u2014 author footnotes
+var SUBCOMMANDS3, HELP12 = `docx footnotes \u2014 author footnotes
 
 Usage:
   docx footnotes <verb> FILE [options]
@@ -84502,7 +84517,7 @@ var init_footnotes = __esm(() => {
 });
 
 // src/core/hyperlinks/wrap.tsx
-function wrapSpanInHyperlink(paragraph2, span, relationshipId) {
+function wrapSpanInHyperlink(paragraph2, span, relationshipId, applyStyle = true) {
   if (span.start >= span.end) {
     throw new HyperlinkWrapError(`Empty or inverted span ${span.start}-${span.end}`);
   }
@@ -84513,6 +84528,9 @@ function wrapSpanInHyperlink(paragraph2, span, relationshipId) {
   const placeWrapper = () => {
     if (placed || wrappedRuns.length === 0)
       return;
+    if (applyStyle)
+      for (const run17 of wrappedRuns)
+        applyHyperlinkRunStyle(run17);
     newChildren.push(hyperlinkWrapper(relationshipId, wrappedRuns));
     wrappedRuns.length = 0;
     placed = true;
@@ -84573,6 +84591,20 @@ function hyperlinkWrapper(relationshipId, runs) {
     children: runs
   }, undefined, false, undefined, this);
 }
+function applyHyperlinkRunStyle(run17) {
+  if (run17.tag !== "w:r")
+    return;
+  let rPr = run17.findChild("w:rPr");
+  if (!rPr) {
+    rPr = /* @__PURE__ */ jsxDEV(w.rPr, {}, undefined, false, undefined, this);
+    run17.children.unshift(rPr);
+  }
+  if (rPr.findChild("w:rStyle"))
+    return;
+  rPr.children.unshift(/* @__PURE__ */ jsxDEV(w.rStyle, {
+    "w-val": "Hyperlink"
+  }, undefined, false, undefined, this));
+}
 var HyperlinkWrapError;
 var init_wrap = __esm(() => {
   init_jsx();
@@ -84594,7 +84626,10 @@ class Hyperlinks {
   }
   add(paragraph2, span, url, options = {}) {
     const relationshipId = this.document.relationships.addHyperlink(url);
-    wrapSpanInHyperlink(paragraph2, span, relationshipId);
+    const applyStyle = options.style ?? true;
+    if (applyStyle)
+      this.document.ensureStyles().ensureStyle("Hyperlink");
+    wrapSpanInHyperlink(paragraph2, span, relationshipId, applyStyle);
     this.document.relationships.hyperlinksByRelationshipId.set(relationshipId, {
       url
     });
@@ -84697,31 +84732,32 @@ var init_hyperlinks = __esm(() => {
 // src/cli/hyperlinks/add.tsx
 var exports_add3 = {};
 __export(exports_add3, {
-  run: () => run18
+  run: () => run17
 });
-async function run18(args) {
+async function run17(args) {
   const parsed = await tryParseArgs(args, {
     at: { type: "string" },
     url: { type: "string" },
     author: { type: "string" },
+    "no-style": { type: "boolean" },
     ...SAVE_FLAGS
-  }, HELP14);
+  }, HELP13);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP14);
+    await writeStdout(HELP13);
     return EXIT2.OK;
   }
   setVerboseAck(Boolean(parsed.values.verbose));
   const path2 = parsed.positionals[0];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP14);
+    return fail("USAGE", "Missing FILE argument", HELP13);
   const atInput = parsed.values.at;
   const url = parsed.values.url;
   if (!atInput)
-    return fail("USAGE", "Missing --at LOCATOR", HELP14);
+    return fail("USAGE", "Missing --at LOCATOR", HELP13);
   if (!url)
-    return fail("USAGE", "Missing --url URL", HELP14);
+    return fail("USAGE", "Missing --url URL", HELP13);
   let locator;
   try {
     locator = parseLocator(atInput);
@@ -84755,7 +84791,8 @@ async function run18(args) {
   }
   try {
     new Hyperlinks(document4).add(paragraphRef.node, target.span, url, {
-      author: parsed.values.author
+      author: parsed.values.author,
+      style: !parsed.values["no-style"]
     });
   } catch (error) {
     if (error instanceof HyperlinkWrapError) {
@@ -84784,27 +84821,27 @@ async function findMintedHyperlink(savedPath, blockId, spanStart) {
   let offset2 = 0;
   let foundId;
   let text6 = "";
-  for (const run19 of block.runs) {
-    if (run19.type !== "text")
+  for (const run18 of block.runs) {
+    if (run18.type !== "text")
       continue;
-    const runEnd = offset2 + run19.text.length;
-    if (foundId === undefined && run19.hyperlink && spanStart < runEnd) {
-      foundId = run19.hyperlink.id;
+    const runEnd = offset2 + run18.text.length;
+    if (foundId === undefined && run18.hyperlink && spanStart < runEnd) {
+      foundId = run18.hyperlink.id;
     }
-    if (foundId !== undefined && run19.hyperlink?.id === foundId) {
-      text6 += run19.text;
+    if (foundId !== undefined && run18.hyperlink?.id === foundId) {
+      text6 += run18.text;
     }
     offset2 = runEnd;
   }
   return foundId === undefined ? undefined : { id: foundId, text: text6 };
 }
-var AT_FORMS3, HELP14;
+var AT_FORMS3, HELP13;
 var init_add3 = __esm(() => {
   init_core2();
   init_hyperlinks();
   init_respond();
   AT_FORMS3 = describeForms(["span", "cellSpan"], "                    ");
-  HELP14 = `docx hyperlinks add \u2014 wrap an existing span in a hyperlink
+  HELP13 = `docx hyperlinks add \u2014 wrap an existing span in a hyperlink
 
 Usage:
   docx hyperlinks add FILE --at LOCATOR --url URL [options]
@@ -84818,6 +84855,9 @@ ${AT_FORMS3}
   --url URL         Target URL
 
 Optional:
+  --no-style        Don't apply Word's "Hyperlink" character style (blue +
+                    underline). By default the wrapped text is styled so the link
+                    is visibly a link; pass this to keep the original run look.
   --author NAME     Author for the audit comment when track-changes is on
                     (default: $DOCX_AUTHOR)
   -o, --output PATH Write to PATH instead of overwriting FILE
@@ -84851,27 +84891,27 @@ Examples:
 // src/cli/hyperlinks/delete.ts
 var exports_delete4 = {};
 __export(exports_delete4, {
-  run: () => run19
+  run: () => run18
 });
-async function run19(args) {
+async function run18(args) {
   const parsed = await tryParseArgs(args, {
     at: { type: "string" },
     author: { type: "string" },
     ...SAVE_FLAGS
-  }, HELP15);
+  }, HELP14);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP15);
+    await writeStdout(HELP14);
     return EXIT2.OK;
   }
   setVerboseAck(Boolean(parsed.values.verbose));
   const path2 = parsed.positionals[0];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP15);
+    return fail("USAGE", "Missing FILE argument", HELP14);
   const targetId = parsed.values.at;
   if (!targetId)
-    return fail("USAGE", "Missing --at linkN", HELP15);
+    return fail("USAGE", "Missing --at linkN", HELP14);
   const document4 = await openOrFail(path2);
   if (typeof document4 === "number")
     return document4;
@@ -84912,13 +84952,13 @@ async function run19(args) {
   });
   return EXIT2.OK;
 }
-var AT_FORMS4, HELP15;
+var AT_FORMS4, HELP14;
 var init_delete4 = __esm(() => {
   init_core2();
   init_hyperlinks();
   init_respond();
   AT_FORMS4 = describeForms(["hyperlink"], "                    ");
-  HELP15 = `docx hyperlinks delete \u2014 unwrap a hyperlink (keep the text)
+  HELP14 = `docx hyperlinks delete \u2014 unwrap a hyperlink (keep the text)
 
 Usage:
   docx hyperlinks delete FILE --at linkN [options]
@@ -84957,21 +84997,21 @@ Examples:
 // src/cli/hyperlinks/list.ts
 var exports_list3 = {};
 __export(exports_list3, {
-  run: () => run20
+  run: () => run19
 });
-async function run20(args) {
+async function run19(args) {
   const parsed = await tryParseArgs(args, {
     help: { type: "boolean", short: "h" }
-  }, HELP16);
+  }, HELP15);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP16);
+    await writeStdout(HELP15);
     return EXIT2.OK;
   }
   const path2 = parsed.positionals[0];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP16);
+    return fail("USAGE", "Missing FILE argument", HELP15);
   const document4 = await openOrFail(path2);
   if (typeof document4 === "number")
     return document4;
@@ -84984,10 +85024,10 @@ function collectHyperlinks(blocks, entries) {
   for (const block of iterateBlocks(blocks)) {
     if (block.type !== "paragraph")
       continue;
-    for (const run21 of block.runs) {
-      if (run21.type !== "text" || !run21.hyperlink)
+    for (const run20 of block.runs) {
+      if (run20.type !== "text" || !run20.hyperlink)
         continue;
-      addToEntry(entries, run21.hyperlink, block.id, run21.text);
+      addToEntry(entries, run20.hyperlink, block.id, run20.text);
     }
   }
 }
@@ -85010,7 +85050,7 @@ function addToEntry(entries, hyperlink, blockId, text6) {
     entry.tooltip = hyperlink.tooltip;
   entries.set(hyperlink.id, entry);
 }
-var HELP16 = `docx hyperlinks list \u2014 print hyperlink manifest as JSON
+var HELP15 = `docx hyperlinks list \u2014 print hyperlink manifest as JSON
 
 Usage:
   docx hyperlinks list FILE [options]
@@ -85036,31 +85076,31 @@ var init_list5 = __esm(() => {
 // src/cli/hyperlinks/replace.ts
 var exports_replace = {};
 __export(exports_replace, {
-  run: () => run21
+  run: () => run20
 });
-async function run21(args) {
+async function run20(args) {
   const parsed = await tryParseArgs(args, {
     at: { type: "string" },
     with: { type: "string" },
     author: { type: "string" },
     ...SAVE_FLAGS
-  }, HELP17);
+  }, HELP16);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP17);
+    await writeStdout(HELP16);
     return EXIT2.OK;
   }
   setVerboseAck(Boolean(parsed.values.verbose));
   const path2 = parsed.positionals[0];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP17);
+    return fail("USAGE", "Missing FILE argument", HELP16);
   const targetId = parsed.values.at;
   if (!targetId)
-    return fail("USAGE", "Missing --at linkN", HELP17);
+    return fail("USAGE", "Missing --at linkN", HELP16);
   const newUrl = parsed.values.with;
   if (!newUrl)
-    return fail("USAGE", "Missing --with URL", HELP17);
+    return fail("USAGE", "Missing --with URL", HELP16);
   const document4 = await openOrFail(path2);
   if (typeof document4 === "number")
     return document4;
@@ -85099,13 +85139,13 @@ async function run21(args) {
   });
   return EXIT2.OK;
 }
-var AT_FORMS5, HELP17;
+var AT_FORMS5, HELP16;
 var init_replace2 = __esm(() => {
   init_core2();
   init_hyperlinks();
   init_respond();
   AT_FORMS5 = describeForms(["hyperlink"], "                    ");
-  HELP17 = `docx hyperlinks replace \u2014 change a hyperlink's URL
+  HELP16 = `docx hyperlinks replace \u2014 change a hyperlink's URL
 
 Usage:
   docx hyperlinks replace FILE --at linkN --with URL [options]
@@ -85146,12 +85186,12 @@ Examples:
 // src/cli/hyperlinks/index.ts
 var exports_hyperlinks = {};
 __export(exports_hyperlinks, {
-  run: () => run22
+  run: () => run21
 });
-async function run22(args) {
+async function run21(args) {
   const verb = args[0];
   if (!verb || verb === "--help" || verb === "-h" || verb === "help") {
-    await writeStdout(HELP18);
+    await writeStdout(HELP17);
     return verb ? 0 : 2;
   }
   const loader = SUBCOMMANDS4[verb];
@@ -85161,7 +85201,7 @@ async function run22(args) {
   const module_ = await loader();
   return module_.run(args.slice(1));
 }
-var SUBCOMMANDS4, HELP18 = `docx hyperlinks \u2014 manage hyperlinks
+var SUBCOMMANDS4, HELP17 = `docx hyperlinks \u2014 manage hyperlinks
 
 Usage:
   docx hyperlinks <verb> FILE [options]
@@ -85380,24 +85420,24 @@ var init_batch3 = __esm(() => {
 // src/cli/insert/index.tsx
 var exports_insert = {};
 __export(exports_insert, {
-  run: () => run23,
+  run: () => run22,
   parseTargetPlacement: () => parseTargetPlacement,
   parseParagraphOptions: () => parseParagraphOptions2,
   chooseContentSpec: () => chooseContentSpec,
   MARKDOWN_INCOMPATIBLE_FLAGS: () => MARKDOWN_INCOMPATIBLE_FLAGS2
 });
-async function run23(args) {
-  const parsed = await tryParseArgs(args, OPTION_SPEC4, HELP19);
+async function run22(args) {
+  const parsed = await tryParseArgs(args, OPTION_SPEC3, HELP18);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP19);
+    await writeStdout(HELP18);
     return EXIT2.OK;
   }
   setVerboseAck(Boolean(parsed.values.verbose));
   const filePath = parsed.positionals[0];
   if (!filePath)
-    return fail("USAGE", "Missing FILE argument", HELP19);
+    return fail("USAGE", "Missing FILE argument", HELP18);
   const batchInput = parsed.values.batch;
   if (batchInput !== undefined) {
     return runInsertBatch(filePath, batchInput, parsed.values);
@@ -85452,16 +85492,20 @@ async function commitInsert(document4, blockRef, blocks, opts) {
     if (insertedNodes.has(reference.node))
       locators.push(blockId);
   }
+  const destination = opts.outputPath ?? opts.filePath;
   await respondMinted(locators, {
     ok: true,
     operation: "insert",
-    path: opts.outputPath ?? opts.filePath,
+    path: destination,
     locators,
     anchor: opts.placement.locator,
     placement: opts.placement.mode
-  });
+  }, isLayoutAffecting(opts.spec) ? renderVerifyHint(destination) : undefined);
   return EXIT2.OK;
 }
+function isLayoutAffecting(spec) {
+  return spec.kind === "section" || spec.kind === "image" || spec.kind === "table" || spec.kind === "break";
+}
 async function buildSingleShotOptions(filePath, values2) {
   const placement = await parseTargetPlacement(values2);
   if (typeof placement === "number")
@@ -85469,10 +85513,18 @@ async function buildSingleShotOptions(filePath, values2) {
   const spec = await chooseContentSpec(values2);
   if (typeof spec === "number")
     return spec;
+  if (spec.kind === "text") {
+    const rejected = await rejectMarkdownInText(values2.text, HELP18);
+    if (typeof rejected === "number")
+      return rejected;
+    const mangled = await rejectShellMangledValue(values2.text, HELP18, "--text");
+    if (typeof mangled === "number")
+      return mangled;
+  }
   if (spec.kind === "markdown") {
     const conflict = MARKDOWN_INCOMPATIBLE_FLAGS2.find((flag) => values2[flag] !== undefined);
     if (conflict) {
-      return fail("USAGE", `--${conflict} can't be combined with --markdown / --markdown-file (the markdown source controls block-level styling)`, HELP19);
+      return fail("USAGE", `--${conflict} can't be combined with --markdown / --markdown-file (the markdown source controls block-level styling)`, HELP18);
     }
   }
   const paragraphOptions = await parseParagraphOptions2(values2);
@@ -85493,23 +85545,26 @@ async function parseTargetPlacement(values2) {
   const after = values2.after;
   const before = values2.before;
   if (!after && !before) {
-    return fail("USAGE", "Missing locator: pass --after or --before", HELP19);
+    return fail("USAGE", "Missing locator: pass --after or --before", HELP18);
   }
   if (after && before) {
-    return fail("USAGE", "Pass either --after or --before, not both", HELP19);
+    return fail("USAGE", "Pass either --after or --before, not both", HELP18);
   }
   if (after !== undefined)
     return { mode: "after", locator: after };
   return { mode: "before", locator: before };
 }
 async function chooseContentSpec(values2) {
+  if (values2.section !== undefined || values2.columns !== undefined || values2.type !== undefined) {
+    return fail("USAGE", "insert no longer creates section/column layout \u2014 use `docx sections`", "To put paragraphs pN\u2026pM in N columns: `docx sections --at pN-pM --columns N`. To recount an existing section: `docx sections --at sN --columns N`.");
+  }
   const present = CONTENT_KINDS.filter((kind) => values2[kind.flag] !== undefined);
   if (present.length > 1) {
-    return fail("USAGE", `Pass only one of ${CONTENT_FLAG_LIST}`, HELP19);
+    return fail("USAGE", `Pass only one of ${CONTENT_FLAG_LIST}`, HELP18);
   }
   const chosen = present[0];
   if (!chosen) {
-    return fail("USAGE", `Missing content: pass ${CONTENT_FLAG_LIST}`, HELP19);
+    return fail("USAGE", `Missing content: pass ${CONTENT_FLAG_LIST}`, HELP18);
   }
   const chosenSubFlags = new Set(chosen.subFlags);
   for (const kind of CONTENT_KINDS) {
@@ -85517,7 +85572,7 @@ async function chooseContentSpec(values2) {
       continue;
     const orphan = kind.subFlags.find((flag) => values2[flag] !== undefined && !chosenSubFlags.has(flag));
     if (orphan) {
-      return fail("USAGE", `--${orphan} requires --${kind.flag}`, HELP19);
+      return fail("USAGE", `--${orphan} requires --${kind.flag}`, HELP18);
     }
   }
   switch (chosen.flag) {
@@ -85531,10 +85586,6 @@ async function chooseContentSpec(values2) {
       return { kind: "break", breakKind: "page" };
     case "column-break":
       return { kind: "break", breakKind: "column" };
-    case "section": {
-      const flags = await parseSectionFlags(values2);
-      return typeof flags === "number" ? flags : { kind: "section", ...flags };
-    }
     case "table": {
       const flags = await parseTableFlags(values2);
       return typeof flags === "number" ? flags : { kind: "table", ...flags };
@@ -85589,7 +85640,7 @@ async function resolveCodeSpec(values2, flag) {
 async function parseImageFlags(values2) {
   const src = values2.image;
   if (!src)
-    return fail("USAGE", "--image requires a SRC argument", HELP19);
+    return fail("USAGE", "--image requires a SRC argument", HELP18);
   const out = { src };
   const alt = values2.alt;
   if (alt !== undefined)
@@ -85632,7 +85683,7 @@ async function parseTableFlags(values2) {
   const rowsRaw = values2.rows;
   const colsRaw = values2.cols;
   if (rowsRaw === undefined || colsRaw === undefined) {
-    return fail("USAGE", "--table requires --rows and --cols", HELP19);
+    return fail("USAGE", "--table requires --rows and --cols", HELP18);
   }
   const rows = Number.parseInt(rowsRaw, 10);
   const cols = Number.parseInt(colsRaw, 10);
@@ -85709,18 +85760,18 @@ async function parseParagraphOptions2(values2) {
   const listValue = values2.list;
   const listLevelValue = values2["list-level"];
   if (taskValue !== undefined && listValue !== undefined) {
-    return fail("USAGE", "--task and --list are mutually exclusive (--task already implies a bullet list)", HELP19);
+    return fail("USAGE", "--task and --list are mutually exclusive (--task already implies a bullet list)", HELP18);
   }
   if (taskValue !== undefined) {
     const checked = parseTaskFlag(taskValue);
     if (checked === null) {
-      return fail("USAGE", `--task must be "checked" or "unchecked", got "${taskValue}"`, HELP19);
+      return fail("USAGE", `--task must be "checked" or "unchecked", got "${taskValue}"`, HELP18);
     }
     out.taskState = checked ? "checked" : "unchecked";
   }
   if (listValue !== undefined) {
     if (listValue !== "bullet" && listValue !== "ordered") {
-      return fail("USAGE", `--list must be "bullet" or "ordered", got "${listValue}"`, HELP19);
+      return fail("USAGE", `--list must be "bullet" or "ordered", got "${listValue}"`, HELP18);
     }
     out.list = { level: 0, numId: -1 };
     out.listKind = listValue;
@@ -85728,7 +85779,7 @@ async function parseParagraphOptions2(values2) {
   if (listLevelValue !== undefined) {
     const level = Number(listLevelValue);
     if (!Number.isInteger(level) || level < 0 || level > 8) {
-      return fail("USAGE", `--list-level must be an integer 0-8, got "${listLevelValue}"`, HELP19);
+      return fail("USAGE", `--list-level must be an integer 0-8, got "${listLevelValue}"`, HELP18);
     }
     if (out.list)
       out.list.level = level;
@@ -85736,14 +85787,14 @@ async function parseParagraphOptions2(values2) {
   }
   return out;
 }
-var ANCHOR_FORMS2, HELP19, OPTION_SPEC4, MARKDOWN_INCOMPATIBLE_FLAGS2, CONTENT_KINDS, CONTENT_FLAG_LIST;
+var ANCHOR_FORMS2, HELP18, OPTION_SPEC3, MARKDOWN_INCOMPATIBLE_FLAGS2, CONTENT_KINDS, CONTENT_FLAG_LIST;
 var init_insert2 = __esm(() => {
   init_core2();
   init_parse_helpers();
   init_respond();
   init_batch3();
   ANCHOR_FORMS2 = describeForms(["paragraph", "table", "section", "cellParagraph"], "                      ");
-  HELP19 = `docx insert \u2014 insert a block (paragraph, table, image, \u2026) at a locator
+  HELP18 = `docx insert \u2014 insert a block (paragraph, table, image, \u2026) at a locator
 
 Usage:
   docx insert FILE (--after | --before) LOCATOR <content> [options]
@@ -85762,7 +85813,6 @@ Content (one required):
   --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)
   --table           Insert an empty rows\xD7cols table (requires --rows and --cols)
   --image SRC       Insert an image (SRC is a file path, data: URI, or http(s) URL)
   --code TEXT       Insert a multi-line code block. Newlines split into one
@@ -85808,19 +85858,20 @@ 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
+Column / section layout: NOT here \u2014 use \`docx sections\`. Name the range and it
+inserts the bounding breaks correctly: \`docx sections --at p6-p16 --columns 2\`.
+(A raw section break formats the content ABOVE it, the off-by-one that made
+\`insert --section\` a footgun, so it was removed.)
 
 Agent tip: VERIFY LAYOUT VISUALLY: \`docx read\` shows text and structure as
-Markdown, but NOT how the page actually looks \u2014 multi-column sections, page
-breaks, image sizing, and where content lands on the page do not appear there.
-After inserting layout-affecting content (--section/--columns, --page-break,
---image, --table), render the document to images and look at them:
+Markdown, but NOT how the page actually looks \u2014 page breaks, image sizing, and
+where content lands on the page do not appear there. After inserting
+layout-affecting content (--page-break, --image, --table), render the document to
+images and look at them:
   docx render FILE --out pages/      # writes page-001.png, page-002.png, \u2026
-Read the PNGs, check the layout reads the way you intended (columns balanced, no
-stray blank page, figure sized sensibly), and adjust placement + re-render until
-it looks right. Don't assume a section/column insert looks good without seeing it.
+Read the PNGs, check the layout reads the way you intended (no stray blank page,
+figure sized sensibly), and adjust placement + re-render until it looks right.
+Don't assume a layout-affecting insert looks good without seeing it.
 
 Table options (only with --table):
   --rows N          Number of rows (required, >= 1)
@@ -85869,7 +85920,6 @@ Examples:
   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
   docx insert doc.docx --after p3 --table --rows 3 --cols 2
   docx insert doc.docx --after p3 --table --rows 2 --cols 3 --widths 1440,2880,4320
   docx insert doc.docx --after p3 --image ./diagram.png --alt "System diagram"
@@ -85887,7 +85937,7 @@ Batch JSONL example (keys mirror the flags; one insert per line):
   {"before": "p0", "text": "ALERT", "color": "CC0000", "bold": true}
   {"after": "p5", "markdown": "## Summary\\n\\n- point a\\n- point b"}
 `;
-  OPTION_SPEC4 = {
+  OPTION_SPEC3 = {
     after: { type: "string" },
     before: { type: "string" },
     batch: { type: "string" },
@@ -85942,7 +85992,6 @@ Batch JSONL example (keys mirror the flags; one insert per line):
     { flag: "runs", subFlags: [] },
     { flag: "page-break", subFlags: [] },
     { flag: "column-break", subFlags: [] },
-    { flag: "section", subFlags: ["columns", "type"] },
     {
       flag: "table",
       subFlags: ["rows", "cols", "widths", "table-width", "borders", "layout"]
@@ -85960,16 +86009,16 @@ Batch JSONL example (keys mirror the flags; one insert per line):
 // src/cli/images/add.ts
 var exports_add4 = {};
 __export(exports_add4, {
-  run: () => run24
+  run: () => run23
 });
-async function run24(args) {
+async function run23(args) {
   if (args[0] === "-h" || args[0] === "--help") {
-    await writeStdout(HELP20);
+    await writeStdout(HELP19);
     return 0;
   }
-  return run23(args);
+  return run22(args);
 }
-var HELP20 = `docx images add \u2014 insert an image (an alias for \`docx insert --image\`)
+var HELP19 = `docx images add \u2014 insert an image (an alias for \`docx insert --image\`)
 
 Usage:
   docx images add FILE --image PATH --after pN [options]
@@ -85993,28 +86042,28 @@ var init_add4 = __esm(() => {
 // src/cli/images/delete.tsx
 var exports_delete5 = {};
 __export(exports_delete5, {
-  run: () => run25
+  run: () => run24
 });
-async function run25(args) {
+async function run24(args) {
   const parsed = await tryParseArgs(args, {
     at: { type: "string" },
     author: { type: "string" },
     track: { type: "boolean" },
     ...SAVE_FLAGS
-  }, HELP21);
+  }, HELP20);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP21);
+    await writeStdout(HELP20);
     return EXIT2.OK;
   }
   setVerboseAck(Boolean(parsed.values.verbose));
   const path2 = parsed.positionals[0];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP21);
+    return fail("USAGE", "Missing FILE argument", HELP20);
   const targetId = parsed.values.at;
   if (!targetId)
-    return fail("USAGE", "Missing --at imgN", HELP21);
+    return fail("USAGE", "Missing --at imgN", HELP20);
   const document4 = await openOrFail(path2);
   if (typeof document4 === "number")
     return document4;
@@ -86084,7 +86133,7 @@ function pruneIfUnreferenced(document4, relationshipId) {
   }
   return true;
 }
-var HELP21 = `docx images delete \u2014 remove an embedded image
+var HELP20 = `docx images delete \u2014 remove an embedded image
 
 Usage:
   docx images delete FILE --at imgN [options]
@@ -86129,27 +86178,27 @@ var init_delete5 = __esm(() => {
 // src/cli/images/extract.ts
 var exports_extract = {};
 __export(exports_extract, {
-  run: () => run26
+  run: () => run25
 });
 import { join as join6 } from "path";
-async function run26(args) {
+async function run25(args) {
   const parsed = await tryParseArgs(args, {
     to: { type: "string" },
     at: { type: "string" },
     help: { type: "boolean", short: "h" }
-  }, HELP22);
+  }, HELP21);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP22);
+    await writeStdout(HELP21);
     return EXIT2.OK;
   }
   const path2 = parsed.positionals[0];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP22);
+    return fail("USAGE", "Missing FILE argument", HELP21);
   const outputDir = parsed.values.to;
   if (!outputDir)
-    return fail("USAGE", "Missing --to DIR", HELP22);
+    return fail("USAGE", "Missing --to DIR", HELP21);
   const targetId = parsed.values.at;
   const document4 = await openOrFail(path2);
   if (typeof document4 === "number")
@@ -86190,7 +86239,7 @@ function extensionFor(contentType, partName) {
   const fromName = partName.split(".").pop()?.toLowerCase();
   return fromName ?? "bin";
 }
-var HELP22 = `docx images extract \u2014 dump image bytes to a directory
+var HELP21 = `docx images extract \u2014 dump image bytes to a directory
 
 Usage:
   docx images extract FILE --to DIR [options]
@@ -86223,21 +86272,21 @@ var init_extract = __esm(() => {
 // src/cli/images/list.ts
 var exports_list4 = {};
 __export(exports_list4, {
-  run: () => run27
+  run: () => run26
 });
-async function run27(args) {
+async function run26(args) {
   const parsed = await tryParseArgs(args, {
     help: { type: "boolean", short: "h" }
-  }, HELP23);
+  }, HELP22);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP23);
+    await writeStdout(HELP22);
     return EXIT2.OK;
   }
   const path2 = parsed.positionals[0];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP23);
+    return fail("USAGE", "Missing FILE argument", HELP22);
   const document4 = await openOrFail(path2);
   if (typeof document4 === "number")
     return document4;
@@ -86245,7 +86294,7 @@ async function run27(args) {
   await respond(flattenImageRuns(document4.body.blocks));
   return EXIT2.OK;
 }
-var HELP23 = `docx images list \u2014 print image manifest as JSON
+var HELP22 = `docx images list \u2014 print image manifest as JSON
 
 Usage:
   docx images list FILE [options]
@@ -86271,31 +86320,31 @@ var init_list6 = __esm(() => {
 // src/cli/images/replace.ts
 var exports_replace2 = {};
 __export(exports_replace2, {
-  run: () => run28
+  run: () => run27
 });
-async function run28(args) {
+async function run27(args) {
   const parsed = await tryParseArgs(args, {
     at: { type: "string" },
     with: { type: "string" },
     author: { type: "string" },
     ...SAVE_FLAGS
-  }, HELP24);
+  }, HELP23);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP24);
+    await writeStdout(HELP23);
     return EXIT2.OK;
   }
   setVerboseAck(Boolean(parsed.values.verbose));
   const path2 = parsed.positionals[0];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP24);
+    return fail("USAGE", "Missing FILE argument", HELP23);
   const targetId = parsed.values.at;
   if (!targetId)
-    return fail("USAGE", "Missing --at imgN", HELP24);
+    return fail("USAGE", "Missing --at imgN", HELP23);
   const sourcePath = parsed.values.with;
   if (!sourcePath)
-    return fail("USAGE", "Missing --with PATH", HELP24);
+    return fail("USAGE", "Missing --with PATH", HELP23);
   const sourceFile = Bun.file(sourcePath);
   if (!await sourceFile.exists()) {
     return fail("FILE_NOT_FOUND", `Replacement file not found: ${sourcePath}`);
@@ -86386,7 +86435,7 @@ function renameExtension(partName, newExtension) {
 function relativeTargetFor(partName) {
   return partName.startsWith("word/") ? partName.slice("word/".length) : partName;
 }
-var HELP24 = `docx images replace \u2014 swap an image's bytes
+var HELP23 = `docx images replace \u2014 swap an image's bytes
 
 Usage:
   docx images replace FILE --at imgN --with PATH [options]
@@ -86431,12 +86480,12 @@ var init_replace3 = __esm(() => {
 // src/cli/images/index.ts
 var exports_images = {};
 __export(exports_images, {
-  run: () => run29
+  run: () => run28
 });
-async function run29(args) {
+async function run28(args) {
   const verb = args[0];
   if (!verb || verb === "--help" || verb === "-h" || verb === "help") {
-    await writeStdout(HELP25);
+    await writeStdout(HELP24);
     return verb ? 0 : 2;
   }
   const loader = SUBCOMMANDS5[verb];
@@ -86446,7 +86495,7 @@ async function run29(args) {
   const module_ = await loader();
   return module_.run(args.slice(1));
 }
-var SUBCOMMANDS5, HELP25 = `docx images \u2014 manage embedded images
+var SUBCOMMANDS5, HELP24 = `docx images \u2014 manage embedded images
 
 Usage:
   docx images <verb> FILE [options]
@@ -86501,6 +86550,13 @@ export type Paragraph = {
 	 * them at top level, breaking the quote at that point. See
 	 * [src/core/markdown/CLAUDE.md](../markdown/CLAUDE.md). */
 	quoteDepth?: number;
+	/** Explicit tab stops from \`<w:pPr><w:tabs>\`, each \`{ align, pos }\` (pos in
+	 * twips). Surfaced so \`read\` can flag a fragile right-alignment: a LEFT (or
+	 * center) tab stop near the right margin pushes content rightward but \u2014 unlike
+	 * a RIGHT tab \u2014 wraps anything wider than the gap to the margin (the r\xE9sum\xE9
+	 * "San / Francisco, CA" break). Present only when the paragraph declares
+	 * explicit tab stops. */
+	tabStops?: { align: string; pos: number }[];
 	runs: Run[];
 };
 
@@ -86806,18 +86862,18 @@ var init_types3 = () => {};
 // src/cli/info/schema.ts
 var exports_schema = {};
 __export(exports_schema, {
-  run: () => run30
+  run: () => run29
 });
-async function run30(args) {
+async function run29(args) {
   const parsed = await tryParseArgs(args, {
     json: { type: "boolean" },
     ts: { type: "boolean" },
     help: { type: "boolean", short: "h" }
-  }, HELP26);
+  }, HELP25);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP26);
+    await writeStdout(HELP25);
     return EXIT2.OK;
   }
   if (parsed.values.ts) {
@@ -86827,7 +86883,7 @@ async function run30(args) {
   await respond(JSON_SCHEMA);
   return EXIT2.OK;
 }
-var HELP26 = `docx info schema \u2014 print the AST type definitions
+var HELP25 = `docx info schema \u2014 print the AST type definitions
 
 Usage:
   docx info schema [options]
@@ -86901,6 +86957,17 @@ var init_schema = __esm(() => {
             }
           },
           taskState: { enum: ["checked", "unchecked"] },
+          tabStops: {
+            type: "array",
+            items: {
+              type: "object",
+              required: ["align", "pos"],
+              properties: {
+                align: { type: "string" },
+                pos: { type: "number" }
+              }
+            }
+          },
           runs: { type: "array", items: { $ref: "#/$defs/Run" } }
         }
       },
@@ -87155,7 +87222,7 @@ var init_schema = __esm(() => {
 // src/cli/info/locators.ts
 var exports_locators = {};
 __export(exports_locators, {
-  run: () => run31
+  run: () => run30
 });
 function renderReference() {
   const sections = GROUPS.map((group) => {
@@ -87286,15 +87353,15 @@ function renderJson() {
     ]
   };
 }
-async function run31(args) {
+async function run30(args) {
   const parsed = await tryParseArgs(args, {
     json: { type: "boolean" },
     help: { type: "boolean", short: "h" }
-  }, HELP27);
+  }, HELP26);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP27);
+    await writeStdout(HELP26);
     return EXIT2.OK;
   }
   if (parsed.values.json) {
@@ -87305,7 +87372,7 @@ async function run31(args) {
   await writeStdout(renderReference());
   return EXIT2.OK;
 }
-var HELP27 = `docx info locators \u2014 print the locator grammar reference
+var HELP26 = `docx info locators \u2014 print the locator grammar reference
 
 Usage:
   docx info locators [options]
@@ -87357,12 +87424,12 @@ var init_locators2 = __esm(() => {
 // src/cli/info/index.ts
 var exports_info = {};
 __export(exports_info, {
-  run: () => run32
+  run: () => run31
 });
-async function run32(args) {
+async function run31(args) {
   const topic = args[0];
   if (!topic || topic === "--help" || topic === "-h" || topic === "help") {
-    await writeStdout(HELP28);
+    await writeStdout(HELP27);
     return topic ? 0 : 2;
   }
   const loader = SUBCOMMANDS6[topic];
@@ -87372,7 +87439,7 @@ async function run32(args) {
   const module_ = await loader();
   return module_.run(args.slice(1));
 }
-var SUBCOMMANDS6, HELP28 = `docx info \u2014 print reference material about the CLI
+var SUBCOMMANDS6, HELP27 = `docx info \u2014 print reference material about the CLI
 
 Usage:
   docx info <topic> [options]
@@ -87452,23 +87519,23 @@ var init_build = __esm(() => {
 // src/cli/outline/index.ts
 var exports_outline = {};
 __export(exports_outline, {
-  run: () => run33
+  run: () => run32
 });
-async function run33(args) {
+async function run32(args) {
   const parsed = await tryParseArgs(args, {
     "style-prefix": { type: "string" },
     json: { type: "boolean" },
     help: { type: "boolean", short: "h" }
-  }, HELP29);
+  }, HELP28);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP29);
+    await writeStdout(HELP28);
     return EXIT2.OK;
   }
   const path2 = parsed.positionals[0];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP29);
+    return fail("USAGE", "Missing FILE argument", HELP28);
   const stylePrefix = parsed.values["style-prefix"] ?? "Heading";
   if (stylePrefix.length === 0) {
     return fail("USAGE", "--style-prefix cannot be empty");
@@ -87496,7 +87563,7 @@ function renderOutlineText(entries, depth = 0) {
   }
   return lines;
 }
-var HELP29 = `docx outline \u2014 list headings as a hierarchical tree
+var HELP28 = `docx outline \u2014 list headings as a hierarchical tree
 
 Usage:
   docx outline FILE [options]
@@ -87564,7 +87631,9 @@ function renderMarkdown(doc, options = {}) {
     referencedEndnoteIds: new Set,
     referencedTrackedChanges: new Map,
     orderedCounters: new Map,
-    contentWidthEmu: contentWidthEmu(documentGeometry(blocks))
+    contentWidthEmu: contentWidthEmu(documentGeometry(blocks)),
+    governingColumns: computeGoverningColumns(blocks),
+    wrappingTabLines: []
   };
   const parts = [];
   let cursor = 0;
@@ -87591,7 +87660,7 @@ function renderMarkdown(doc, options = {}) {
       cursor = lookahead2;
       continue;
     }
-    const rendered = renderBlock(block, ctx);
+    const rendered = renderBlock(block, ctx, blocks, cursor);
     if (rendered !== null)
       parts.push(rendered);
     cursor++;
@@ -87618,7 +87687,9 @@ function renderMarkdown(doc, options = {}) {
     return "";
   const baseNote = formatBaseNote(dominant);
   const pageNote = formatPageNote(documentGeometry(blocks));
-  const headLines = [baseNote, pageNote].filter((line) => line.length > 0);
+  const trackNote = options.trackChangesOn ? formatNote("track-changes", [], ["on"]) : "";
+  const wrapSummary = formatWrappingTabSummary(ctx.wrappingTabLines);
+  const headLines = [baseNote, pageNote, trackNote, wrapSummary].filter((line) => line.length > 0);
   const head = headLines.length > 0 ? `${headLines.join(`
 `)}
 
@@ -87633,17 +87704,17 @@ function detectFormatBaseline(blocks) {
   const sizeChars = new Map;
   let total = 0;
   for (const paragraph2 of flattenParagraphs(blocks)) {
-    for (const run34 of paragraph2.runs) {
-      if (run34.type !== "text")
+    for (const run33 of paragraph2.runs) {
+      if (run33.type !== "text")
         continue;
-      const length = run34.text.length;
+      const length = run33.text.length;
       if (length === 0)
         continue;
       total += length;
-      if (run34.font)
-        fontChars.set(run34.font, (fontChars.get(run34.font) ?? 0) + length);
-      if (run34.sizeHalfPoints !== undefined) {
-        sizeChars.set(run34.sizeHalfPoints, (sizeChars.get(run34.sizeHalfPoints) ?? 0) + length);
+      if (run33.font)
+        fontChars.set(run33.font, (fontChars.get(run33.font) ?? 0) + length);
+      if (run33.sizeHalfPoints !== undefined) {
+        sizeChars.set(run33.sizeHalfPoints, (sizeChars.get(run33.sizeHalfPoints) ?? 0) + length);
       }
     }
   }
@@ -87677,8 +87748,8 @@ function emptyCommentIndex() {
     orderedIds: []
   };
 }
-function isRunVisible(run34, view) {
-  const kind = run34.trackedChange?.kind;
+function isRunVisible(run33, view) {
+  const kind = run33.trackedChange?.kind;
   if (!kind)
     return true;
   if (view === "accepted" && (kind === "del" || kind === "moveFrom"))
@@ -87693,13 +87764,13 @@ function buildCommentIndex(blocks, options) {
   const spanText = new Map;
   const orderedIds = [];
   for (const paragraph2 of flattenParagraphs(blocks)) {
-    paragraph2.runs.forEach((run34, index2) => {
-      const comments = runComments(run34);
+    paragraph2.runs.forEach((run33, index2) => {
+      const comments = runComments(run33);
       if (!comments)
         return;
-      if (run34.type === "text" && !isRunVisible(run34, view))
+      if (run33.type === "text" && !isRunVisible(run33, view))
         return;
-      const spanContribution = run34.type === "text" ? run34.text : run34.type === "equation" ? run34.text : "";
+      const spanContribution = run33.type === "text" ? run33.text : run33.type === "equation" ? run33.text : "";
       for (const commentId of comments) {
         if (!spanText.has(commentId))
           orderedIds.push(commentId);
@@ -87719,32 +87790,121 @@ function buildCommentIndex(blocks, options) {
   }
   return { endingsByRun, spanText, orderedIds };
 }
-function runComments(run34) {
-  if (run34.type === "text")
-    return run34.comments;
-  if (run34.type === "equation")
-    return run34.comments;
+function runComments(run33) {
+  if (run33.type === "text")
+    return run33.comments;
+  if (run33.type === "equation")
+    return run33.comments;
   return;
 }
 function slotKey(paragraphId, runIndex) {
   return `${paragraphId}#${runIndex}`;
 }
-function renderBlock(block, ctx) {
+function renderBlock(block, ctx, blocks, index2) {
   if (block.type === "paragraph")
     return renderParagraph(block, ctx);
   if (block.type === "table")
     return renderTable(block, ctx);
-  if (block.type === "sectionBreak")
-    return renderSectionBreak(block);
+  if (block.type === "sectionBreak") {
+    return renderSectionBreak(block, governedRange(blocks, index2));
+  }
   return null;
 }
-function renderSectionBreak(block) {
+function computeGoverningColumns(blocks) {
+  const map3 = new Map;
+  let cols = 1;
+  for (let index2 = blocks.length - 1;index2 >= 0; index2--) {
+    const block = blocks[index2];
+    if (!block)
+      continue;
+    if (block.type === "sectionBreak") {
+      cols = block.columns ?? 1;
+      continue;
+    }
+    map3.set(block.id, cols);
+  }
+  return map3;
+}
+function formatWrappingTabSummary(ids) {
+  if (ids.length === 0)
+    return "";
+  const count = `${ids.length} line${ids.length > 1 ? "s" : ""}`;
+  const range = tabCureRange(ids);
+  const fix = range ? `edit FILE --at ${range} --tabs right` : ids.map((id) => `edit FILE --at ${id} --tabs right`).join(" ; ");
+  return formatNote("layout", [
+    ["wrap", count],
+    [
+      "warn",
+      "tab-aligned content (e.g. dates/locations) overflows the right margin and WRAPS in render until cured"
+    ],
+    ["fix-all", fix]
+  ], ids);
+}
+function tabCureRange(ids) {
+  const nums = ids.map((id) => /^p(\d+)$/.exec(id)?.[1]).filter((value) => value !== undefined).map(Number);
+  if (nums.length === 0)
+    return null;
+  const min = Math.min(...nums);
+  const max = Math.max(...nums);
+  return min === max ? `p${min}` : `p${min}-p${max}`;
+}
+function layoutHazardNote(paragraph2, ctx) {
+  if (!paragraph2.runs.some((run33) => run33.type === "tab"))
+    return "";
+  const cols = ctx.governingColumns.get(paragraph2.id) ?? 1;
+  if (cols > 1) {
+    return ` ${formatNote("layout", [
+      ["cols", cols],
+      [
+        "warn",
+        `tab alignment can wrap mid-line in this ${cols}-column section; render to verify`
+      ]
+    ], [paragraph2.id])}`;
+  }
+  const tabs = paragraph2.tabStops ?? [];
+  if (tabs.some((tab) => tab.align === "right"))
+    return "";
+  const textWidthTwips = Math.round(ctx.contentWidthEmu / EMU_PER_TWIP2);
+  const fragile = tabs.find((tab) => (tab.align === "left" || tab.align === "center" || tab.align === "") && tab.pos > textWidthTwips * 0.7);
+  if (!fragile)
+    return "";
+  ctx.wrappingTabLines.push(paragraph2.id);
+  const gapIn = twipsToInches(Math.max(0, textWidthTwips - fragile.pos));
+  return ` ${formatNote("layout", [
+    ["tab", `${fragile.align || "left"}@${twipsToInches(fragile.pos)}in`],
+    [
+      "warn",
+      `right content on a LEFT tab ~${gapIn}in from the margin \u2014 wraps when longer (cure: --tabs right; see the docx:layout fix-all at top)`
+    ]
+  ], [paragraph2.id])}`;
+}
+function governedRange(blocks, index2) {
+  let first;
+  let last;
+  for (let cursor = index2 - 1;cursor >= 0; cursor--) {
+    const block = blocks[cursor];
+    if (!block)
+      continue;
+    if (block.type === "sectionBreak")
+      break;
+    first = block.id;
+    if (last === undefined)
+      last = block.id;
+  }
+  if (!first || !last)
+    return;
+  return first === last ? first : `${first}..${last}`;
+}
+function renderSectionBreak(block, governs) {
   const pairs = [];
   if (block.columns !== undefined && block.columns > 1) {
     pairs.push(["cols", block.columns]);
   }
   if (block.sectionType !== undefined)
     pairs.push(["type", block.sectionType]);
+  if (governs !== undefined && pairs.length > 0) {
+    pairs.push(["applies-to", `${governs} (above)`]);
+  }
   return formatNote("section", pairs, [block.id]);
 }
 function contentWidthEmu(geometry) {
@@ -87755,25 +87915,25 @@ function contentWidthEmu(geometry) {
   const fallback = (DEFAULT_PAGE.width - 2 * DEFAULT_PAGE.margin) * EMU_PER_TWIP2;
   return contentTwips > 0 ? contentTwips * EMU_PER_TWIP2 : fallback;
 }
-function formatImageNote(run34, contentEmu) {
+function formatImageNote(run33, contentEmu) {
   const pairs = [];
-  if (run34.widthEmu && run34.heightEmu) {
+  if (run33.widthEmu && run33.heightEmu) {
     pairs.push([
       "size",
-      `${emuToInches(run34.widthEmu)}x${emuToInches(run34.heightEmu)}in`
+      `${emuToInches(run33.widthEmu)}x${emuToInches(run33.heightEmu)}in`
     ]);
   }
-  if (run34.floating)
+  if (run33.floating)
     pairs.push(["float", "yes"]);
-  if (run34.wrap)
-    pairs.push(["wrap", run34.wrap]);
-  if (run34.align)
-    pairs.push(["align", run34.align]);
-  if (run34.widthEmu && run34.widthEmu > contentEmu)
+  if (run33.wrap)
+    pairs.push(["wrap", run33.wrap]);
+  if (run33.align)
+    pairs.push(["align", run33.align]);
+  if (run33.widthEmu && run33.widthEmu > contentEmu)
     pairs.push(["overflow", "yes"]);
   if (pairs.length === 0)
     return "";
-  return ` ${formatNote("image", pairs, [run34.id])}`;
+  return ` ${formatNote("image", pairs, [run33.id])}`;
 }
 function documentGeometry(blocks) {
   for (let index2 = blocks.length - 1;index2 >= 0; index2--) {
@@ -87825,14 +87985,14 @@ function isCodeBlockParagraph(block) {
 function renderCodeBlockGroup(paragraphs, ctx) {
   if (ctx.options.view !== "baseline" && ctx.options.view !== "accepted") {
     for (const paragraph2 of paragraphs) {
-      for (const run34 of paragraph2.runs) {
-        if (run34.type === "text" && run34.trackedChange) {
-          ctx.referencedTrackedChanges.set(run34.trackedChange.id, run34.trackedChange);
+      for (const run33 of paragraph2.runs) {
+        if (run33.type === "text" && run33.trackedChange) {
+          ctx.referencedTrackedChanges.set(run33.trackedChange.id, run33.trackedChange);
         }
       }
     }
   }
-  const lines = paragraphs.map((paragraph2) => paragraph2.runs.filter((run34) => run34.type === "text" && typeof run34.text === "string").map((run34) => run34.text).join(""));
+  const lines = paragraphs.map((paragraph2) => paragraph2.runs.filter((run33) => run33.type === "text" && typeof run33.text === "string").map((run33) => run33.text).join(""));
   const firstId = paragraphs[0]?.id ?? "";
   const lastId = paragraphs[paragraphs.length - 1]?.id ?? firstId;
   const language = codeBlockLanguageFromStyleId(paragraphs[0]?.style) ?? "";
@@ -87852,7 +88012,7 @@ function renderParagraph(paragraph2, ctx) {
   const body = rendered.replace(/[ \t]+$/, "");
   const separator = isDisplayEquationOnly(body) ? `
 ` : " ";
-  return `${prefix}${body}${separator}<!-- ${paragraph2.id} -->${formatParagraphNote(paragraph2)}`;
+  return `${prefix}${body}${separator}<!-- ${paragraph2.id} -->${formatParagraphNote(paragraph2)}${layoutHazardNote(paragraph2, ctx)}`;
 }
 function formatParagraphNote(paragraph2) {
   const pairs = [];
@@ -87925,10 +88085,10 @@ function headingLevelFor(style) {
 function renderRuns(paragraphId, runs, ctx, mask, baseOffset) {
   const view = ctx.options.view ?? "accepted";
   const visibleEntries = [];
-  runs.forEach((run34, index2) => {
-    if (run34.type === "text" && !isRunVisible(run34, view))
+  runs.forEach((run33, index2) => {
+    if (run33.type === "text" && !isRunVisible(run33, view))
       return;
-    visibleEntries.push({ run: run34, originalIndex: index2 });
+    visibleEntries.push({ run: run33, originalIndex: index2 });
   });
   let out = "";
   let cursor = 0;
@@ -87939,14 +88099,14 @@ function renderRuns(paragraphId, runs, ctx, mask, baseOffset) {
       cursor++;
       continue;
     }
-    const { run: run34 } = entry;
-    if (run34.type === "text") {
+    const { run: run33 } = entry;
+    if (run33.type === "text") {
       let lookahead2 = cursor + 1;
       while (lookahead2 < visibleEntries.length) {
         const next = visibleEntries[lookahead2];
         if (!next || next.run.type !== "text")
           break;
-        if (!sameDecoration(run34, next.run))
+        if (!sameDecoration(run33, next.run))
           break;
         lookahead2++;
       }
@@ -87967,29 +88127,29 @@ function renderRuns(paragraphId, runs, ctx, mask, baseOffset) {
       cursor = lookahead2;
       continue;
     }
-    if (run34.type === "image") {
-      const alt = sanitizeAltText(run34.alt ?? run34.id);
-      const extension2 = extensionForImageMime(run34.contentType) ?? "bin";
-      out += `![${alt}](${run34.hash}.${extension2})`;
-      out += formatImageNote(run34, ctx.contentWidthEmu);
-    } else if (run34.type === "break") {
-      if (run34.kind === "line")
+    if (run33.type === "image") {
+      const alt = sanitizeAltText(run33.alt ?? run33.id);
+      const extension2 = extensionForImageMime(run33.contentType) ?? "bin";
+      out += `![${alt}](${run33.hash}.${extension2})`;
+      out += formatImageNote(run33, ctx.contentWidthEmu);
+    } else if (run33.type === "break") {
+      if (run33.kind === "line")
         out += `
 `;
-    } else if (run34.type === "tab") {
+    } else if (run33.type === "tab") {
       out += "\t";
-    } else if (run34.type === "equation") {
-      const body = run34.latex.length > 0 ? run34.latex : run34.text;
-      out += run34.display ? `$$${body}$$` : `$${body}$`;
+    } else if (run33.type === "equation") {
+      const body = run33.latex.length > 0 ? run33.latex : run33.text;
+      out += run33.display ? `$$${body}$$` : `$${body}$`;
       out += commentEndingsFor(paragraphId, [{ originalIndex: cursor }], ctx.commentIndex);
-    } else if (run34.type === "noteRef") {
-      if (run34.kind === "footnote")
-        ctx.referencedFootnoteIds.add(run34.id);
+    } else if (run33.type === "noteRef") {
+      if (run33.kind === "footnote")
+        ctx.referencedFootnoteIds.add(run33.id);
       else
-        ctx.referencedEndnoteIds.add(run34.id);
-      out += `[^${run34.id}]`;
-    } else if (run34.type === "chart") {
-      out += `\`[${run34.kind}]\``;
+        ctx.referencedEndnoteIds.add(run33.id);
+      out += `[^${run33.id}]`;
+    } else if (run33.type === "chart") {
+      out += `\`[${run33.kind}]\``;
     }
     cursor++;
   }
@@ -88023,7 +88183,7 @@ function sameCommentSet(left, right) {
   return true;
 }
 function renderTextSegment(runs, view, baseline, mask, offset2) {
-  const text6 = runs.map((run34) => run34.text).join("");
+  const text6 = runs.map((run33) => run33.text).join("");
   if (text6.length === 0)
     return "";
   const first = runs[0];
@@ -88067,33 +88227,33 @@ function criticMarkerFor(kind) {
     return "++";
   return "--";
 }
-function needsHtmlWrap(run34, baseline) {
-  return Boolean(run34.color && !isDefaultColor(run34.color) || run34.colorTheme && !isDefaultThemeColor(run34) || run34.shade || run34.font && run34.font !== baseline.font || run34.sizeHalfPoints !== undefined && run34.sizeHalfPoints !== baseline.sizeHalfPoints || run34.smallCaps || run34.allCaps || run34.underline || run34.vertAlign === "superscript" || run34.vertAlign === "subscript" || run34.highlight);
+function needsHtmlWrap(run33, baseline) {
+  return Boolean(run33.color && !isDefaultColor(run33.color) || run33.colorTheme && !isDefaultThemeColor(run33) || run33.shade || run33.font && run33.font !== baseline.font || run33.sizeHalfPoints !== undefined && run33.sizeHalfPoints !== baseline.sizeHalfPoints || run33.smallCaps || run33.allCaps || run33.underline || run33.vertAlign === "superscript" || run33.vertAlign === "subscript" || run33.highlight);
 }
-function wrapRunFormatting(body, run34, baseline) {
+function wrapRunFormatting(body, run33, baseline) {
   const styles = [];
   const attrs = [];
-  if (run34.color && !isDefaultColor(run34.color))
-    styles.push(`color:#${run34.color}`);
-  if (run34.shade)
-    styles.push(`background-color:#${run34.shade}`);
-  if (run34.font && run34.font !== baseline.font) {
-    styles.push(`font-family:${cssFontFamily(run34.font)}`);
+  if (run33.color && !isDefaultColor(run33.color))
+    styles.push(`color:#${run33.color}`);
+  if (run33.shade)
+    styles.push(`background-color:#${run33.shade}`);
+  if (run33.font && run33.font !== baseline.font) {
+    styles.push(`font-family:${cssFontFamily(run33.font)}`);
   }
-  if (run34.sizeHalfPoints !== undefined && run34.sizeHalfPoints !== baseline.sizeHalfPoints) {
-    styles.push(`font-size:${run34.sizeHalfPoints / 2}pt`);
+  if (run33.sizeHalfPoints !== undefined && run33.sizeHalfPoints !== baseline.sizeHalfPoints) {
+    styles.push(`font-size:${run33.sizeHalfPoints / 2}pt`);
   }
-  if (run34.smallCaps)
+  if (run33.smallCaps)
     styles.push("font-variant:small-caps");
-  if (run34.allCaps)
+  if (run33.allCaps)
     styles.push("text-transform:uppercase");
-  if (run34.colorTheme && !isDefaultThemeColor(run34)) {
-    attrs.push(htmlAttr("data-color-theme", run34.colorTheme));
-    if (run34.colorThemeTint) {
-      attrs.push(htmlAttr("data-color-theme-tint", run34.colorThemeTint));
+  if (run33.colorTheme && !isDefaultThemeColor(run33)) {
+    attrs.push(htmlAttr("data-color-theme", run33.colorTheme));
+    if (run33.colorThemeTint) {
+      attrs.push(htmlAttr("data-color-theme-tint", run33.colorThemeTint));
     }
-    if (run34.colorThemeShade) {
-      attrs.push(htmlAttr("data-color-theme-shade", run34.colorThemeShade));
+    if (run33.colorThemeShade) {
+      attrs.push(htmlAttr("data-color-theme-shade", run33.colorThemeShade));
     }
   }
   let out = body;
@@ -88102,18 +88262,18 @@ function wrapRunFormatting(body, run34, baseline) {
     const attrPart = attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
     out = `<span${stylePart}${attrPart}>${out}</span>`;
   }
-  if (run34.underline === "single") {
+  if (run33.underline === "single") {
     out = `<u>${out}</u>`;
-  } else if (run34.underline) {
-    const color2 = run34.underlineColor ? ` ${htmlAttr("data-underline-color", run34.underlineColor)}` : "";
-    out = `<u ${htmlAttr("data-underline", run34.underline)}${color2}>${out}</u>`;
+  } else if (run33.underline) {
+    const color2 = run33.underlineColor ? ` ${htmlAttr("data-underline-color", run33.underlineColor)}` : "";
+    out = `<u ${htmlAttr("data-underline", run33.underline)}${color2}>${out}</u>`;
   }
-  if (run34.vertAlign === "superscript")
+  if (run33.vertAlign === "superscript")
     out = `<sup>${out}</sup>`;
-  else if (run34.vertAlign === "subscript")
+  else if (run33.vertAlign === "subscript")
     out = `<sub>${out}</sub>`;
-  if (run34.highlight) {
-    const named = run34.highlight === "yellow" ? "" : ` ${htmlAttr("data-highlight", run34.highlight)}`;
+  if (run33.highlight) {
+    const named = run33.highlight === "yellow" ? "" : ` ${htmlAttr("data-highlight", run33.highlight)}`;
     out = `<mark${named}>${out}</mark>`;
   }
   return out;
@@ -88122,8 +88282,8 @@ function isDefaultColor(color2) {
   const normalized = color2.toLowerCase();
   return normalized === "000000" || normalized === "auto";
 }
-function isDefaultThemeColor(run34) {
-  return (run34.colorTheme === "text1" || run34.colorTheme === "dark1") && !run34.colorThemeTint && !run34.colorThemeShade;
+function isDefaultThemeColor(run33) {
+  return (run33.colorTheme === "text1" || run33.colorTheme === "dark1") && !run33.colorThemeTint && !run33.colorThemeShade;
 }
 function cssFontFamily(font) {
   return /\s/.test(font) ? `'${font}'` : font;
@@ -88140,19 +88300,19 @@ function applyEscapeMask(text6, mask, offset2) {
 }
 function paragraphContent(runs, view) {
   let content3 = "";
-  for (const run34 of runs) {
-    if (run34.type !== "text")
+  for (const run33 of runs) {
+    if (run33.type !== "text")
       continue;
-    if (run34.runStyle === "Code")
+    if (run33.runStyle === "Code")
       continue;
-    if (!isRunVisible(run34, view))
+    if (!isRunVisible(run33, view))
       continue;
-    content3 += run34.text;
+    content3 += run33.text;
   }
   return content3;
 }
 function hasEquationRun(runs) {
-  return runs.some((run34) => run34.type === "equation");
+  return runs.some((run33) => run33.type === "equation");
 }
 function renderTable(table, ctx) {
   const view = ctx.options.view ?? "accepted";
@@ -88438,9 +88598,9 @@ var init_markdown3 = __esm(() => {
 // src/cli/read/index.ts
 var exports_read = {};
 __export(exports_read, {
-  run: () => run34
+  run: () => run33
 });
-async function run34(args) {
+async function run33(args) {
   const parsed = await tryParseArgs(args, {
     ast: { type: "boolean" },
     from: { type: "string" },
@@ -88450,16 +88610,16 @@ async function run34(args) {
     current: { type: "boolean" },
     comments: { type: "boolean" },
     help: { type: "boolean", short: "h" }
-  }, HELP30);
+  }, HELP29);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP30);
+    await writeStdout(HELP29);
     return EXIT2.OK;
   }
   const path2 = parsed.positionals[0];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP30);
+    return fail("USAGE", "Missing FILE argument", HELP29);
   const ast = Boolean(parsed.values.ast);
   const from = parsed.values.from;
   const to = parsed.values.to;
@@ -88468,11 +88628,11 @@ async function run34(args) {
   const current = Boolean(parsed.values.current);
   const showComments = Boolean(parsed.values.comments);
   if (ast && (from || to || accepted || baseline || current || showComments)) {
-    return fail("USAGE", "--from, --to, --accepted, --baseline, --current, and --comments are Markdown-only and cannot be combined with --ast", HELP30);
+    return fail("USAGE", "--from, --to, --accepted, --baseline, --current, and --comments are Markdown-only and cannot be combined with --ast", HELP29);
   }
   const view = resolveView({ accepted, baseline, current });
   if (!view) {
-    return fail("USAGE", "--accepted, --baseline, and --current are mutually exclusive", HELP30);
+    return fail("USAGE", "--accepted, --baseline, and --current are mutually exclusive", HELP29);
   }
   const docView = await openOrFail(path2);
   if (typeof docView === "number")
@@ -88488,7 +88648,8 @@ async function run34(args) {
       to,
       view,
       showComments,
-      defaultSizeHalfPoints: docView.styles?.defaultSizeHalfPoints()
+      defaultSizeHalfPoints: docView.styles?.defaultSizeHalfPoints(),
+      trackChangesOn: docView.isTrackChangesEnabled()
     });
     await writeStdout(rendered);
     return EXIT2.OK;
@@ -88499,7 +88660,7 @@ async function run34(args) {
     throw err;
   }
 }
-var HELP30 = `docx read \u2014 render document body as Markdown, or print AST as JSON
+var HELP29 = `docx read \u2014 render document body as Markdown, or print AST as JSON
 
 Usage:
   docx read FILE [options]
@@ -88589,20 +88750,20 @@ function parsePagesSpec(spec) {
 // src/cli/render/index.ts
 var exports_render = {};
 __export(exports_render, {
-  run: () => run35
+  run: () => run34
 });
 import { basename as basename2, extname as extname2, resolve as resolve2 } from "path";
-async function run35(args) {
-  const parsed = await tryParseArgs(args, OPTION_SPEC5, HELP31);
+async function run34(args) {
+  const parsed = await tryParseArgs(args, OPTION_SPEC4, HELP30);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP31);
+    await writeStdout(HELP30);
     return EXIT2.OK;
   }
   const filePath = parsed.positionals[0];
   if (!filePath)
-    return fail("USAGE", "Missing FILE argument", HELP31);
+    return fail("USAGE", "Missing FILE argument", HELP30);
   if (!await Bun.file(filePath).exists()) {
     return fail("FILE_NOT_FOUND", `File not found: ${filePath}`);
   }
@@ -88682,7 +88843,7 @@ function availabilityHint(installed) {
   }
   return `Detected engines: ${installed.join(", ")} \u2014 but none chose auto-select; pass --engine explicitly.`;
 }
-var HELP31 = `docx render \u2014 render each page of a .docx as a PNG/JPG image
+var HELP30 = `docx render \u2014 render each page of a .docx as a PNG/JPG image
 
 Usage:
   docx render FILE [options]
@@ -88734,11 +88895,11 @@ Runtime dependencies:
     \u2014 no extra system tools (poppler / pdftoppm / ImageMagick) required.
 
 Run "docx render --help" or "docx --help" for the full command list.
-`, OPTION_SPEC5;
+`, OPTION_SPEC4;
 var init_render2 = __esm(() => {
   init_core2();
   init_respond();
-  OPTION_SPEC5 = {
+  OPTION_SPEC4 = {
     out: { type: "string" },
     engine: { type: "string" },
     dpi: { type: "string" },
@@ -88899,9 +89060,9 @@ var init_batch4 = __esm(() => {
 // src/cli/replace/index.ts
 var exports_replace3 = {};
 __export(exports_replace3, {
-  run: () => run36
+  run: () => run35
 });
-async function run36(args) {
+async function run35(args) {
   const parsed = await tryParseArgs(args, {
     batch: { type: "string" },
     regex: { type: "boolean" },
@@ -88914,30 +89075,30 @@ async function run36(args) {
     baseline: { type: "boolean" },
     exact: { type: "boolean" },
     ...SAVE_FLAGS
-  }, HELP32);
+  }, HELP31);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP32);
+    await writeStdout(HELP31);
     return EXIT2.OK;
   }
   setVerboseAck(Boolean(parsed.values.verbose));
   const path2 = parsed.positionals[0];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP32);
+    return fail("USAGE", "Missing FILE argument", HELP31);
   const batchInput = parsed.values.batch;
   if (batchInput !== undefined) {
     if (parsed.positionals.length > 1) {
-      return fail("USAGE", "--batch reads pattern/replacement from the JSONL file; don't also pass them as positionals", HELP32);
+      return fail("USAGE", "--batch reads pattern/replacement from the JSONL file; don't also pass them as positionals", HELP31);
     }
     return runReplaceBatch(path2, batchInput, parsed.values);
   }
   const pattern = parsed.positionals[1];
   const replacement = parsed.positionals[2];
   if (pattern == null)
-    return fail("USAGE", "Missing PATTERN argument", HELP32);
+    return fail("USAGE", "Missing PATTERN argument", HELP31);
   if (replacement == null) {
-    return fail("USAGE", "Missing REPLACEMENT argument", HELP32);
+    return fail("USAGE", "Missing REPLACEMENT argument", HELP31);
   }
   const ignoreCase = Boolean(parsed.values["ignore-case"]);
   const useRegex = Boolean(parsed.values.regex);
@@ -89041,6 +89202,8 @@ async function run36(args) {
     replaceSpanInParagraph(blockRef.node, { start: match.start, end: match.end }, concreteReplacement, tracked, findView);
   }
   await document4.save(outputPath);
+  const remaining = allMatches.length - selected.length;
+  const partialHint = remaining > 0 ? `\u21B3 ${remaining} more match${remaining === 1 ? "" : "es"} left unreplaced (${selected.length} of ${allMatches.length} done) \u2014 pass --all to replace every match, or --limit N for a specific count.` : undefined;
   await respondAck({
     ok: true,
     operation: "replace",
@@ -89054,10 +89217,10 @@ async function run36(args) {
     replaced: selected.length,
     matches: matchesPayload,
     ...normalizationFields
-  });
+  }, partialHint);
   return EXIT2.OK;
 }
-var HELP32 = `docx replace \u2014 substitute text spans (sed for docx)
+var HELP31 = `docx replace \u2014 substitute text spans (sed for docx)
 
 Usage:
   docx replace FILE PATTERN REPLACEMENT [options]
@@ -89135,6 +89298,258 @@ var init_replace4 = __esm(() => {
   init_batch4();
 });
 
+// src/cli/sections/index.tsx
+var exports_sections = {};
+__export(exports_sections, {
+  run: () => run36
+});
+async function run36(args) {
+  const parsed = await tryParseArgs(args, OPTION_SPEC5, HELP32);
+  if (typeof parsed === "number")
+    return parsed;
+  if (parsed.values.help) {
+    await writeStdout(HELP32);
+    return EXIT2.OK;
+  }
+  setVerboseAck(Boolean(parsed.values.verbose));
+  const filePath = parsed.positionals[0];
+  if (!filePath)
+    return fail("USAGE", "Missing FILE argument", HELP32);
+  const at = parsed.values.at;
+  if (!at) {
+    return fail("USAGE", "Missing --at LOCATOR (a range pN-pM or a section sN)", HELP32);
+  }
+  const count = parseCount(parsed.values.columns);
+  if (typeof count === "number" && Number.isNaN(count)) {
+    return fail("USAGE", `--columns must be a positive integer`, HELP32);
+  }
+  if (count === undefined)
+    return fail("USAGE", "Missing --columns N", HELP32);
+  const typeRaw = parsed.values.type;
+  if (typeRaw !== undefined && !isSectionType(typeRaw)) {
+    return fail("USAGE", `Invalid --type: ${typeRaw}`, "Valid values: continuous, nextPage, evenPage, oddPage, nextColumn");
+  }
+  let locator;
+  try {
+    locator = parseLocator(at);
+  } catch (error) {
+    if (error instanceof LocatorParseError) {
+      return fail("INVALID_LOCATOR", error.message, HELP32);
+    }
+    throw error;
+  }
+  const document4 = await openOrFail(filePath);
+  if (typeof document4 === "number")
+    return document4;
+  const opts = {
+    filePath,
+    count,
+    sectionType: typeRaw,
+    authorFlag: parsed.values.author,
+    trackFlag: Boolean(parsed.values.track),
+    outputPath: parsed.values.output,
+    dryRun: Boolean(parsed.values["dry-run"])
+  };
+  if (locator.kind === "blockRange") {
+    const range = await resolveBlockRangeOrFail(document4, at);
+    if (typeof range === "number")
+      return range;
+    return wrapRange(document4, range.parent, range.startIndex, range.endIndex, at, opts);
+  }
+  const blockRef = await resolveBlockOrFail(document4, at);
+  if (typeof blockRef === "number")
+    return blockRef;
+  if (blockRef.node.tag === "w:sectPr") {
+    return editSection(document4, blockRef, at, opts);
+  }
+  if (blockRef.node.tag === "w:p") {
+    const index2 = blockRef.parent.indexOf(blockRef.node);
+    return wrapRange(document4, blockRef.parent, index2, index2, at, opts);
+  }
+  return fail("INVALID_LOCATOR", `columns needs a section (sN) or a paragraph range (pN-pM); ${at} is neither`, HELP32);
+}
+async function editSection(document4, blockRef, at, opts) {
+  try {
+    new Edit(document4).section(blockRef, { columns: opts.count, sectionType: opts.sectionType }, { authorFlag: opts.authorFlag, track: opts.trackFlag });
+  } catch (error) {
+    if (error instanceof EditError)
+      return fail(error.code, error.message);
+    throw error;
+  }
+  return commit(document4, opts, { at, mode: "section" });
+}
+async function wrapRange(document4, parent, startIndex, endIndex, at, opts) {
+  if (parent !== document4.body.findBodyChildren()) {
+    return fail("USAGE", `columns can only wrap body-level paragraphs; ${at} is inside a table cell`, "Section breaks carry column layout and cannot live in a table cell.");
+  }
+  for (let index2 = startIndex;index2 <= endIndex; index2++) {
+    if (containsSectionBreak(parent[index2])) {
+      return fail("USAGE", `The range ${at} already contains a section break`, "Target the existing section directly with `--at sN`, or pick a range without one.");
+    }
+  }
+  const governing = governingColumns(parent, endIndex + 1);
+  const track = resolveTracked(document4, opts.trackFlag);
+  const insert = new Insert(document4);
+  const allocator = track ? new TrackChanges(document4).createAllocator() : undefined;
+  const endNode = parent[endIndex];
+  if (!endNode) {
+    return fail("BLOCK_NOT_FOUND", "Range end is stale (parent does not contain it)");
+  }
+  const startNode = startIndex > 0 ? parent[startIndex] : undefined;
+  if (startIndex > 0 && !startNode) {
+    return fail("BLOCK_NOT_FOUND", "Range start is stale (parent does not contain it)");
+  }
+  let afterBlocks;
+  let beforeBlocks = [];
+  try {
+    afterBlocks = await insert.paragraph({ node: endNode, parent }, {
+      kind: "section",
+      columns: opts.count,
+      sectionType: opts.sectionType ?? "continuous"
+    }, {}, { placement: "after", authorFlag: opts.authorFlag, track, allocator });
+    if (startNode) {
+      beforeBlocks = await insert.paragraph({ node: startNode, parent }, {
+        kind: "section",
+        ...governing > 1 ? { columns: governing } : {},
+        sectionType: "continuous"
+      }, {}, { placement: "before", authorFlag: opts.authorFlag, track, allocator });
+    }
+  } catch (error) {
+    if (error instanceof InsertError)
+      return fail(error.code, error.message, error.hint);
+    throw error;
+  }
+  if (opts.dryRun) {
+    return commit(document4, opts, { at, mode: "range", dryRunOnly: true });
+  }
+  parent.splice(endIndex + 1, 0, ...afterBlocks);
+  parent.splice(startIndex, 0, ...beforeBlocks);
+  return commit(document4, opts, { at, mode: "range" });
+}
+function containsSectionBreak(node2) {
+  if (!node2)
+    return false;
+  if (node2.tag === "w:sectPr")
+    return true;
+  if (node2.tag !== "w:p")
+    return false;
+  return Boolean(node2.findChild("w:pPr")?.findChild("w:sectPr"));
+}
+function governingColumns(parent, fromIndex) {
+  for (let index2 = fromIndex;index2 < parent.length; index2++) {
+    const node2 = parent[index2];
+    if (!node2)
+      continue;
+    if (node2.tag === "w:sectPr")
+      return columnsOf(node2);
+    if (node2.tag === "w:p") {
+      const inline = node2.findChild("w:pPr")?.findChild("w:sectPr");
+      if (inline)
+        return columnsOf(inline);
+    }
+  }
+  return 1;
+}
+function columnsOf(sectPr) {
+  const raw = sectPr.findChild("w:cols")?.getAttribute("w:num");
+  const parsed = raw ? Number.parseInt(raw, 10) : 1;
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 1;
+}
+function parseCount(raw) {
+  if (raw === undefined)
+    return;
+  if (!/^\d+$/.test(raw.trim()))
+    return Number.NaN;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed < 1)
+    return Number.NaN;
+  return parsed;
+}
+async function commit(document4, opts, meta) {
+  if (opts.dryRun || meta.dryRunOnly) {
+    await respond({
+      operation: "sections",
+      dryRun: true,
+      path: opts.filePath,
+      locator: meta.at,
+      columnCount: opts.count,
+      mode: meta.mode,
+      ...opts.outputPath ? { output: opts.outputPath } : {}
+    });
+    return EXIT2.OK;
+  }
+  await document4.save(opts.outputPath);
+  const destination = opts.outputPath ?? opts.filePath;
+  await respondAck({
+    ok: true,
+    operation: "sections",
+    path: destination,
+    locator: meta.at,
+    columnCount: opts.count,
+    mode: meta.mode
+  }, renderVerifyHint(destination));
+  return EXIT2.OK;
+}
+var HELP32 = `docx sections \u2014 multi-column layout & section breaks
+
+Usage:
+  docx sections FILE --at LOCATOR --columns N [options]
+
+The verb for section layout \u2014 multi-column flow and section breaks \u2014 so you
+don't have to hand-build them with the right OOXML semantics. This is the ONLY
+way to add/change column layout; \`insert\` no longer takes --section (a raw
+section break formats the content ABOVE it, which is the classic off-by-one).
+Two addressing modes:
+
+  --at pN-pM   Wrap the paragraph range pN\u2026pM in its own N-column section
+               (inserts the bounding continuous section breaks for you, so the
+               columns land on EXACTLY pN\u2026pM). Also accepts a single paragraph
+               (--at pN). THIS is how you put text in columns \u2014 name the range.
+  --at sN      Set the column count on an EXISTING section break sN (the section
+               whose content ENDS at sN). Equivalent to \`edit --at sN --columns N\`.
+
+Options:
+  --at LOCATOR      Paragraph range (pN-pM), single paragraph (pN), or section (sN)
+  --columns N       Number of columns (>= 1; use 1 to collapse back to single column)
+  --type T          Section type for the wrapping break: continuous (default),
+                    nextPage, evenPage, oddPage, nextColumn. Only meaningful with
+                    a pN-pM/pN range; with sN it overrides the section's type.
+  --author NAME     Author for tracked changes (default: $DOCX_AUTHOR)
+  --track           Record as a tracked change even when the doc toggle is off
+  -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 full success ack JSON
+  -h, --help        Show this help
+
+Agent tip: VERIFY LAYOUT VISUALLY. \`docx read\` shows the section as a
+\`<!-- docx:section \u2026 cols="N" -->\` annotation but NOT how the columns actually
+flow on the page (balance, overflow). After setting columns, render and look:
+  docx render FILE --out pages/
+Adjust the range and re-render until the columns read the way you intended.
+
+Output:
+  Prints a one-line confirmation on success (exit 0); --verbose prints {ok:true, \u2026}. Positional ids shift
+  after a range wrap (two section breaks are inserted), so re-read before further
+  edits. Errors print {code, error, hint?} + nonzero exit.
+
+Examples:
+  docx sections doc.docx --at p4-p9 --columns 2
+  docx sections doc.docx --at p4-p9 --columns 3 --type continuous
+  docx sections doc.docx --at s2 --columns 1     # collapse section s2 to one column
+`, OPTION_SPEC5;
+var init_sections2 = __esm(() => {
+  init_core2();
+  init_respond();
+  OPTION_SPEC5 = {
+    at: { type: "string" },
+    columns: { type: "string" },
+    type: { type: "string" },
+    author: { type: "string" },
+    track: { type: "boolean" },
+    ...SAVE_FLAGS
+  };
+});
+
 // src/cli/styles/index.ts
 var exports_styles = {};
 __export(exports_styles, {
@@ -89366,8 +89781,15 @@ async function run38(args) {
     return fail("USAGE", `--position must be an integer in 0..${grid.rows.length}`);
   }
   const cellTexts = parsed.values.cells ? parsed.values.cells.split(",") : [];
-  if (cellTexts.length > grid.colCount) {
-    return fail("USAGE", `--cells has ${cellTexts.length} entries but table ${tableId} has ${grid.colCount} columns`);
+  for (const cell of cellTexts) {
+    const mangled = await rejectShellMangledValue(cell, HELP34, "--cells");
+    if (typeof mangled === "number")
+      return mangled;
+  }
+  const reference = referenceRow(grid, position2);
+  const logicalCols = reference ? reference.cells.length : grid.colCount;
+  if (cellTexts.length > logicalCols) {
+    return fail("USAGE", `--cells has ${cellTexts.length} entries but the row has ${logicalCols} columns (a merged cell counts once)`);
   }
   const newRow = buildRow(grid, position2, cellTexts);
   const tracking = resolveTracked(document4, parsed.values.track);
@@ -89409,9 +89831,16 @@ function resolveRowPosition(raw, rowCount) {
     return null;
   return value;
 }
+function referenceRow(grid, position2) {
+  const above = position2 > 0 ? grid.rows[position2 - 1] : undefined;
+  const below = position2 < grid.rows.length ? grid.rows[position2] : undefined;
+  return above ?? below;
+}
 function buildRow(grid, position2, cellTexts) {
   const below = position2 > 0 && position2 < grid.rows.length ? grid.rows[position2] : undefined;
+  const spans = referenceRow(grid, position2);
   const cells = [];
+  let logical = 0;
   for (let col = 0;col < grid.colCount; ) {
     const continued = below ? cellAt(below, col) : undefined;
     if (continued?.vMerge === "continue") {
@@ -89425,12 +89854,15 @@ function buildRow(grid, position2, cellTexts) {
       col += continued.colSpan;
       continue;
     }
+    const refSpan = spans ? cellAt(spans, col)?.colSpan ?? 1 : 1;
     cells.push(/* @__PURE__ */ jsxDEV(TableCell, {
+      gridSpan: refSpan > 1 ? refSpan : undefined,
       children: /* @__PURE__ */ jsxDEV(Paragraph, {
-        text: cellTexts[col] ?? ""
+        text: cellTexts[logical] ?? ""
       }, undefined, false, undefined, this)
     }, undefined, false, undefined, this));
-    col += 1;
+    logical += 1;
+    col += refSpan;
   }
   return /* @__PURE__ */ jsxDEV(w.tr, {
     children: cells
@@ -89450,6 +89882,7 @@ var init_insert_row = __esm(() => {
   init_jsx();
   init_locators();
   init_table();
+  init_parse_helpers();
   init_respond();
   init_jsx_dev_runtime();
   AT_FORMS6 = describeForms(["table"], "                     ");
@@ -89465,8 +89898,11 @@ ${AT_FORMS6}
 
 Optional:
   --position INDEX   0-based row index to insert at (default: append at end)
-  --cells "a,b,c"    Comma-separated text for the new cells (default: empty).
-                     Must not exceed the table's column count.
+  --cells "a,b,c"    Comma-separated text, one value per VISIBLE cell left to
+                     right (default: empty). On a table with merged cells the new
+                     row copies the neighbor row's gridSpan pattern, so you pass
+                     one value per logical column (a spanned cell counts once),
+                     NOT one per underlying grid column.
   --author NAME      Author for tracked insertion (default: $DOCX_AUTHOR)
   -o, --output PATH  Write to PATH instead of overwriting FILE
   --dry-run          Print what would change; do not write
@@ -89999,10 +90435,13 @@ async function run42(args) {
   const cols = grid.tblGrid.findChildren("w:gridCol");
   let twips = [];
   if (!auto) {
-    const resolved = resolveWidths(widthsSpec, cols);
+    const resolved = resolveWidths(widthsSpec, cols, grid);
     if (typeof resolved === "string")
       return fail("USAGE", resolved);
     twips = resolved;
+    const tooNarrow = findTooNarrowCell(grid, twips);
+    if (tooNarrow)
+      return fail("USAGE", tooNarrow);
   }
   const outputPath = parsed.values.output;
   if (parsed.values["dry-run"]) {
@@ -90038,20 +90477,24 @@ async function run42(args) {
     appendTblGridChange(grid.tblGrid, priorCols, new TrackChanges(document4).mintMeta(author));
   }
   await document4.save(outputPath);
+  const destination = outputPath ?? path2;
+  const echo = auto ? "" : `${describeColumnWidths(twips)}
+`;
   await respondAck({
     ok: true,
     operation: "tables.set-widths",
-    path: outputPath ?? path2,
+    path: destination,
     table: tableId,
     layout: auto ? "autofit" : "fixed",
     widths: auto ? "auto" : twips
-  });
+  }, `${echo}${renderVerifyHint(destination)}`);
   return EXIT2.OK;
 }
-function resolveWidths(spec, cols) {
+function resolveWidths(spec, cols, grid) {
   const tokens = spec.split(",").map((token) => token.trim());
   if (tokens.length !== cols.length) {
-    return `--widths has ${tokens.length} entries but the table has ${cols.length} columns`;
+    const base = `--widths has ${tokens.length} entries but the table has ${cols.length} grid columns`;
+    return hasMergedColumns(grid) ? `${base}. This table has merged cells, so some visible columns span multiple grid columns and the grid has more columns than any single row shows. Supply one width per GRID column (${cols.length} values), left-to-right; a merged cell takes the sum of the grid columns it covers. Inspect the gridSpan layout with \`docx read --ast\`.` : base;
   }
   const percentage = tokens.every((token) => token.endsWith("%"));
   const anyPercent = tokens.some((token) => token.endsWith("%"));
@@ -90103,7 +90546,30 @@ function cellWidth(cell, twips) {
   }
   return width;
 }
-var AT_FORMS10, HELP38;
+function findTooNarrowCell(grid, twips) {
+  for (const row of grid.rows) {
+    for (const cell of row.cells) {
+      const width = cellWidth(cell, twips);
+      if (width >= MIN_COL_TWIPS)
+        continue;
+      const text6 = cell.node.collectText().trim();
+      if (text6.length === 0)
+        continue;
+      const where = cell.colSpan > 1 ? `grid columns ${cell.colStart}\u2013${cell.colStart + cell.colSpan - 1}` : `grid column ${cell.colStart}`;
+      const sample = text6.length > 24 ? `${text6.slice(0, 24)}\u2026` : text6;
+      return `--widths collapses ${where} to ${twipsToInches(width)}in (${width} twips); that cell holds "${sample}" but ~0.15in goes to cell margins, leaving under one character \u2014 Word wraps it one char per line. Widen it and lower a wider column to compensate.`;
+    }
+  }
+  return null;
+}
+function hasMergedColumns(grid) {
+  return grid.rows.some((row) => row.cells.some((cell) => cell.colSpan > 1));
+}
+function describeColumnWidths(twips) {
+  const cells = twips.map((value, index2) => `g${index2}=${twipsToInches(value)}in`);
+  return `widths: ${cells.join(" ")}`;
+}
+var AT_FORMS10, HELP38, MIN_COL_TWIPS = 288;
 var init_set_widths = __esm(() => {
   init_core2();
   init_locators();
@@ -90136,6 +90602,15 @@ cell's <w:tcW>. Under track-changes the resize is recorded as a real revision
 (<w:tblGridChange> for the grid plus a per-cell <w:tcPrChange>), so it can be
 accepted or rejected \u2014 matching what Word emits for a width change.
 
+Widths map one value per GRID column, not per visible column. On a table with
+merged cells (gridSpan), the grid has MORE columns than a single row shows, so
+the count you pass must match the grid (run \`docx read --ast\` to see it). A
+cell that HOLDS TEXT but lands narrower than ~0.2in is refused \u2014 after ~0.15in
+of cell margin it fits under one character, so Word wraps it one char per line
+(empty/spacer columns that thin are fine, nothing to wrap). The success line
+echoes the resulting per-column widths; since layout changes don't show in
+\`read\`, render to verify.
+
 Output:
   Prints a one-line confirmation on success (exit 0). --verbose prints {ok:true, operation, path, table,
   layout, widths}. --dry-run prints the preview object (no ok field). Errors
@@ -90677,6 +91152,64 @@ var init_tables = __esm(() => {
   };
 });
 
+// src/cli/track-changes/groups.ts
+function revisionGroups(changes) {
+  const sorted = [...changes].sort((a2, b) => tcIndex(a2.id) - tcIndex(b.id));
+  const membersOf = new Map;
+  const revOf = new Map;
+  let next = 0;
+  let index2 = 0;
+  while (index2 < sorted.length) {
+    const a2 = sorted[index2];
+    const b = sorted[index2 + 1];
+    if (a2 && b && isTextReplacePair(a2, b)) {
+      const rev = `rev${next++}`;
+      membersOf.set(rev, [a2.id, b.id]);
+      revOf.set(a2.id, rev);
+      revOf.set(b.id, rev);
+      index2 += 2;
+      continue;
+    }
+    index2 += 1;
+  }
+  return { membersOf, revOf };
+}
+function isTextReplacePair(a2, b) {
+  if (a2.blockId === undefined || a2.blockId !== b.blockId)
+    return false;
+  const pair = `${a2.kind}+${b.kind}`;
+  return pair === "del+ins" || pair === "ins+del";
+}
+function expandRevisionTargets(targets, groups) {
+  const out = [];
+  for (const target of targets) {
+    if (/^rev\d+$/.test(target)) {
+      const members = groups.membersOf.get(target);
+      if (!members)
+        throw new UnknownRevisionError(target);
+      out.push(...members);
+      continue;
+    }
+    out.push(target);
+  }
+  return out;
+}
+function tcIndex(id) {
+  const match = id.match(/^tc(\d+)$/);
+  return match?.[1] ? Number(match[1]) : 0;
+}
+var UnknownRevisionError;
+var init_groups = __esm(() => {
+  UnknownRevisionError = class UnknownRevisionError extends Error {
+    revision;
+    constructor(revision) {
+      super(`Unknown revision group "${revision}"`);
+      this.revision = revision;
+      this.name = "UnknownRevisionError";
+    }
+  };
+});
+
 // src/cli/track-changes/list.ts
 var exports_list5 = {};
 __export(exports_list5, {
@@ -90737,6 +91270,12 @@ async function run47(args) {
     byId.set(change.id, record);
   }
   const sorted = [...byId.values()].sort((a2, b) => trackedChangeIndex(a2.id) - trackedChangeIndex(b.id));
+  const { revOf } = revisionGroups(sorted);
+  for (const record of sorted) {
+    const group = revOf.get(record.id);
+    if (group)
+      record.group = group;
+  }
   await respond(sorted);
   return EXIT2.OK;
 }
@@ -90761,7 +91300,11 @@ apart.
 
 Output: a bare JSON array of { id, kind, author, date, revisionId, blockId,
 text } sorted by id (document order). Each item's "id" (e.g. tc0) is its
-addressable handle \u2014 pass it to \`accept\`/\`reject --at tcN\`. Errors print
+addressable handle \u2014 pass it to \`accept\`/\`reject --at tcN\`. When a del and an
+ins are an adjacent REPLACE pair on the same paragraph, BOTH carry a shared
+"group": "revN" \u2014 accept/reject the whole logical change in one call with
+\`--at revN\` instead of accepting each half separately (tcN ids renumber after
+each single accept, so the revN handle avoids the re-list ping-pong). Errors print
 {code, error, hint?} with a nonzero exit. kind is one of: "ins", "del", "moveFrom",
 "moveTo", "sectPrChange", "rowIns", "rowDel", "cellIns", "cellDel",
 "tblGridChange", "tblPrChange", "tcPrChange", "checkboxToggle". Paragraph-mark
@@ -90790,6 +91333,7 @@ var init_list7 = __esm(() => {
   init_core2();
   init_track_changes();
   init_respond();
+  init_groups();
 });
 
 // src/cli/track-changes/apply.ts
@@ -90820,8 +91364,20 @@ async function runApply(args, verb, help) {
   const document4 = await openOrFail(path2);
   if (typeof document4 === "number")
     return document4;
-  const target = all2 ? "all" : atRaw ?? [];
   const trackChanges = new TrackChanges(document4);
+  let target;
+  if (all2) {
+    target = "all";
+  } else {
+    try {
+      target = expandRevisionTargets(atRaw ?? [], revisionGroups(trackChanges.list()));
+    } catch (error) {
+      if (error instanceof UnknownRevisionError) {
+        return fail("TRACKED_CHANGE_NOT_FOUND", error.message, "Run 'docx track-changes list FILE' \u2014 revN handles appear as the `group` field on paired changes.");
+      }
+      throw error;
+    }
+  }
   const outputPath = parsed.values.output;
   try {
     if (parsed.values["dry-run"]) {
@@ -90853,6 +91409,7 @@ async function runApply(args, verb, help) {
 var init_apply2 = __esm(() => {
   init_track_changes();
   init_respond();
+  init_groups();
 });
 
 // src/cli/track-changes/accept.ts
@@ -90899,6 +91456,10 @@ Target (one required, mutually exclusive):
                     batch is not a concern. Supports:
 ${AT_FORMS14}
                     See \`docx info locators\`.
+  --at revN         Accept a del+ins REPLACE pair in one call (both halves of one
+                    logical change). \`list\` tags the two tcNs with a shared
+                    "group": "revN"; addressing the revN saves the accept-relist-
+                    accept ping-pong (tcN ids renumber after each single accept).
   --all             Accept every tracked change.
 
 Options:
@@ -90952,7 +91513,7 @@ 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
+break disappears \u2014 for sentinels created by "docx sections" this also
 removes the section break the sentinel was carrying). Rejecting a
 paragraph-mark deletion just removes the marker (the paragraph stays).
 
@@ -90970,6 +91531,10 @@ Target (one required, mutually exclusive):
                     batch is not a concern. Supports:
 ${AT_FORMS15}
                     See \`docx info locators\`.
+  --at revN         Reject a del+ins REPLACE pair in one call (both halves of one
+                    logical change). \`list\` tags the two tcNs with a shared
+                    "group": "revN"; addressing the revN saves the reject-relist-
+                    reject ping-pong (tcN ids renumber after each single reject).
   --all             Reject every tracked change.
 
 Options:
@@ -91520,7 +92085,7 @@ Examples:
 // package.json
 var package_default = {
   name: "bun-docx",
-  version: "0.13.0",
+  version: "0.14.0",
   description: "CLI for AI agents (Claude, Codex) to read, edit, and comment on .docx files with full format fidelity.",
   keywords: [
     "docx",
@@ -91611,13 +92176,13 @@ Commands (each one-liner names capabilities you'd otherwise miss; see <command>
   create    FILE  Create a new .docx (--from PATH.md | --from - builds from Markdown; --force to overwrite)
   read      FILE  Render as Markdown with pN locators; --from/--to to slice, --accepted (default)/--current/--baseline tracked views, --comments, --ast for JSON-AST
   edit      FILE  Replace or strip text/formatting at pN, pN:S-E, pN-pM, sN, eqN, or table-cell locators (--clear to strip formatting, --track to redline, --batch for many edits in one read)
-  insert    FILE  Insert a paragraph, image, table, equation, code block, markdown, or structural break (--after/--before LOCATOR; --track; --batch for many inserts in one read)
+  insert    FILE  Insert a paragraph, image, table, equation, code block, markdown, or page break (--after/--before LOCATOR; --track; --batch for many inserts in one read). For COLUMN layout use "docx sections", not insert.
   delete    FILE  Remove a paragraph, range, table, or section break (--at LOCATOR; --track for tracked deletion; --batch to remove many in one read)
   find      FILE [QUERY]  Find spans by text, OR by formatting (--highlight/--color/--bold/--italic/--underline); returns locators for --at
   replace   FILE PATTERN REPL  Substitute text spans, sed-style (--regex, --track to redline, --dry-run to preview, --batch for a multi-pattern script)
   wc        FILE [LOCATOR]  Count words in the doc or a slice (--accepted/--baseline/--current tracked view, --json)
   outline   FILE  List headings as a locator tree (pN feeds --at / read --from; --style-prefix, --json)
-  columns   FILE  Lay a paragraph range out in N columns (--at pN-pM --count N) or recount a section (--at sN)
+  sections  FILE  Multi-column layout & section breaks \u2014 put a paragraph range in N columns (--at pN-pM --columns N) or recount a section (--at sN). The ONLY way to do columns; insert does not.
   styles    FILE  List the styles you can apply (--used for ones in use; --at ID to describe one) \u2014 the catalog isn't in the body
   render    FILE  Visual page verification \u2014 render each page as PNG/JPG via Word or LibreOffice
   comments  \u2026     Add (--at LOCATOR | --anchor PHRASE | --batch), reply, resolve (--unset to reopen), delete, list (--thread cN)
@@ -91645,7 +92210,7 @@ render (each render spins up Word and is slow). Render only for what Markdown ca
 multi-column sections, page/section breaks, image sizing/placement, table geometry \u2014 and
 then ONCE at the end (not after every edit), or one final time if you're genuinely unsure
 it looks right: "docx render FILE --out pages/" writes page-001.png, \u2026 which you can read.
-(A multi-column section's columns apply to content BEFORE the break \u2014 see "docx insert --help".)
+(To put text in columns, name the range: "docx sections --at pN-pM --columns N" \u2014 it inserts the bounding breaks so the columns land on exactly that range. A raw section break's columns apply to the content BEFORE it, which is why insert no longer takes --section.)
 
 Environment:
   DOCX_AUTHOR    Default author for comments and tracked-change attribution
@@ -91666,7 +92231,6 @@ async function printTopHelp() {
 // src/cli/index.ts
 init_respond();
 var COMMANDS = {
-  columns: () => Promise.resolve().then(() => (init_columns(), exports_columns)),
   comments: () => Promise.resolve().then(() => (init_comments3(), exports_comments)),
   create: () => Promise.resolve().then(() => (init_create2(), exports_create)),
   delete: () => Promise.resolve().then(() => (init_delete2(), exports_delete2)),
@@ -91682,6 +92246,7 @@ var COMMANDS = {
   read: () => Promise.resolve().then(() => (init_read3(), exports_read)),
   render: () => Promise.resolve().then(() => (init_render2(), exports_render)),
   replace: () => Promise.resolve().then(() => (init_replace4(), exports_replace3)),
+  sections: () => Promise.resolve().then(() => (init_sections2(), exports_sections)),
   styles: () => Promise.resolve().then(() => (init_styles2(), exports_styles)),
   tables: () => Promise.resolve().then(() => (init_tables(), exports_tables)),
   "track-changes": () => Promise.resolve().then(() => (init_track_changes2(), exports_track_changes)),
@@ -91711,6 +92276,9 @@ Run "docx --help" for available commands.
     }
     return 0;
   }
+  if (cmd === "columns") {
+    return fail("USAGE", "`docx columns` was renamed to `docx sections`", "Run `docx sections --at pN-pM --columns N` (or `docx sections --help`).");
+  }
   const loader = COMMANDS[cmd];
   if (!loader) {
     return fail("USAGE", `Unknown command: ${cmd}`, 'Run "docx --help" for the list of commands.');