bun-docx 0.16.0 → 0.18.0

package/dist/index.js

@@ -4710,12 +4710,15 @@ var init_jsx = __esm(() => {
     "type",
     "tbl",
     "tblPr",
+    "tblStyle",
     "tblPrChange",
     "tblGrid",
     "tblGridChange",
     "gridCol",
     "tr",
     "trPr",
+    "trHeight",
+    "tblHeader",
     "tc",
     "tcPr",
     "tcPrChange",
@@ -4761,6 +4764,7 @@ var init_jsx = __esm(() => {
     "tcW",
     "tblLayout",
     "vMerge",
+    "vAlign",
     "gridSpan",
     "numbering",
     "num",
@@ -18088,9 +18092,25 @@ function previewTrackedChanges(document2, target, verb) {
 }
 function applyTrackedChanges(document2, target, verb) {
   const targets = resolveTargets(document2, target);
-  const records = targets.map((found) => recordFor(found, verb));
-  const affectedNotes = collectAffectedNotes(targets);
-  for (const found of [...targets].reverse()) {
+  return applyResolvedTargets(document2, targets.map((found) => ({ found, verb })));
+}
+function applyTrackedDecisions(document2, accepts, rejects) {
+  const acceptTargets = resolveTargets(document2, accepts).map((found) => ({
+    found,
+    verb: "accept"
+  }));
+  const rejectTargets = resolveTargets(document2, rejects).map((found) => ({
+    found,
+    verb: "reject"
+  }));
+  return applyResolvedTargets(document2, [...acceptTargets, ...rejectTargets]);
+}
+function applyResolvedTargets(document2, decisions) {
+  const order = collectTrackedChanges(document2);
+  const sorted = [...decisions].sort((left, right) => indexOfFound(order, left.found) - indexOfFound(order, right.found));
+  const records = sorted.map(({ found, verb }) => recordFor(found, verb));
+  const affectedNotes = collectAffectedNotes(sorted.map(({ found }) => found));
+  for (const { found, verb } of [...sorted].reverse()) {
     if (verb === "accept")
       applyAccept(found);
     else
@@ -18100,6 +18120,9 @@ function applyTrackedChanges(document2, target, verb) {
   applyNotePairing(document2, affectedNotes);
   return records;
 }
+function indexOfFound(inventory, found) {
+  return inventory.findIndex((change) => change.node === found.node);
+}
 function resolveTargets(document2, target) {
   const allChanges = collectTrackedChanges(document2);
   if (target === "all")
@@ -18602,6 +18625,9 @@ class TrackChanges {
   reject(target) {
     return applyTrackedChanges(this.document, target, "reject");
   }
+  apply(accepts, rejects) {
+    return applyTrackedDecisions(this.document, accepts, rejects);
+  }
   applyInsertion(paragraph, authorFlag, allocator) {
     const mintMeta = this.metaMinter(authorFlag, allocator);
     paragraph.children = wrapContiguousTrackable(paragraph.children, (runs) => /* @__PURE__ */ jsxDEV(Ins, {
@@ -21585,6 +21611,481 @@ var init_body = __esm(() => {
   };
 });
 
+// src/core/ast/document/numbering.tsx
+function numFmtToFormat(numFmt) {
+  return NUMFMT_TO_FORMAT[numFmt] ?? numFmt;
+}
+
+class NumberingView {
+  tree;
+  constructor(tree = XmlNode2.parse(EMPTY_NUMBERING_XML)) {
+    this.tree = tree;
+  }
+  static async fromPackage(pkg) {
+    const tree = await pkg.readPart(NUMBERING_PART_NAME);
+    return tree ? new NumberingView(tree) : undefined;
+  }
+  static fromXml(xml) {
+    return xml ? new NumberingView(XmlNode2.parse(xml)) : undefined;
+  }
+  writeTo(pkg) {
+    pkg.writeText(NUMBERING_PART_NAME, XmlNode2.serialize(this.tree));
+  }
+  static register(deps) {
+    if (!deps.relationships.hasTarget("numbering.xml")) {
+      deps.relationships.add(NUMBERING_RELATIONSHIP_TYPE, "numbering.xml");
+    }
+    deps.contentTypes.registerPart(NUMBERING_PART_NAME, NUMBERING_CONTENT_TYPE);
+    return new NumberingView;
+  }
+  listNumIds() {
+    const root = XmlNode2.findRoot(this.tree, "w:numbering");
+    if (!root)
+      return [];
+    const out = [];
+    for (const child2 of root.findChildren("w:num")) {
+      const id = child2.getAttribute("w:numId");
+      if (id)
+        out.push(id);
+    }
+    return out;
+  }
+  listAbstractNumIds() {
+    const root = XmlNode2.findRoot(this.tree, "w:numbering");
+    if (!root)
+      return [];
+    const out = [];
+    for (const child2 of root.findChildren("w:abstractNum")) {
+      const id = child2.getAttribute("w:abstractNumId");
+      if (id)
+        out.push(id);
+    }
+    return out;
+  }
+  allocate(kind, start = 1) {
+    const root = this.ensureNumberingRoot();
+    const abstractNumId = this.ensureAbstractNum(root, kind);
+    const numId = nextNumId(root);
+    root.children.push(/* @__PURE__ */ jsxDEV(NumElement, {
+      numId,
+      abstractNumId,
+      start
+    }, undefined, false, undefined, this));
+    return numId;
+  }
+  getLevelInfo(numId, level) {
+    const num = this.findNum(numId);
+    const lvlOverride = num ? this.findLvlOverride(num, level) : undefined;
+    const override = lvlOverride?.findChild("w:lvl")?.findChild("w:numFmt")?.getAttribute("w:val");
+    const abstractNum = this.resolveAbstractNum(numId);
+    const abstractLvl = abstractNum ? findLevel(abstractNum, level) ?? findLevel(abstractNum, 0) : undefined;
+    const format = override ?? abstractLvl?.findChild("w:numFmt")?.getAttribute("w:val");
+    const startRaw = lvlOverride?.findChild("w:startOverride")?.getAttribute("w:val") ?? abstractLvl?.findChild("w:start")?.getAttribute("w:val");
+    const startNum = Number(startRaw);
+    const start = startRaw !== undefined && Number.isFinite(startNum) ? startNum : 1;
+    return { format, override, start };
+  }
+  getFormat(numId, level) {
+    return this.getLevelInfo(numId, level).format;
+  }
+  getBulletText(numId, level) {
+    const fromOverride = this.overrideLevel(numId, level)?.findChild("w:lvlText")?.getAttribute("w:val");
+    if (fromOverride !== undefined)
+      return fromOverride;
+    const abstractNum = this.resolveAbstractNum(numId);
+    if (!abstractNum)
+      return;
+    const lvl = findLevel(abstractNum, level) ?? findLevel(abstractNum, 0);
+    return lvl?.findChild("w:lvlText")?.getAttribute("w:val") ?? undefined;
+  }
+  getStart(numId, level) {
+    return this.getLevelInfo(numId, level).start;
+  }
+  setStart(numId, level, start) {
+    const num = this.findNum(numId);
+    if (!num)
+      return false;
+    const lvlOverride = this.ensureLvlOverride(num, level);
+    const existing = lvlOverride.findChild("w:startOverride");
+    if (existing)
+      existing.setAttribute("w:val", String(start));
+    else
+      insertLvlOverrideChildInOrder(lvlOverride, /* @__PURE__ */ jsxDEV(w.startOverride, {
+        "w-val": String(start)
+      }, undefined, false, undefined, this));
+    return true;
+  }
+  setFormat(numId, level, numFmt) {
+    const num = this.findNum(numId);
+    if (!num)
+      return false;
+    const lvl = this.buildOverrideLevel(numId, level, numFmt);
+    const lvlOverride = this.ensureLvlOverride(num, level);
+    const existing = lvlOverride.findChild("w:lvl");
+    if (existing) {
+      lvlOverride.children.splice(lvlOverride.children.indexOf(existing), 1, lvl);
+    } else {
+      insertLvlOverrideChildInOrder(lvlOverride, lvl);
+    }
+    return true;
+  }
+  cloneListDefinition(srcNumId, start) {
+    const root = this.ensureNumberingRoot();
+    const src = this.findNum(srcNumId);
+    const abstractNumId = src?.findChild("w:abstractNumId")?.getAttribute("w:val") ?? "0";
+    const numId = nextNumId(root);
+    const num = /* @__PURE__ */ jsxDEV(w.num, {
+      "w-numId": String(numId)
+    }, undefined, false, undefined, this);
+    num.children.push(/* @__PURE__ */ jsxDEV(w.abstractNumId, {
+      "w-val": abstractNumId
+    }, undefined, false, undefined, this));
+    if (src) {
+      for (const lvlOverride of src.findChildren("w:lvlOverride")) {
+        const lvl = lvlOverride.findChild("w:lvl");
+        if (!lvl)
+          continue;
+        const carried = /* @__PURE__ */ jsxDEV(w.lvlOverride, {
+          "w-ilvl": lvlOverride.getAttribute("w:ilvl") ?? "0"
+        }, undefined, false, undefined, this);
+        carried.children.push(lvl.clone());
+        num.children.push(carried);
+      }
+    }
+    root.children.push(num);
+    this.setStart(String(numId), 0, start);
+    return numId;
+  }
+  findNum(numId) {
+    const root = XmlNode2.findRoot(this.tree, "w:numbering");
+    return root?.findChildren("w:num").find((node) => node.getAttribute("w:numId") === numId);
+  }
+  findLvlOverride(num, level) {
+    const target = String(level);
+    return num.findChildren("w:lvlOverride").find((node) => node.getAttribute("w:ilvl") === target);
+  }
+  ensureLvlOverride(num, level) {
+    const existing = this.findLvlOverride(num, level);
+    if (existing)
+      return existing;
+    const created = /* @__PURE__ */ jsxDEV(w.lvlOverride, {
+      "w-ilvl": String(level)
+    }, undefined, false, undefined, this);
+    const abstractIdx = num.children.findIndex((child2) => child2.tag === "w:abstractNumId");
+    num.children.splice(abstractIdx + 1, 0, created);
+    return created;
+  }
+  overrideLevel(numId, level) {
+    const num = this.findNum(numId);
+    const lvlOverride = num ? this.findLvlOverride(num, level) : undefined;
+    return lvlOverride?.findChild("w:lvl");
+  }
+  buildOverrideLevel(numId, level, numFmt) {
+    const abstractNum = this.resolveAbstractNum(numId);
+    const base = abstractNum && (findLevel(abstractNum, level) ?? findLevel(abstractNum, 0));
+    const lvl = base ? base.clone() : /* @__PURE__ */ jsxDEV(OrderedLevel, {
+      ilvl: level,
+      text: `%${level + 1}.`,
+      fmt: numFmt
+    }, undefined, false, undefined, this);
+    lvl.setAttribute("w:ilvl", String(level));
+    lvl.findChild("w:numFmt")?.setAttribute("w:val", numFmt);
+    lvl.children = lvl.children.filter((child2) => child2.tag !== "w:start");
+    return lvl;
+  }
+  resolveAbstractNum(numId) {
+    const root = XmlNode2.findRoot(this.tree, "w:numbering");
+    if (!root)
+      return;
+    const num = root.findChildren("w:num").find((node) => node.getAttribute("w:numId") === numId);
+    if (!num)
+      return;
+    const abstractNumId = num.findChild("w:abstractNumId")?.getAttribute("w:val");
+    if (!abstractNumId)
+      return;
+    return root.findChildren("w:abstractNum").find((node) => node.getAttribute("w:abstractNumId") === abstractNumId);
+  }
+  ensureNumberingRoot() {
+    const root = XmlNode2.findRoot(this.tree, "w:numbering");
+    if (!root) {
+      throw new Error("expected <w:numbering> root in numbering tree");
+    }
+    return root;
+  }
+  ensureAbstractNum(root, kind) {
+    const targetFormat = kind === "bullet" ? "bullet" : "decimal";
+    for (const child2 of root.findChildren("w:abstractNum")) {
+      const lvl0 = findLevel(child2, 0);
+      const numFmt = lvl0?.findChild("w:numFmt");
+      if (numFmt?.getAttribute("w:val") === targetFormat) {
+        const id = child2.getAttribute("w:abstractNumId");
+        if (id)
+          return Number(id);
+      }
+    }
+    const newId = nextAbstractNumId(root);
+    const def = /* @__PURE__ */ jsxDEV(AbstractNum, {
+      kind,
+      id: newId
+    }, undefined, false, undefined, this);
+    const firstNumIdx = root.children.findIndex((child2) => child2.tag === "w:num");
+    if (firstNumIdx === -1)
+      root.children.push(def);
+    else
+      root.children.splice(firstNumIdx, 0, def);
+    return newId;
+  }
+}
+function nextAbstractNumId(root) {
+  let max = -1;
+  for (const child2 of root.findChildren("w:abstractNum")) {
+    const id = child2.getAttribute("w:abstractNumId");
+    if (id) {
+      const numeric = Number(id);
+      if (Number.isFinite(numeric) && numeric > max)
+        max = numeric;
+    }
+  }
+  return max + 1;
+}
+function nextNumId(root) {
+  let max = 0;
+  for (const child2 of root.findChildren("w:num")) {
+    const id = child2.getAttribute("w:numId");
+    if (id) {
+      const numeric = Number(id);
+      if (Number.isFinite(numeric) && numeric > max)
+        max = numeric;
+    }
+  }
+  return max + 1;
+}
+function insertLvlOverrideChildInOrder(lvlOverride, child2) {
+  const order = ["w:startOverride", "w:lvl"];
+  const rank = order.indexOf(child2.tag);
+  const at = lvlOverride.children.findIndex((existing) => !existing.isText && order.indexOf(existing.tag) > rank);
+  if (at < 0)
+    lvlOverride.children.push(child2);
+  else
+    lvlOverride.children.splice(at, 0, child2);
+}
+function findLevel(abstractNum, ilvl) {
+  const target = String(ilvl);
+  return abstractNum.findChildren("w:lvl").find((lvl) => lvl.getAttribute("w:ilvl") === target);
+}
+function NumElement({
+  numId,
+  abstractNumId,
+  start
+}) {
+  return /* @__PURE__ */ jsxDEV(w.num, {
+    "w-numId": String(numId),
+    children: [
+      /* @__PURE__ */ jsxDEV(w.abstractNumId, {
+        "w-val": String(abstractNumId)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV(w.lvlOverride, {
+        "w-ilvl": "0",
+        children: /* @__PURE__ */ jsxDEV(w.startOverride, {
+          "w-val": String(start)
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+function AbstractNum({
+  kind,
+  id
+}) {
+  return kind === "bullet" ? /* @__PURE__ */ jsxDEV(BulletAbstractNum, {
+    id
+  }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV(OrderedAbstractNum, {
+    id
+  }, undefined, false, undefined, this);
+}
+function BulletAbstractNum({ id }) {
+  return /* @__PURE__ */ jsxDEV(w.abstractNum, {
+    "w-abstractNumId": String(id),
+    children: [
+      /* @__PURE__ */ jsxDEV(w.multiLevelType, {
+        "w-val": "hybridMultilevel"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV(BulletLevel, {
+        ilvl: 0,
+        glyph: "\u2022"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV(BulletLevel, {
+        ilvl: 1,
+        glyph: "\u25E6"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV(BulletLevel, {
+        ilvl: 2,
+        glyph: "\u25AA"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV(BulletLevel, {
+        ilvl: 3,
+        glyph: "\u2022"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV(BulletLevel, {
+        ilvl: 4,
+        glyph: "\u25E6"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV(BulletLevel, {
+        ilvl: 5,
+        glyph: "\u25AA"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV(BulletLevel, {
+        ilvl: 6,
+        glyph: "\u2022"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV(BulletLevel, {
+        ilvl: 7,
+        glyph: "\u25E6"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV(BulletLevel, {
+        ilvl: 8,
+        glyph: "\u25AA"
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+function BulletLevel({
+  ilvl,
+  glyph
+}) {
+  return /* @__PURE__ */ jsxDEV(w.lvl, {
+    "w-ilvl": String(ilvl),
+    children: [
+      /* @__PURE__ */ jsxDEV(w.start, {
+        "w-val": "1"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV(w.numFmt, {
+        "w-val": "bullet"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV(w.lvlText, {
+        "w-val": glyph
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV(w.lvlJc, {
+        "w-val": "left"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV(w.pPr, {
+        children: /* @__PURE__ */ jsxDEV(w.ind, {
+          "w-left": String(levelIndent(ilvl)),
+          "w-hanging": HANGING
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+function OrderedAbstractNum({ id }) {
+  return /* @__PURE__ */ jsxDEV(w.abstractNum, {
+    "w-abstractNumId": String(id),
+    children: [
+      /* @__PURE__ */ jsxDEV(w.multiLevelType, {
+        "w-val": "hybridMultilevel"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV(OrderedLevel, {
+        ilvl: 0,
+        text: "%1.",
+        fmt: "decimal"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV(OrderedLevel, {
+        ilvl: 1,
+        text: "%2.",
+        fmt: "lowerLetter"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV(OrderedLevel, {
+        ilvl: 2,
+        text: "%3.",
+        fmt: "lowerRoman"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV(OrderedLevel, {
+        ilvl: 3,
+        text: "%4.",
+        fmt: "decimal"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV(OrderedLevel, {
+        ilvl: 4,
+        text: "%5.",
+        fmt: "lowerLetter"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV(OrderedLevel, {
+        ilvl: 5,
+        text: "%6.",
+        fmt: "lowerRoman"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV(OrderedLevel, {
+        ilvl: 6,
+        text: "%7.",
+        fmt: "decimal"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV(OrderedLevel, {
+        ilvl: 7,
+        text: "%8.",
+        fmt: "lowerLetter"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV(OrderedLevel, {
+        ilvl: 8,
+        text: "%9.",
+        fmt: "lowerRoman"
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+function OrderedLevel({
+  ilvl,
+  text: text2,
+  fmt
+}) {
+  return /* @__PURE__ */ jsxDEV(w.lvl, {
+    "w-ilvl": String(ilvl),
+    children: [
+      /* @__PURE__ */ jsxDEV(w.start, {
+        "w-val": "1"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV(w.numFmt, {
+        "w-val": fmt
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV(w.lvlText, {
+        "w-val": text2
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV(w.lvlJc, {
+        "w-val": "left"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV(w.pPr, {
+        children: /* @__PURE__ */ jsxDEV(w.ind, {
+          "w-left": String(levelIndent(ilvl)),
+          "w-hanging": HANGING
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+function levelIndent(ilvl) {
+  return (ilvl + 1) * 300;
+}
+var FORMAT_TO_NUMFMT, NUMFMT_TO_FORMAT, NUMBERING_PART_NAME = "word/numbering.xml", NUMBERING_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering", NUMBERING_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml", EMPTY_NUMBERING_XML = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<w:numbering xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"/>`, HANGING = "240";
+var init_numbering = __esm(() => {
+  init_jsx();
+  init_parser();
+  init_jsx_dev_runtime();
+  FORMAT_TO_NUMFMT = {
+    decimal: "decimal",
+    "lower-alpha": "lowerLetter",
+    "upper-alpha": "upperLetter",
+    "lower-roman": "lowerRoman",
+    "upper-roman": "upperRoman"
+  };
+  NUMFMT_TO_FORMAT = {
+    decimal: "decimal",
+    lowerLetter: "lower-alpha",
+    upperLetter: "upper-alpha",
+    lowerRoman: "lower-roman",
+    upperRoman: "upper-roman"
+  };
+});
+
 // src/core/ast/sym.ts
 function decodeSym(font, charHex) {
   const codepoint = Number.parseInt(charHex, 16);
@@ -22358,9 +22859,13 @@ function applyParagraphProperties(document2, paragraph, paragraphProperties) {
       level,
       numId: id
     };
-    const format = id ? document2.numbering?.getFormat(id, level) : undefined;
-    if (format !== undefined && format !== "bullet" && format !== "none") {
+    const info = id ? document2.numbering?.getLevelInfo(id, level) : undefined;
+    if (info?.format !== undefined && info.format !== "bullet" && info.format !== "none") {
       list.ordered = true;
+      if (info.override !== undefined)
+        list.format = numFmtToFormat(info.override);
+      if (info.start !== 1)
+        list.start = info.start;
     }
     paragraph.list = list;
   }
@@ -22670,6 +23175,7 @@ function readTable(document2, node, id, state) {
   const width = readTableWidth(node);
   const borders = readTableBorders(node);
   const style = readTableStyle(node);
+  const align = readTableAlign(node);
   readTablePropertyRevision(document2, node, id, state);
   readGridRevision(document2, node, id, state);
   const rows = [];
@@ -22689,6 +23195,11 @@ function readTable(document2, node, id, state) {
     const row = { cells };
     if (rowChange)
       row.trackedChange = rowChange;
+    const height = readRowHeight(child2);
+    if (height)
+      row.height = height;
+    if (readRepeatHeader(child2))
+      row.repeatHeader = true;
     rows.push(row);
     rowIndex++;
   }
@@ -22699,8 +23210,35 @@ function readTable(document2, node, id, state) {
     table.borders = borders;
   if (style)
     table.style = style;
+  if (align)
+    table.align = align;
   return table;
 }
+function readTableAlign(table) {
+  const val = table.findChild("w:tblPr")?.findChild("w:jc")?.getAttribute("w:val");
+  return val === "center" || val === "right" ? val : undefined;
+}
+function readRowHeight(row) {
+  const trHeight = row.findChild("w:trPr")?.findChild("w:trHeight");
+  if (!trHeight)
+    return;
+  const raw = trHeight.getAttribute("w:val");
+  const value = raw ? Number(raw) : NaN;
+  if (!Number.isFinite(value))
+    return;
+  const rule = trHeight.getAttribute("w:hRule");
+  return {
+    value,
+    rule: rule === "exact" || rule === "auto" ? rule : "atLeast"
+  };
+}
+function readRepeatHeader(row) {
+  const marker = row.findChild("w:trPr")?.findChild("w:tblHeader");
+  if (!marker)
+    return false;
+  const val = marker.getAttribute("w:val");
+  return val !== "false" && val !== "0" && val !== "off";
+}
 function readTableStyle(table) {
   return table.findChild("w:tblPr")?.findChild("w:tblStyle")?.getAttribute("w:val") ?? undefined;
 }
@@ -22832,8 +23370,39 @@ function readTableCell(document2, cellNode, rowChildren, tableId, rowIndex, colu
     if (fill && fill.toLowerCase() !== "auto")
       cell.shading = fill.toUpperCase();
   }
+  const vAlignNode = tcPr.findChild("w:vAlign");
+  if (vAlignNode) {
+    const raw = vAlignNode.getAttribute("w:val");
+    if (raw === "center" || raw === "bottom")
+      cell.vAlign = raw;
+  }
+  const cellBorders = readCellBorders(tcPr);
+  if (cellBorders)
+    cell.borders = cellBorders;
   return cell;
 }
+function readCellBorders(tcPr) {
+  const tcBorders = tcPr.findChild("w:tcBorders");
+  if (!tcBorders)
+    return;
+  const byStyle = new Map;
+  for (const edge of CELL_BORDER_EDGES) {
+    const val = tcBorders.findChild(`w:${edge}`)?.getAttribute("w:val");
+    if (!val || val === "nil" || val === "none")
+      continue;
+    const sides = byStyle.get(val) ?? [];
+    sides.push(edge);
+    byStyle.set(val, sides);
+  }
+  if (byStyle.size === 0)
+    return;
+  const parts = [];
+  for (const [style, sides] of byStyle) {
+    const label = sides.length === CELL_BORDER_EDGES.length ? "all" : sides.join(",");
+    parts.push(`${label}:${style}`);
+  }
+  return parts.join(" ");
+}
 function readCellPropertyRevision(document2, cell, tableId, state) {
   const tcPr = cell.findChild("w:tcPr");
   const change = tcPr?.findChild("w:tcPrChange");
@@ -22869,7 +23438,7 @@ function readCellBlocks(document2, cell, tableId, rowIndex, columnIndex, state)
   }
   return blocks;
 }
-var TRACKED_CHANGE_KIND_BY_TAG, WRAP_TAGS, TABLE_BORDER_EDGES;
+var TRACKED_CHANGE_KIND_BY_TAG, WRAP_TAGS, TABLE_BORDER_EDGES, CELL_BORDER_EDGES;
 var init_read2 = __esm(() => {
   init_blocks();
   init_equation();
@@ -22880,6 +23449,7 @@ var init_read2 = __esm(() => {
   init_sections();
   init_task_list();
   init_body();
+  init_numbering();
   init_sym();
   TRACKED_CHANGE_KIND_BY_TAG = {
     "w:ins": "ins",
@@ -22902,6 +23472,14 @@ var init_read2 = __esm(() => {
     "w:insideH",
     "w:insideV"
   ];
+  CELL_BORDER_EDGES = [
+    "top",
+    "left",
+    "bottom",
+    "right",
+    "insideH",
+    "insideV"
+  ];
 });
 
 // src/core/ast/document/comments.tsx
@@ -23709,348 +24287,6 @@ var init_notes2 = __esm(() => {
   init_relationships();
 });
 
-// src/core/ast/document/numbering.tsx
-class NumberingView {
-  tree;
-  constructor(tree = XmlNode2.parse(EMPTY_NUMBERING_XML)) {
-    this.tree = tree;
-  }
-  static async fromPackage(pkg) {
-    const tree = await pkg.readPart(NUMBERING_PART_NAME);
-    return tree ? new NumberingView(tree) : undefined;
-  }
-  static fromXml(xml) {
-    return xml ? new NumberingView(XmlNode2.parse(xml)) : undefined;
-  }
-  writeTo(pkg) {
-    pkg.writeText(NUMBERING_PART_NAME, XmlNode2.serialize(this.tree));
-  }
-  static register(deps) {
-    if (!deps.relationships.hasTarget("numbering.xml")) {
-      deps.relationships.add(NUMBERING_RELATIONSHIP_TYPE, "numbering.xml");
-    }
-    deps.contentTypes.registerPart(NUMBERING_PART_NAME, NUMBERING_CONTENT_TYPE);
-    return new NumberingView;
-  }
-  listNumIds() {
-    const root = XmlNode2.findRoot(this.tree, "w:numbering");
-    if (!root)
-      return [];
-    const out = [];
-    for (const child2 of root.findChildren("w:num")) {
-      const id = child2.getAttribute("w:numId");
-      if (id)
-        out.push(id);
-    }
-    return out;
-  }
-  listAbstractNumIds() {
-    const root = XmlNode2.findRoot(this.tree, "w:numbering");
-    if (!root)
-      return [];
-    const out = [];
-    for (const child2 of root.findChildren("w:abstractNum")) {
-      const id = child2.getAttribute("w:abstractNumId");
-      if (id)
-        out.push(id);
-    }
-    return out;
-  }
-  allocate(kind, start = 1) {
-    const root = this.ensureNumberingRoot();
-    const abstractNumId = this.ensureAbstractNum(root, kind);
-    const numId = nextNumId(root);
-    root.children.push(/* @__PURE__ */ jsxDEV(NumElement, {
-      numId,
-      abstractNumId,
-      start
-    }, undefined, false, undefined, this));
-    return numId;
-  }
-  getFormat(numId, level) {
-    const abstractNum = this.resolveAbstractNum(numId);
-    if (!abstractNum)
-      return;
-    const lvl = findLevel(abstractNum, level) ?? findLevel(abstractNum, 0);
-    return lvl?.findChild("w:numFmt")?.getAttribute("w:val") ?? undefined;
-  }
-  getBulletText(numId, level) {
-    const abstractNum = this.resolveAbstractNum(numId);
-    if (!abstractNum)
-      return;
-    const lvl = findLevel(abstractNum, level) ?? findLevel(abstractNum, 0);
-    return lvl?.findChild("w:lvlText")?.getAttribute("w:val") ?? undefined;
-  }
-  resolveAbstractNum(numId) {
-    const root = XmlNode2.findRoot(this.tree, "w:numbering");
-    if (!root)
-      return;
-    const num = root.findChildren("w:num").find((node) => node.getAttribute("w:numId") === numId);
-    if (!num)
-      return;
-    const abstractNumId = num.findChild("w:abstractNumId")?.getAttribute("w:val");
-    if (!abstractNumId)
-      return;
-    return root.findChildren("w:abstractNum").find((node) => node.getAttribute("w:abstractNumId") === abstractNumId);
-  }
-  ensureNumberingRoot() {
-    const root = XmlNode2.findRoot(this.tree, "w:numbering");
-    if (!root) {
-      throw new Error("expected <w:numbering> root in numbering tree");
-    }
-    return root;
-  }
-  ensureAbstractNum(root, kind) {
-    const targetFormat = kind === "bullet" ? "bullet" : "decimal";
-    for (const child2 of root.findChildren("w:abstractNum")) {
-      const lvl0 = findLevel(child2, 0);
-      const numFmt = lvl0?.findChild("w:numFmt");
-      if (numFmt?.getAttribute("w:val") === targetFormat) {
-        const id = child2.getAttribute("w:abstractNumId");
-        if (id)
-          return Number(id);
-      }
-    }
-    const newId = nextAbstractNumId(root);
-    const def = /* @__PURE__ */ jsxDEV(AbstractNum, {
-      kind,
-      id: newId
-    }, undefined, false, undefined, this);
-    const firstNumIdx = root.children.findIndex((child2) => child2.tag === "w:num");
-    if (firstNumIdx === -1)
-      root.children.push(def);
-    else
-      root.children.splice(firstNumIdx, 0, def);
-    return newId;
-  }
-}
-function nextAbstractNumId(root) {
-  let max = -1;
-  for (const child2 of root.findChildren("w:abstractNum")) {
-    const id = child2.getAttribute("w:abstractNumId");
-    if (id) {
-      const numeric = Number(id);
-      if (Number.isFinite(numeric) && numeric > max)
-        max = numeric;
-    }
-  }
-  return max + 1;
-}
-function nextNumId(root) {
-  let max = 0;
-  for (const child2 of root.findChildren("w:num")) {
-    const id = child2.getAttribute("w:numId");
-    if (id) {
-      const numeric = Number(id);
-      if (Number.isFinite(numeric) && numeric > max)
-        max = numeric;
-    }
-  }
-  return max + 1;
-}
-function findLevel(abstractNum, ilvl) {
-  const target = String(ilvl);
-  return abstractNum.findChildren("w:lvl").find((lvl) => lvl.getAttribute("w:ilvl") === target);
-}
-function NumElement({
-  numId,
-  abstractNumId,
-  start
-}) {
-  return /* @__PURE__ */ jsxDEV(w.num, {
-    "w-numId": String(numId),
-    children: [
-      /* @__PURE__ */ jsxDEV(w.abstractNumId, {
-        "w-val": String(abstractNumId)
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV(w.lvlOverride, {
-        "w-ilvl": "0",
-        children: /* @__PURE__ */ jsxDEV(w.startOverride, {
-          "w-val": String(start)
-        }, undefined, false, undefined, this)
-      }, undefined, false, undefined, this)
-    ]
-  }, undefined, true, undefined, this);
-}
-function AbstractNum({
-  kind,
-  id
-}) {
-  return kind === "bullet" ? /* @__PURE__ */ jsxDEV(BulletAbstractNum, {
-    id
-  }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV(OrderedAbstractNum, {
-    id
-  }, undefined, false, undefined, this);
-}
-function BulletAbstractNum({ id }) {
-  return /* @__PURE__ */ jsxDEV(w.abstractNum, {
-    "w-abstractNumId": String(id),
-    children: [
-      /* @__PURE__ */ jsxDEV(w.multiLevelType, {
-        "w-val": "hybridMultilevel"
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV(BulletLevel, {
-        ilvl: 0,
-        glyph: "\u2022"
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV(BulletLevel, {
-        ilvl: 1,
-        glyph: "\u25E6"
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV(BulletLevel, {
-        ilvl: 2,
-        glyph: "\u25AA"
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV(BulletLevel, {
-        ilvl: 3,
-        glyph: "\u2022"
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV(BulletLevel, {
-        ilvl: 4,
-        glyph: "\u25E6"
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV(BulletLevel, {
-        ilvl: 5,
-        glyph: "\u25AA"
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV(BulletLevel, {
-        ilvl: 6,
-        glyph: "\u2022"
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV(BulletLevel, {
-        ilvl: 7,
-        glyph: "\u25E6"
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV(BulletLevel, {
-        ilvl: 8,
-        glyph: "\u25AA"
-      }, undefined, false, undefined, this)
-    ]
-  }, undefined, true, undefined, this);
-}
-function BulletLevel({
-  ilvl,
-  glyph
-}) {
-  return /* @__PURE__ */ jsxDEV(w.lvl, {
-    "w-ilvl": String(ilvl),
-    children: [
-      /* @__PURE__ */ jsxDEV(w.start, {
-        "w-val": "1"
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV(w.numFmt, {
-        "w-val": "bullet"
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV(w.lvlText, {
-        "w-val": glyph
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV(w.lvlJc, {
-        "w-val": "left"
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV(w.pPr, {
-        children: /* @__PURE__ */ jsxDEV(w.ind, {
-          "w-left": String(levelIndent(ilvl)),
-          "w-hanging": HANGING
-        }, undefined, false, undefined, this)
-      }, undefined, false, undefined, this)
-    ]
-  }, undefined, true, undefined, this);
-}
-function OrderedAbstractNum({ id }) {
-  return /* @__PURE__ */ jsxDEV(w.abstractNum, {
-    "w-abstractNumId": String(id),
-    children: [
-      /* @__PURE__ */ jsxDEV(w.multiLevelType, {
-        "w-val": "hybridMultilevel"
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV(OrderedLevel, {
-        ilvl: 0,
-        text: "%1.",
-        fmt: "decimal"
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV(OrderedLevel, {
-        ilvl: 1,
-        text: "%2.",
-        fmt: "lowerLetter"
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV(OrderedLevel, {
-        ilvl: 2,
-        text: "%3.",
-        fmt: "lowerRoman"
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV(OrderedLevel, {
-        ilvl: 3,
-        text: "%4.",
-        fmt: "decimal"
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV(OrderedLevel, {
-        ilvl: 4,
-        text: "%5.",
-        fmt: "lowerLetter"
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV(OrderedLevel, {
-        ilvl: 5,
-        text: "%6.",
-        fmt: "lowerRoman"
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV(OrderedLevel, {
-        ilvl: 6,
-        text: "%7.",
-        fmt: "decimal"
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV(OrderedLevel, {
-        ilvl: 7,
-        text: "%8.",
-        fmt: "lowerLetter"
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV(OrderedLevel, {
-        ilvl: 8,
-        text: "%9.",
-        fmt: "lowerRoman"
-      }, undefined, false, undefined, this)
-    ]
-  }, undefined, true, undefined, this);
-}
-function OrderedLevel({
-  ilvl,
-  text: text2,
-  fmt
-}) {
-  return /* @__PURE__ */ jsxDEV(w.lvl, {
-    "w-ilvl": String(ilvl),
-    children: [
-      /* @__PURE__ */ jsxDEV(w.start, {
-        "w-val": "1"
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV(w.numFmt, {
-        "w-val": fmt
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV(w.lvlText, {
-        "w-val": text2
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV(w.lvlJc, {
-        "w-val": "left"
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV(w.pPr, {
-        children: /* @__PURE__ */ jsxDEV(w.ind, {
-          "w-left": String(levelIndent(ilvl)),
-          "w-hanging": HANGING
-        }, undefined, false, undefined, this)
-      }, undefined, false, undefined, this)
-    ]
-  }, undefined, true, undefined, this);
-}
-function levelIndent(ilvl) {
-  return (ilvl + 1) * 300;
-}
-var NUMBERING_PART_NAME = "word/numbering.xml", NUMBERING_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering", NUMBERING_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml", EMPTY_NUMBERING_XML = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<w:numbering xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"/>`, HANGING = "240";
-var init_numbering = __esm(() => {
-  init_jsx();
-  init_parser();
-  init_jsx_dev_runtime();
-});
-
 // node_modules/process-nextick-args/index.js
 var require_process_nextick_args = __commonJS((exports, module) => {
   if (typeof process === "undefined" || !process.version || process.version.indexOf("v0.") === 0 || process.version.indexOf("v1.") === 0 && process.version.indexOf("v1.8.") !== 0) {
@@ -33807,6 +34043,13 @@ function NormalStyle() {
     ]
   }, undefined, true, undefined, this);
 }
+function HeadingThemeFonts() {
+  return /* @__PURE__ */ jsxDEV(w.rFonts, {
+    "w-asciiTheme": "majorHAnsi",
+    "w-hAnsiTheme": "majorHAnsi",
+    "w-cstheme": "majorBidi"
+  }, undefined, false, undefined, this);
+}
 function TitleStyle() {
   return /* @__PURE__ */ jsxDEV(w.style, {
     "w-type": "paragraph",
@@ -33829,10 +34072,7 @@ function TitleStyle() {
       }, undefined, false, undefined, this),
       /* @__PURE__ */ jsxDEV(w.rPr, {
         children: [
-          /* @__PURE__ */ jsxDEV(w.rFonts, {
-            "w-ascii": "Calibri Light",
-            "w-hAnsi": "Calibri Light"
-          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV(HeadingThemeFonts, {}, undefined, false, undefined, this),
           /* @__PURE__ */ jsxDEV(w.color, {
             "w-val": "1F3864"
           }, undefined, false, undefined, this),
@@ -33866,10 +34106,7 @@ function SubtitleStyle() {
       }, undefined, false, undefined, this),
       /* @__PURE__ */ jsxDEV(w.rPr, {
         children: [
-          /* @__PURE__ */ jsxDEV(w.rFonts, {
-            "w-ascii": "Calibri Light",
-            "w-hAnsi": "Calibri Light"
-          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV(HeadingThemeFonts, {}, undefined, false, undefined, this),
           /* @__PURE__ */ jsxDEV(w.color, {
             "w-val": "5A5A5A"
           }, undefined, false, undefined, this),
@@ -33919,10 +34156,7 @@ function HeadingStyle({
       }, undefined, true, undefined, this),
       /* @__PURE__ */ jsxDEV(w.rPr, {
         children: [
-          /* @__PURE__ */ jsxDEV(w.rFonts, {
-            "w-ascii": "Calibri Light",
-            "w-hAnsi": "Calibri Light"
-          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV(HeadingThemeFonts, {}, undefined, false, undefined, this),
           bold2 && /* @__PURE__ */ jsxDEV(w.b, {}, undefined, false, undefined, this),
           italic && /* @__PURE__ */ jsxDEV(w.i, {}, undefined, false, undefined, this),
           color && /* @__PURE__ */ jsxDEV(w.color, {
@@ -72465,6 +72699,69 @@ function setCellWidth(cell, width) {
   }, undefined, false, undefined, this) : null);
   pruneEmptyTcPr(cell, tcPr);
 }
+function setCellShading(cell, hex) {
+  const tcPr = ensureTcPr(cell);
+  setTcPrChild(tcPr, "w:shd", hex ? /* @__PURE__ */ jsxDEV(w.shd, {
+    "w-val": "clear",
+    "w-color": "auto",
+    "w-fill": hex
+  }, undefined, false, undefined, this) : null);
+  pruneEmptyTcPr(cell, tcPr);
+}
+function setCellVAlign(cell, value) {
+  const tcPr = ensureTcPr(cell);
+  setTcPrChild(tcPr, "w:vAlign", value && value !== "top" ? /* @__PURE__ */ jsxDEV(w.vAlign, {
+    "w-val": value
+  }, undefined, false, undefined, this) : null);
+  pruneEmptyTcPr(cell, tcPr);
+}
+function setCellBorders(cell, updates, clearAll = false) {
+  const tcPr = ensureTcPr(cell);
+  if (clearAll) {
+    setTcPrChild(tcPr, "w:tcBorders", null);
+    pruneEmptyTcPr(cell, tcPr);
+    return;
+  }
+  let tcBorders = tcPr.findChild("w:tcBorders");
+  if (!tcBorders) {
+    if (updates.every((update) => update.edge === null)) {
+      pruneEmptyTcPr(cell, tcPr);
+      return;
+    }
+    tcBorders = /* @__PURE__ */ jsxDEV(w.tcBorders, {}, undefined, false, undefined, this);
+    setTcPrChild(tcPr, "w:tcBorders", tcBorders);
+  }
+  for (const { side, edge } of updates) {
+    const tag = `w:${side}`;
+    tcBorders.children = tcBorders.children.filter((child2) => child2.tag !== tag);
+    if (edge)
+      insertEdgeInOrder(tcBorders, tag, borderEdge(tag, edge));
+  }
+  if (tcBorders.children.length === 0)
+    setTcPrChild(tcPr, "w:tcBorders", null);
+  pruneEmptyTcPr(cell, tcPr);
+}
+function borderEdge(tag, edge) {
+  const attributes = edge.style === "none" ? { "w:val": "none" } : {
+    "w:val": edge.style,
+    "w:sz": String(edge.sizeEighths),
+    "w:space": "0",
+    "w:color": edge.color
+  };
+  return XmlNode2.element(tag, attributes);
+}
+function insertEdgeInOrder(parent, tag, node2) {
+  const target = orderIndex(CELL_BORDER_ORDER, tag);
+  let insertAt = parent.children.length;
+  for (let index2 = 0;index2 < parent.children.length; index2++) {
+    const child2 = parent.children[index2];
+    if (child2 && orderIndex(CELL_BORDER_ORDER, child2.tag) > target) {
+      insertAt = index2;
+      break;
+    }
+  }
+  parent.children.splice(insertAt, 0, node2);
+}
 function markRowTracked(row, kind, meta) {
   const trPr = ensureTrPr(row);
   trPr.children = trPr.children.filter((child2) => child2.tag !== "w:ins" && child2.tag !== "w:del");
@@ -72495,6 +72792,24 @@ function ensureTrPr(row) {
   row.children.unshift(trPr);
   return trPr;
 }
+function setRowHeight(row, height) {
+  const trPr = ensureTrPr(row);
+  setTrPrChild(trPr, "w:trHeight", height ? /* @__PURE__ */ jsxDEV(w.trHeight, {
+    "w-val": String(height.value),
+    "w-hRule": height.rule
+  }, undefined, false, undefined, this) : null);
+  pruneEmptyTrPr(row, trPr);
+}
+function setRepeatHeader(row, on) {
+  const trPr = ensureTrPr(row);
+  setTrPrChild(trPr, "w:tblHeader", on ? /* @__PURE__ */ jsxDEV(w.tblHeader, {}, undefined, false, undefined, this) : null);
+  pruneEmptyTrPr(row, trPr);
+}
+function pruneEmptyTrPr(row, trPr) {
+  if (trPr.children.length === 0) {
+    row.children = row.children.filter((child2) => child2 !== trPr);
+  }
+}
 function appendTblGridChange(tblGrid, priorCols, meta) {
   tblGrid.children = tblGrid.children.filter((child2) => child2.tag !== "w:tblGridChange");
   tblGrid.children.push(/* @__PURE__ */ jsxDEV(w.tblGridChange, {
@@ -72546,6 +72861,16 @@ function setTableLayout(table, layout) {
 function setTablePropertiesChild(table, tag, node2) {
   setTblPrChild(ensureTblPr(table), tag, node2);
 }
+function setTableJustification(table, value) {
+  setTablePropertiesChild(table, "w:jc", value && value !== "left" ? /* @__PURE__ */ jsxDEV(w.jc, {
+    "w-val": value
+  }, undefined, false, undefined, this) : null);
+}
+function setTableStyle(table, styleId) {
+  setTablePropertiesChild(table, "w:tblStyle", styleId ? /* @__PURE__ */ jsxDEV(w.tblStyle, {
+    "w-val": styleId
+  }, undefined, false, undefined, this) : null);
+}
 function setTblPrChild(tblPr, tag, node2) {
   tblPr.children = tblPr.children.filter((child2) => child2.tag !== tag);
   if (!node2)
@@ -72580,13 +72905,37 @@ function setTcPrChild(tcPr, tag, node2) {
   }
   tcPr.children.splice(insertAt, 0, node2);
 }
-var TBL_PR_ORDER, TC_PR_ORDER;
+function setTrPrChild(trPr, tag, node2) {
+  trPr.children = trPr.children.filter((child2) => child2.tag !== tag);
+  if (!node2)
+    return;
+  const target = orderIndex(TR_PR_ORDER, tag);
+  let insertAt = trPr.children.length;
+  for (let index2 = 0;index2 < trPr.children.length; index2++) {
+    const child2 = trPr.children[index2];
+    if (child2 && orderIndex(TR_PR_ORDER, child2.tag) > target) {
+      insertAt = index2;
+      break;
+    }
+  }
+  trPr.children.splice(insertAt, 0, node2);
+}
+var CELL_BORDER_ORDER, TBL_PR_ORDER, TC_PR_ORDER, TR_PR_ORDER;
 var init_mutate = __esm(() => {
   init_blocks();
   init_jsx();
+  init_parser();
   init_emit2();
   init_table();
   init_jsx_dev_runtime();
+  CELL_BORDER_ORDER = [
+    "w:top",
+    "w:left",
+    "w:bottom",
+    "w:right",
+    "w:insideH",
+    "w:insideV"
+  ];
   TBL_PR_ORDER = [
     "w:tblStyle",
     "w:tblpPr",
@@ -72624,6 +72973,23 @@ var init_mutate = __esm(() => {
     "w:cellMerge",
     "w:tcPrChange"
   ];
+  TR_PR_ORDER = [
+    "w:cnfStyle",
+    "w:divId",
+    "w:gridBefore",
+    "w:gridAfter",
+    "w:wBefore",
+    "w:wAfter",
+    "w:cantSplit",
+    "w:trHeight",
+    "w:tblHeader",
+    "w:tblCellSpacing",
+    "w:jc",
+    "w:hidden",
+    "w:ins",
+    "w:del",
+    "w:trPrChange"
+  ];
 });
 
 // src/core/table/index.tsx
@@ -73721,6 +74087,99 @@ var init_insert = __esm(() => {
   };
 });
 
+// src/core/lists/index.ts
+class Lists {
+  document;
+  constructor(document4) {
+    this.document = document4;
+  }
+  setStart(blockRef, start) {
+    const list3 = this.requireList(blockRef.node);
+    this.numbering().setStart(list3.numId, list3.level, start);
+  }
+  setFormat(blockRef, format) {
+    const list3 = this.requireList(blockRef.node);
+    this.numbering().setFormat(list3.numId, list3.level, FORMAT_TO_NUMFMT[format]);
+  }
+  restart(blockRef, start) {
+    const list3 = this.requireList(blockRef.node);
+    const newNumId = String(this.numbering().cloneListDefinition(list3.numId, start));
+    const startIdx = blockRef.parent.indexOf(blockRef.node);
+    this.repointFrom(blockRef.parent, startIdx, list3.numId, newNumId);
+  }
+  continue(blockRef) {
+    const list3 = this.requireList(blockRef.node);
+    const siblings = blockRef.parent;
+    const startIdx = siblings.indexOf(blockRef.node);
+    let precedingNumId;
+    for (let i = startIdx - 1;i >= 0; i--) {
+      const sibling = siblings[i];
+      if (!sibling)
+        continue;
+      const numbered = readNumPr(sibling);
+      if (!numbered)
+        continue;
+      if (numbered.numId !== list3.numId && this.isOrdered(numbered)) {
+        precedingNumId = numbered.numId;
+        break;
+      }
+    }
+    if (!precedingNumId) {
+      throw new ListOperationError("no preceding list to continue from");
+    }
+    this.repointFrom(siblings, startIdx, list3.numId, precedingNumId);
+  }
+  repointFrom(siblings, startIdx, oldNumId, newNumId) {
+    for (let i = startIdx;i < siblings.length; i++) {
+      const sibling = siblings[i];
+      if (!sibling)
+        continue;
+      if (readNumPr(sibling)?.numId === oldNumId)
+        setNumId(sibling, newNumId);
+    }
+  }
+  isOrdered(numbered) {
+    const format = this.numbering().getFormat(numbered.numId, numbered.level);
+    return format !== undefined && format !== "bullet" && format !== "none";
+  }
+  requireList(paragraph2) {
+    const numbered = readNumPr(paragraph2);
+    if (!numbered) {
+      throw new ListOperationError("paragraph is not a list item");
+    }
+    return numbered;
+  }
+  numbering() {
+    if (!this.document.numbering) {
+      throw new ListOperationError("document has no numbering definitions");
+    }
+    return this.document.numbering;
+  }
+}
+function readNumPr(paragraph2) {
+  const numPr = paragraph2.findChild("w:pPr")?.findChild("w:numPr");
+  if (!numPr)
+    return;
+  const numId = numPr.findChild("w:numId")?.getAttribute("w:val");
+  if (numId === undefined)
+    return;
+  const level = Number(numPr.findChild("w:ilvl")?.getAttribute("w:val") ?? "0");
+  return { numId, level };
+}
+function setNumId(paragraph2, numId) {
+  paragraph2.findChild("w:pPr")?.findChild("w:numPr")?.findChild("w:numId")?.setAttribute("w:val", numId);
+}
+var ListOperationError;
+var init_lists = __esm(() => {
+  init_numbering();
+  ListOperationError = class ListOperationError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "ListOperationError";
+    }
+  };
+});
+
 // src/core/marginals/index.tsx
 class Marginals {
   document;
@@ -82062,11 +82521,13 @@ var init_render = __esm(() => {
 // src/core/index.ts
 var init_core2 = __esm(() => {
   init_ast();
+  init_numbering();
   init_package();
   init_comments2();
   init_edit();
   init_fonts();
   init_insert();
+  init_lists();
   init_literal_text();
   init_locators();
   init_marginals2();
@@ -89549,7 +90010,19 @@ export type Paragraph = {
 	type: "paragraph";
 	style?: string;
 	alignment?: "left" | "center" | "right" | "justify";
-	list?: { level: number; numId: string; ordered?: boolean };
+	/** List membership from \`<w:pPr><w:numPr>\`. \`start\`/\`format\` are the
+	 * numbering-control properties \`docx lists set\` authors: \`start\` is the
+	 * effective level-start (omitted when 1), \`format\` the friendly
+	 * \`--format\` glyph vocabulary (decimal/lower-alpha/upper-roman/\u2026, omitted
+	 * when the default \`decimal\`). Two paragraphs sharing a \`numId\` are the same
+	 * (or continued) list, so a \`--continue\` link needs no field of its own. */
+	list?: {
+		level: number;
+		numId: string;
+		ordered?: boolean;
+		start?: number;
+		format?: string;
+	};
 	/** GFM task-list marker. Set when the paragraph's first content is a Word
 	 * checkbox content control (\`<w:sdt><w14:checkbox/></w:sdt>\`); the SDT itself
 	 * plus the leading whitespace run after it are stripped from \`runs\` so the
@@ -89622,6 +90095,10 @@ export type Table = {
 	 * \`borders\` summary. Surfaced so \`styles --used\` can report the table styles
 	 * a document actually applies. Present only when the table references one. */
 	style?: string;
+	/** Justification of the whole table on the page, from \`<w:tblPr><w:jc w:val="\u2026"/>\`
+	 * (\`"center"\` / \`"right"\`). Absent \u21D2 the default \`"left"\`. Authorable via
+	 * \`docx tables format --at tN --align\`. */
+	align?: "left" | "center" | "right";
 	rows: TableRow[];
 };
 
@@ -89630,6 +90107,15 @@ export type TableRow = {
 	/** Tracked row insertion/deletion from <w:trPr><w:ins/> or <w:del/>
 	 * (kind "rowIns" / "rowDel"). Present only under track-changes. */
 	trackedChange?: TrackedChange;
+	/** Row height from \`<w:trPr><w:trHeight w:val="\u2026" w:hRule="\u2026"/>\`. \`value\` is
+	 * in twips; \`rule\` is \`atLeast\` (minimum, the default), \`exact\` (fixed), or
+	 * \`auto\` (fit content). Present only when the row declares an explicit height.
+	 * Authorable via \`docx tables format --at tN:rR --row-height\`. */
+	height?: { value: number; rule: "atLeast" | "exact" | "auto" };
+	/** Whether the row repeats as a header at the top of each page that the table
+	 * spans, from \`<w:trPr><w:tblHeader/>\`. Present (true) only when the marker is
+	 * set. Authorable via \`docx tables format --at tN:rR --repeat-header\`. */
+	repeatHeader?: boolean;
 };
 
 export type TableCell = {
@@ -89654,6 +90140,17 @@ export type TableCell = {
 	 * hint \u2014 GFM can't show cell shading; the fill survives edits via in-place
 	 * mutation. */
 	shading?: string;
+	/** Vertical alignment of the cell's content from \`<w:tcPr><w:vAlign w:val="\u2026"/>\`
+	 * (\`"center"\` / \`"bottom"\`). Absent \u21D2 the default \`"top"\`. Authorable via
+	 * \`docx tables format --at \u2026 --valign\`. (Horizontal alignment is NOT a cell
+	 * property \u2014 it lives on each paragraph's \`<w:jc>\`, surfaced as \`docx:p align\`.) */
+	vAlign?: "top" | "center" | "bottom";
+	/** Summary of \`<w:tcPr><w:tcBorders>\` \u2014 the set edges and their dominant style,
+	 * as a compact \`side:style\` string (e.g. \`"bottom:double"\`, \`"all:single"\`).
+	 * A read-time hint mirroring \`Table.borders\`; full per-edge fidelity stays in
+	 * the XML via in-place mutation. Authorable via \`docx tables format --at \u2026
+	 * --cell-borders\`. Present only when the cell declares explicit borders. */
+	borders?: string;
 };
 
 export type TableWidth = {
@@ -90022,7 +90519,10 @@ var init_schema = __esm(() => {
             required: ["level", "numId"],
             properties: {
               level: { type: "number" },
-              numId: { type: "string" }
+              numId: { type: "string" },
+              ordered: { type: "boolean" },
+              start: { type: "number" },
+              format: { type: "string" }
             }
           },
           taskState: { enum: ["checked", "unchecked"] },
@@ -90216,6 +90716,7 @@ var init_schema = __esm(() => {
           width: { $ref: "#/$defs/TableWidth" },
           borders: { type: "string" },
           style: { type: "string" },
+          align: { enum: ["left", "center", "right"] },
           rows: {
             type: "array",
             items: {
@@ -90234,6 +90735,8 @@ var init_schema = __esm(() => {
                       vMerge: { enum: ["restart", "continue"] },
                       width: { $ref: "#/$defs/TableWidth" },
                       shading: { type: "string" },
+                      vAlign: { enum: ["top", "center", "bottom"] },
+                      borders: { type: "string" },
                       trackedChange: {
                         $ref: "#/$defs/TableRevision",
                         description: "cellIns / cellDel (tracked column change)"
@@ -90244,7 +90747,15 @@ var init_schema = __esm(() => {
                 trackedChange: {
                   $ref: "#/$defs/TableRevision",
                   description: "rowIns / rowDel (tracked row change)"
-                }
+                },
+                height: {
+                  type: "object",
+                  properties: {
+                    value: { type: "number" },
+                    rule: { enum: ["atLeast", "exact", "auto"] }
+                  }
+                },
+                repeatHeader: { type: "boolean" }
               }
             }
           }
@@ -90556,6 +91067,216 @@ var init_info = __esm(() => {
   };
 });
 
+// src/cli/lists/set.ts
+var exports_set = {};
+__export(exports_set, {
+  run: () => run34
+});
+async function run34(args) {
+  const parsed = await tryParseArgs(args, {
+    at: { type: "string" },
+    start: { type: "string" },
+    format: { type: "string" },
+    restart: { type: "boolean" },
+    continue: { type: "boolean" },
+    ...SAVE_FLAGS
+  }, HELP30);
+  if (typeof parsed === "number")
+    return parsed;
+  if (parsed.values.help) {
+    await writeStdout(HELP30);
+    return EXIT2.OK;
+  }
+  setVerboseAck(Boolean(parsed.values.verbose));
+  const path2 = parsed.positionals[0];
+  if (!path2)
+    return fail("USAGE", "Missing FILE argument", HELP30);
+  const at = parsed.values.at;
+  if (!at) {
+    return fail("USAGE", "Missing --at LOCATOR (a list item, e.g. p5)", HELP30);
+  }
+  const plan = buildPlan(parsed.values);
+  if (typeof plan === "string")
+    return fail("USAGE", plan);
+  const document4 = await openOrFail(path2);
+  if (typeof document4 === "number")
+    return document4;
+  const blockRef = await resolveBlockOrFail(document4, at);
+  if (typeof blockRef === "number")
+    return blockRef;
+  const orderedError = validateOrderedList(document4, at);
+  if (orderedError)
+    return fail("USAGE", orderedError);
+  const outputPath = parsed.values.output;
+  if (parsed.values["dry-run"]) {
+    await respond({
+      operation: "lists.set",
+      dryRun: true,
+      path: path2,
+      at,
+      applied: appliedList(plan),
+      ...outputPath ? { output: outputPath } : {}
+    });
+    return EXIT2.OK;
+  }
+  const lists = new Lists(document4);
+  try {
+    if (plan.continue) {
+      lists.continue(blockRef);
+    } else if (plan.restart) {
+      lists.restart(blockRef, plan.start ?? 1);
+      if (plan.format)
+        lists.setFormat(blockRef, plan.format);
+    } else {
+      if (plan.start !== undefined)
+        lists.setStart(blockRef, plan.start);
+      if (plan.format)
+        lists.setFormat(blockRef, plan.format);
+    }
+  } catch (error) {
+    if (error instanceof ListOperationError) {
+      return fail("BLOCK_NOT_FOUND", error.message);
+    }
+    throw error;
+  }
+  await document4.save(outputPath);
+  const destination = outputPath ?? path2;
+  await respondAck({
+    ok: true,
+    operation: "lists.set",
+    path: destination,
+    locator: at,
+    applied: appliedList(plan)
+  });
+  return EXIT2.OK;
+}
+function buildPlan(values2) {
+  const restart = Boolean(values2.restart);
+  const continueFlag = Boolean(values2.continue);
+  if (restart && continueFlag) {
+    return "Pass only one of --restart / --continue";
+  }
+  let start;
+  if (values2.start !== undefined) {
+    const parsedStart = Number(values2.start);
+    if (!Number.isInteger(parsedStart) || parsedStart < 1) {
+      return `--start must be a positive integer (got ${values2.start})`;
+    }
+    start = parsedStart;
+  }
+  let format;
+  if (values2.format !== undefined) {
+    const candidate = String(values2.format);
+    if (!Object.hasOwn(FORMAT_TO_NUMFMT, candidate)) {
+      return `--format must be one of ${Object.keys(FORMAT_TO_NUMFMT).join(", ")} (got ${candidate})`;
+    }
+    format = candidate;
+  }
+  if (continueFlag && (start !== undefined || format !== undefined)) {
+    return "--continue adopts the previous list's numbering \u2014 it can't combine with --start/--format";
+  }
+  if (!restart && !continueFlag && start === undefined && format === undefined) {
+    return "Nothing to do \u2014 pass --start, --format, --restart, or --continue";
+  }
+  return { start, format, restart, continue: continueFlag };
+}
+function validateOrderedList(document4, at) {
+  const block = document4.body.findBlockById(at);
+  if (!block || block.type !== "paragraph" || !block.list) {
+    return `${at} is not a list item \u2014 list numbering controls only apply to numbered lists`;
+  }
+  if (!block.list.ordered) {
+    return `${at} is a bulleted list \u2014 numbering controls (start/format/restart/continue) apply to numbered (ordered) lists`;
+  }
+  return null;
+}
+function appliedList(plan) {
+  const applied = [];
+  if (plan.continue)
+    applied.push("continue");
+  if (plan.restart)
+    applied.push("restart");
+  if (plan.start !== undefined)
+    applied.push(`start=${plan.start}`);
+  if (plan.format)
+    applied.push(`format=${plan.format}`);
+  return applied;
+}
+var HELP30 = `docx lists set \u2014 renumber a numbered list (start value, glyph format, restart/continue)
+
+Usage:
+  docx lists set FILE --at pN [options]
+
+--at names any item of a NUMBERED (ordered) list. --start/--format change the whole
+list (every paragraph sharing its numbering); --restart/--continue act from the
+addressed item onward. Bulleted lists aren't numbered, so they're rejected.
+
+Options:
+  --start N      Start the list's numbering at N (a positive integer)
+  --format FMT   Glyph style: decimal | lower-alpha | upper-alpha | lower-roman | upper-roman
+                 (decimal = 1.2.3., lower-alpha = a.b.c., upper-roman = I.II.III., \u2026)
+  --restart      Begin a FRESH list at this item: split it off with its own numbering
+                 (combine with --start/--format to set the new list's first number/style)
+  --continue     Continue the PREVIOUS list's numbering here instead of restarting at 1
+  -o, --output PATH / --dry-run / -v, --verbose / -h, --help
+
+--restart and --continue are mutually exclusive; --continue can't combine with
+--start/--format (it adopts the previous list's numbering). List numbering edits
+are applied directly (untracked) \u2014 Word records no revision for them.
+
+Examples:
+  docx lists set report.docx --at p12 --start 5
+  docx lists set report.docx --at p12 --format upper-roman
+  docx lists set report.docx --at p20 --restart --start 1
+  docx lists set report.docx --at p20 --continue
+`;
+var init_set2 = __esm(() => {
+  init_core2();
+  init_respond();
+});
+
+// src/cli/lists/index.ts
+var exports_lists = {};
+__export(exports_lists, {
+  run: () => run35
+});
+async function run35(args) {
+  const verb = args[0];
+  if (!verb || verb === "--help" || verb === "-h" || verb === "help") {
+    await writeStdout(HELP31);
+    return verb ? 0 : 2;
+  }
+  const loader = SUBCOMMANDS9[verb];
+  if (!loader) {
+    return fail("USAGE", `Unknown lists subcommand: ${verb}`, 'Run "docx lists --help".');
+  }
+  const module_ = await loader();
+  return module_.run(args.slice(1));
+}
+var SUBCOMMANDS9, HELP31 = `docx lists \u2014 control list numbering (start value, glyph format, restart/continue)
+
+Usage:
+  docx lists set FILE --at pN [options]
+
+Verbs:
+  set   Renumber a numbered list \u2014 set its start value or glyph format, or make it
+        restart vs. continue the previous list
+        (--at pN [--start N] [--format FMT] [--restart] [--continue])
+
+Lists are otherwise handled by the standard verbs:
+  create a list   docx insert FILE --after pN --list "first,second"  (or markdown "1. \u2026")
+  edit an item    docx edit FILE --at pN --text "..."
+  inspect         docx read FILE --ast   (list.numId / level / ordered / start / format)
+
+Run "docx lists set --help" for option detail.
+`;
+var init_lists2 = __esm(() => {
+  init_respond();
+  SUBCOMMANDS9 = {
+    set: () => Promise.resolve().then(() => (init_set2(), exports_set))
+  };
+});
+
 // src/cli/outline/build.ts
 function buildOutline(doc, options = {}) {
   const stylePrefix = options.stylePrefix ?? "Heading";
@@ -90617,23 +91338,23 @@ var init_build = __esm(() => {
 // src/cli/outline/index.ts
 var exports_outline = {};
 __export(exports_outline, {
-  run: () => run34
+  run: () => run36
 });
-async function run34(args) {
+async function run36(args) {
   const parsed = await tryParseArgs(args, {
     "style-prefix": { type: "string" },
     json: { type: "boolean" },
     help: { type: "boolean", short: "h" }
-  }, HELP30);
+  }, HELP32);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP30);
+    await writeStdout(HELP32);
     return EXIT2.OK;
   }
   const path2 = parsed.positionals[0];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP30);
+    return fail("USAGE", "Missing FILE argument", HELP32);
   const stylePrefix = parsed.values["style-prefix"] ?? "Heading";
   if (stylePrefix.length === 0) {
     return fail("USAGE", "--style-prefix cannot be empty");
@@ -90661,7 +91382,7 @@ function renderOutlineText(entries, depth = 0) {
   }
   return lines;
 }
-var HELP30 = `docx outline \u2014 list headings as a hierarchical tree
+var HELP32 = `docx outline \u2014 list headings as a hierarchical tree
 
 Usage:
   docx outline FILE [options]
@@ -90741,6 +91462,8 @@ function renderMarkdown(doc, options = {}) {
     referencedEndnoteIds: new Set,
     referencedTrackedChanges: new Map,
     orderedCounters: new Map,
+    prevListNumId: null,
+    seenListNumIds: new Set,
     contentWidthEmu: contentWidthEmu(documentGeometry(blocks)?.geometry),
     governingColumns: computeGoverningColumns(blocks),
     wrappingTabLines: [],
@@ -90827,17 +91550,17 @@ function detectFormatBaseline(blocks) {
   const sizeChars = new Map;
   let total = 0;
   for (const paragraph2 of flattenParagraphs(blocks)) {
-    for (const run35 of paragraph2.runs) {
-      if (run35.type !== "text")
+    for (const run37 of paragraph2.runs) {
+      if (run37.type !== "text")
         continue;
-      const length = run35.text.length;
+      const length = run37.text.length;
       if (length === 0)
         continue;
       total += length;
-      if (run35.font)
-        fontChars.set(run35.font, (fontChars.get(run35.font) ?? 0) + length);
-      if (run35.sizeHalfPoints !== undefined) {
-        sizeChars.set(run35.sizeHalfPoints, (sizeChars.get(run35.sizeHalfPoints) ?? 0) + length);
+      if (run37.font)
+        fontChars.set(run37.font, (fontChars.get(run37.font) ?? 0) + length);
+      if (run37.sizeHalfPoints !== undefined) {
+        sizeChars.set(run37.sizeHalfPoints, (sizeChars.get(run37.sizeHalfPoints) ?? 0) + length);
       }
     }
   }
@@ -90871,8 +91594,8 @@ function emptyCommentIndex() {
     orderedIds: []
   };
 }
-function isRunVisible(run35, view) {
-  const kind = run35.trackedChange?.kind;
+function isRunVisible(run37, view) {
+  const kind = run37.trackedChange?.kind;
   if (!kind)
     return true;
   if (view === "accepted" && (kind === "del" || kind === "moveFrom"))
@@ -90887,13 +91610,13 @@ function buildCommentIndex(blocks, options) {
   const spanText = new Map;
   const orderedIds = [];
   for (const paragraph2 of flattenParagraphs(blocks)) {
-    paragraph2.runs.forEach((run35, index2) => {
-      const comments = runComments(run35);
+    paragraph2.runs.forEach((run37, index2) => {
+      const comments = runComments(run37);
       if (!comments)
         return;
-      if (run35.type === "text" && !isRunVisible(run35, view))
+      if (run37.type === "text" && !isRunVisible(run37, view))
         return;
-      const spanContribution = run35.type === "text" ? run35.text : run35.type === "equation" ? run35.text : "";
+      const spanContribution = run37.type === "text" ? run37.text : run37.type === "equation" ? run37.text : "";
       for (const commentId of comments) {
         if (!spanText.has(commentId))
           orderedIds.push(commentId);
@@ -90913,11 +91636,11 @@ function buildCommentIndex(blocks, options) {
   }
   return { endingsByRun, spanText, orderedIds };
 }
-function runComments(run35) {
-  if (run35.type === "text")
-    return run35.comments;
-  if (run35.type === "equation")
-    return run35.comments;
+function runComments(run37) {
+  if (run37.type === "text")
+    return run37.comments;
+  if (run37.type === "equation")
+    return run37.comments;
   return;
 }
 function slotKey(paragraphId, runIndex) {
@@ -90926,6 +91649,7 @@ function slotKey(paragraphId, runIndex) {
 function renderBlock(block, ctx) {
   if (block.type === "paragraph")
     return renderParagraph(block, ctx);
+  ctx.prevListNumId = null;
   if (block.type === "table")
     return renderTable(block, ctx);
   return null;
@@ -90938,8 +91662,7 @@ function computeSectionStarts(blocks) {
       continue;
     const entry = {
       block: blocks[index2],
-      breakIndex: index2,
-      isTrailing: index2 === blocks.length - 1
+      breakIndex: index2
     };
     const group = starts.get(sectionStart) ?? [];
     group.push(entry);
@@ -90949,12 +91672,7 @@ function computeSectionStarts(blocks) {
   return starts;
 }
 function renderSectionStart(entry, blocks, ctx) {
-  const marginalLines = ctx.marginalsBySection.get(entry.block.id);
-  if (entry.isTrailing) {
-    return marginalLines && marginalLines.length > 0 ? marginalLines.join(`
-`) : null;
-  }
-  return renderSectionBreak(entry.block, governedRange(blocks, entry.breakIndex), marginalLines);
+  return renderSectionBreak(entry.block, governedRange(blocks, entry.breakIndex), ctx.marginalsBySection.get(entry.block.id));
 }
 function computeGoverningColumns(blocks) {
   const map3 = new Map;
@@ -90995,7 +91713,7 @@ function tabCureRange(ids) {
   return min === max ? `p${min}` : `p${min}-p${max}`;
 }
 function layoutHazardNote(paragraph2, ctx) {
-  if (!paragraph2.runs.some((run35) => run35.type === "tab"))
+  if (!paragraph2.runs.some((run37) => run37.type === "tab"))
     return "";
   const cols = ctx.governingColumns.get(paragraph2.id) ?? 1;
   if (cols > 1) {
@@ -91068,25 +91786,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(run35, contentEmu) {
+function formatImageNote(run37, contentEmu) {
   const pairs = [];
-  if (run35.widthEmu && run35.heightEmu) {
+  if (run37.widthEmu && run37.heightEmu) {
     pairs.push([
       "size",
-      `${emuToInches(run35.widthEmu)}x${emuToInches(run35.heightEmu)}in`
+      `${emuToInches(run37.widthEmu)}x${emuToInches(run37.heightEmu)}in`
     ]);
   }
-  if (run35.floating)
+  if (run37.floating)
     pairs.push(["float", "yes"]);
-  if (run35.wrap)
-    pairs.push(["wrap", run35.wrap]);
-  if (run35.align)
-    pairs.push(["align", run35.align]);
-  if (run35.widthEmu && run35.widthEmu > contentEmu)
+  if (run37.wrap)
+    pairs.push(["wrap", run37.wrap]);
+  if (run37.align)
+    pairs.push(["align", run37.align]);
+  if (run37.widthEmu && run37.widthEmu > contentEmu)
     pairs.push(["overflow", "yes"]);
   if (pairs.length === 0)
     return "";
-  return ` ${formatNote("image", pairs, [run35.id])}`;
+  return ` ${formatNote("image", pairs, [run37.id])}`;
 }
 function documentGeometry(blocks) {
   const geometric = blocks.filter((block) => block.type === "sectionBreak" && hasGeometry(block));
@@ -91192,14 +91910,14 @@ function isCodeBlockParagraph(block) {
 function renderCodeBlockGroup(paragraphs, ctx) {
   if (ctx.options.view !== "baseline" && ctx.options.view !== "accepted") {
     for (const paragraph2 of paragraphs) {
-      for (const run35 of paragraph2.runs) {
-        if (run35.type === "text" && run35.trackedChange) {
-          ctx.referencedTrackedChanges.set(run35.trackedChange.id, run35.trackedChange);
+      for (const run37 of paragraph2.runs) {
+        if (run37.type === "text" && run37.trackedChange) {
+          ctx.referencedTrackedChanges.set(run37.trackedChange.id, run37.trackedChange);
         }
       }
     }
   }
-  const lines = paragraphs.map((paragraph2) => paragraph2.runs.filter((run35) => run35.type === "text" && typeof run35.text === "string").map((run35) => run35.text).join(""));
+  const lines = paragraphs.map((paragraph2) => paragraph2.runs.filter((run37) => run37.type === "text" && typeof run37.text === "string").map((run37) => run37.text).join(""));
   const firstId = paragraphs[0]?.id ?? "";
   const lastId = paragraphs[paragraphs.length - 1]?.id ?? firstId;
   const language = codeBlockLanguageFromStyleId(paragraphs[0]?.style) ?? "";
@@ -91213,11 +91931,14 @@ function renderParagraph(paragraph2, ctx) {
   const view = ctx.options.view ?? "accepted";
   const mask = inlineEscapeMask(paragraphContent(paragraph2.runs, view), hasEquationRun(paragraph2.runs));
   const rendered = renderRuns(paragraph2.id, paragraph2.runs, ctx, mask, 0);
-  if (rendered.length === 0)
+  if (rendered.length === 0) {
+    ctx.prevListNumId = paragraph2.list?.numId ?? null;
     return null;
+  }
   const prefix = paragraphPrefix(paragraph2, orderedOrdinal(paragraph2, ctx));
   const body = rendered.replace(/[ \t]+$/, "");
-  const note = formatParagraphNote(paragraph2);
+  const listNote = listAnnotation(paragraph2, ctx);
+  const note = listNote !== "" ? listNote : formatParagraphNote(paragraph2);
   const locatorOrNote = note !== "" ? note : ` <!-- ${paragraph2.id} -->`;
   const trailing = `${locatorOrNote}${layoutHazardNote(paragraph2, ctx)}`;
   if (isDisplayEquationOnly(body)) {
@@ -91282,7 +92003,8 @@ function orderedOrdinal(paragraph2, ctx) {
     return 1;
   const { numId, level } = paragraph2.list;
   const key = `${numId}:${level}`;
-  const next = (ctx.orderedCounters.get(key) ?? 0) + 1;
+  const base = ctx.orderedCounters.get(key) ?? (paragraph2.list.start ?? 1) - 1;
+  const next = base + 1;
   ctx.orderedCounters.set(key, next);
   for (const existing of ctx.orderedCounters.keys()) {
     const [keyNumId, keyLevel] = existing.split(":");
@@ -91292,6 +92014,32 @@ function orderedOrdinal(paragraph2, ctx) {
   }
   return next;
 }
+function listAnnotation(paragraph2, ctx) {
+  const list3 = paragraph2.list;
+  if (!list3) {
+    ctx.prevListNumId = null;
+    return "";
+  }
+  const isRunStart = ctx.prevListNumId !== list3.numId;
+  ctx.prevListNumId = list3.numId;
+  if (!isRunStart)
+    return "";
+  const isContinuation = ctx.seenListNumIds.has(list3.numId);
+  ctx.seenListNumIds.add(list3.numId);
+  if (!list3.ordered)
+    return "";
+  if (isContinuation) {
+    return ` ${formatNote("list", [], [paragraph2.id, "continues"])}`;
+  }
+  const pairs = [];
+  if (list3.start !== undefined && list3.start !== 1)
+    pairs.push(["start", list3.start]);
+  if (list3.format)
+    pairs.push(["format", list3.format]);
+  if (pairs.length === 0)
+    return "";
+  return ` ${formatNote("list", pairs, [paragraph2.id])}`;
+}
 function paragraphPrefix(paragraph2, ordinal) {
   const quotePrefix = paragraph2.quoteDepth ? "> ".repeat(paragraph2.quoteDepth) : "";
   const headingLevel2 = headingLevelFor(paragraph2.style);
@@ -91322,10 +92070,10 @@ function headingLevelFor(style) {
 function renderRuns(paragraphId, runs, ctx, mask, baseOffset) {
   const view = ctx.options.view ?? "accepted";
   const visibleEntries = [];
-  runs.forEach((run35, index2) => {
-    if (run35.type === "text" && !isRunVisible(run35, view))
+  runs.forEach((run37, index2) => {
+    if (run37.type === "text" && !isRunVisible(run37, view))
       return;
-    visibleEntries.push({ run: run35, originalIndex: index2 });
+    visibleEntries.push({ run: run37, originalIndex: index2 });
   });
   let out = "";
   let cursor = 0;
@@ -91336,14 +92084,14 @@ function renderRuns(paragraphId, runs, ctx, mask, baseOffset) {
       cursor++;
       continue;
     }
-    const { run: run35 } = entry;
-    if (run35.type === "text") {
+    const { run: run37 } = entry;
+    if (run37.type === "text") {
       let lookahead2 = cursor + 1;
       while (lookahead2 < visibleEntries.length) {
         const next = visibleEntries[lookahead2];
         if (!next || next.run.type !== "text")
           break;
-        if (!sameDecoration(run35, next.run))
+        if (!sameDecoration(run37, next.run))
           break;
         lookahead2++;
       }
@@ -91364,29 +92112,29 @@ function renderRuns(paragraphId, runs, ctx, mask, baseOffset) {
       cursor = lookahead2;
       continue;
     }
-    if (run35.type === "image") {
-      const alt = sanitizeAltText(run35.alt ?? run35.id);
-      const extension2 = extensionForImageMime(run35.contentType) ?? "bin";
-      out += `![${alt}](${run35.hash}.${extension2})`;
-      out += formatImageNote(run35, ctx.contentWidthEmu);
-    } else if (run35.type === "break") {
-      if (run35.kind === "line")
+    if (run37.type === "image") {
+      const alt = sanitizeAltText(run37.alt ?? run37.id);
+      const extension2 = extensionForImageMime(run37.contentType) ?? "bin";
+      out += `![${alt}](${run37.hash}.${extension2})`;
+      out += formatImageNote(run37, ctx.contentWidthEmu);
+    } else if (run37.type === "break") {
+      if (run37.kind === "line")
         out += `
 `;
-    } else if (run35.type === "tab") {
+    } else if (run37.type === "tab") {
       out += "\t";
-    } else if (run35.type === "equation") {
-      const body = run35.latex.length > 0 ? run35.latex : run35.text;
-      out += run35.display ? `$$${body}$$` : `$${body}$`;
+    } else if (run37.type === "equation") {
+      const body = run37.latex.length > 0 ? run37.latex : run37.text;
+      out += run37.display ? `$$${body}$$` : `$${body}$`;
       out += commentEndingsFor(paragraphId, [{ originalIndex: cursor }], ctx.commentIndex);
-    } else if (run35.type === "noteRef") {
-      if (run35.kind === "footnote")
-        ctx.referencedFootnoteIds.add(run35.id);
+    } else if (run37.type === "noteRef") {
+      if (run37.kind === "footnote")
+        ctx.referencedFootnoteIds.add(run37.id);
       else
-        ctx.referencedEndnoteIds.add(run35.id);
-      out += `[^${run35.id}]`;
-    } else if (run35.type === "chart") {
-      out += `\`[${run35.kind}]\``;
+        ctx.referencedEndnoteIds.add(run37.id);
+      out += `[^${run37.id}]`;
+    } else if (run37.type === "chart") {
+      out += `\`[${run37.kind}]\``;
     }
     cursor++;
   }
@@ -91420,7 +92168,7 @@ function sameCommentSet(left, right) {
   return true;
 }
 function renderTextSegment(runs, view, baseline, mask, offset2) {
-  const text6 = runs.map((run35) => run35.text).join("");
+  const text6 = runs.map((run37) => run37.text).join("");
   if (text6.length === 0)
     return "";
   const first = runs[0];
@@ -91464,33 +92212,33 @@ function criticMarkerFor(kind) {
     return "++";
   return "--";
 }
-function needsHtmlWrap(run35, baseline) {
-  return Boolean(run35.color && !isDefaultColor(run35.color) || run35.colorTheme && !isDefaultThemeColor(run35) || run35.shade || run35.font && run35.font !== baseline.font || run35.sizeHalfPoints !== undefined && run35.sizeHalfPoints !== baseline.sizeHalfPoints || run35.smallCaps || run35.allCaps || run35.underline || run35.vertAlign === "superscript" || run35.vertAlign === "subscript" || run35.highlight);
+function needsHtmlWrap(run37, baseline) {
+  return Boolean(run37.color && !isDefaultColor(run37.color) || run37.colorTheme && !isDefaultThemeColor(run37) || run37.shade || run37.font && run37.font !== baseline.font || run37.sizeHalfPoints !== undefined && run37.sizeHalfPoints !== baseline.sizeHalfPoints || run37.smallCaps || run37.allCaps || run37.underline || run37.vertAlign === "superscript" || run37.vertAlign === "subscript" || run37.highlight);
 }
-function wrapRunFormatting(body, run35, baseline) {
+function wrapRunFormatting(body, run37, baseline) {
   const styles = [];
   const attrs = [];
-  if (run35.color && !isDefaultColor(run35.color))
-    styles.push(`color:#${run35.color}`);
-  if (run35.shade)
-    styles.push(`background-color:#${run35.shade}`);
-  if (run35.font && run35.font !== baseline.font) {
-    styles.push(`font-family:${cssFontFamily(run35.font)}`);
+  if (run37.color && !isDefaultColor(run37.color))
+    styles.push(`color:#${run37.color}`);
+  if (run37.shade)
+    styles.push(`background-color:#${run37.shade}`);
+  if (run37.font && run37.font !== baseline.font) {
+    styles.push(`font-family:${cssFontFamily(run37.font)}`);
   }
-  if (run35.sizeHalfPoints !== undefined && run35.sizeHalfPoints !== baseline.sizeHalfPoints) {
-    styles.push(`font-size:${run35.sizeHalfPoints / 2}pt`);
+  if (run37.sizeHalfPoints !== undefined && run37.sizeHalfPoints !== baseline.sizeHalfPoints) {
+    styles.push(`font-size:${run37.sizeHalfPoints / 2}pt`);
   }
-  if (run35.smallCaps)
+  if (run37.smallCaps)
     styles.push("font-variant:small-caps");
-  if (run35.allCaps)
+  if (run37.allCaps)
     styles.push("text-transform:uppercase");
-  if (run35.colorTheme && !isDefaultThemeColor(run35)) {
-    attrs.push(htmlAttr("data-color-theme", run35.colorTheme));
-    if (run35.colorThemeTint) {
-      attrs.push(htmlAttr("data-color-theme-tint", run35.colorThemeTint));
+  if (run37.colorTheme && !isDefaultThemeColor(run37)) {
+    attrs.push(htmlAttr("data-color-theme", run37.colorTheme));
+    if (run37.colorThemeTint) {
+      attrs.push(htmlAttr("data-color-theme-tint", run37.colorThemeTint));
     }
-    if (run35.colorThemeShade) {
-      attrs.push(htmlAttr("data-color-theme-shade", run35.colorThemeShade));
+    if (run37.colorThemeShade) {
+      attrs.push(htmlAttr("data-color-theme-shade", run37.colorThemeShade));
     }
   }
   let out = body;
@@ -91499,18 +92247,18 @@ function wrapRunFormatting(body, run35, baseline) {
     const attrPart = attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
     out = `<span${stylePart}${attrPart}>${out}</span>`;
   }
-  if (run35.underline === "single") {
+  if (run37.underline === "single") {
     out = `<u>${out}</u>`;
-  } else if (run35.underline) {
-    const color2 = run35.underlineColor ? ` ${htmlAttr("data-underline-color", run35.underlineColor)}` : "";
-    out = `<u ${htmlAttr("data-underline", run35.underline)}${color2}>${out}</u>`;
+  } else if (run37.underline) {
+    const color2 = run37.underlineColor ? ` ${htmlAttr("data-underline-color", run37.underlineColor)}` : "";
+    out = `<u ${htmlAttr("data-underline", run37.underline)}${color2}>${out}</u>`;
   }
-  if (run35.vertAlign === "superscript")
+  if (run37.vertAlign === "superscript")
     out = `<sup>${out}</sup>`;
-  else if (run35.vertAlign === "subscript")
+  else if (run37.vertAlign === "subscript")
     out = `<sub>${out}</sub>`;
-  if (run35.highlight) {
-    const named = run35.highlight === "yellow" ? "" : ` ${htmlAttr("data-highlight", run35.highlight)}`;
+  if (run37.highlight) {
+    const named = run37.highlight === "yellow" ? "" : ` ${htmlAttr("data-highlight", run37.highlight)}`;
     out = `<mark${named}>${out}</mark>`;
   }
   return out;
@@ -91519,8 +92267,8 @@ function isDefaultColor(color2) {
   const normalized = color2.toLowerCase();
   return normalized === "000000" || normalized === "auto";
 }
-function isDefaultThemeColor(run35) {
-  return (run35.colorTheme === "text1" || run35.colorTheme === "dark1") && !run35.colorThemeTint && !run35.colorThemeShade;
+function isDefaultThemeColor(run37) {
+  return (run37.colorTheme === "text1" || run37.colorTheme === "dark1") && !run37.colorThemeTint && !run37.colorThemeShade;
 }
 function cssFontFamily(font) {
   return /\s/.test(font) ? `'${font}'` : font;
@@ -91537,19 +92285,19 @@ function applyEscapeMask(text6, mask, offset2) {
 }
 function paragraphContent(runs, view) {
   let content3 = "";
-  for (const run35 of runs) {
-    if (run35.type !== "text")
+  for (const run37 of runs) {
+    if (run37.type !== "text")
       continue;
-    if (run35.runStyle === "Code")
+    if (run37.runStyle === "Code")
       continue;
-    if (!isRunVisible(run35, view))
+    if (!isRunVisible(run37, view))
       continue;
-    content3 += run35.text;
+    content3 += run37.text;
   }
   return content3;
 }
 function hasEquationRun(runs) {
-  return runs.some((run35) => run35.type === "equation");
+  return runs.some((run37) => run37.type === "equation");
 }
 function renderTable(table, ctx) {
   const view = ctx.options.view ?? "accepted";
@@ -91593,10 +92341,24 @@ function formatTableNote(table) {
   if (table.borders && table.borders !== "single") {
     pairs.push(["borders", table.borders]);
   }
+  if (table.align && table.align !== "left")
+    pairs.push(["align", table.align]);
+  if (table.style)
+    pairs.push(["style", table.style]);
+  const repeatHeaderRows = table.rows.map((row, index2) => row.repeatHeader ? `r${index2}` : null).filter((value) => value !== null);
+  if (repeatHeaderRows.length > 0)
+    pairs.push(["repeat-header", repeatHeaderRows.join(",")]);
+  const rowHeights = table.rows.map((row, index2) => row.height ? `r${index2}:${formatRowHeight(row.height)}` : null).filter((value) => value !== null);
+  if (rowHeights.length > 0)
+    pairs.push(["row-heights", rowHeights.join(",")]);
   if (pairs.length === 0)
     return "";
   return formatNote("table", pairs, [table.id]);
 }
+function formatRowHeight(height) {
+  const inches = `${twipsToInches(height.value)}in`;
+  return height.rule === "atLeast" ? inches : `${inches}(${height.rule})`;
+}
 function unevenWidths(grid) {
   if (grid.length < 2)
     return;
@@ -91653,11 +92415,27 @@ function cellNote(cell) {
     pairs.push(["vMerge", cell.vMerge]);
   if (cell.shading)
     pairs.push(["shading", cell.shading]);
+  if (cell.vAlign)
+    pairs.push(["vAlign", cell.vAlign]);
+  if (cell.borders)
+    pairs.push(["borders", cell.borders]);
+  const halign = uniformCellAlignment(cell);
+  if (halign)
+    pairs.push(["halign", halign]);
   if (pairs.length === 0)
     return "";
   const address = cellAddress(cell);
   return formatNote("cell", pairs, address ? [address] : []);
 }
+function uniformCellAlignment(cell) {
+  const aligns = cell.blocks.filter((block) => block.type === "paragraph").map((paragraph2) => paragraph2.alignment ?? "left");
+  if (aligns.length === 0)
+    return;
+  const first = aligns[0];
+  if (!first || first === "left")
+    return;
+  return aligns.every((align) => align === first) ? first : undefined;
+}
 function cellAddress(cell) {
   return cell.blocks[0]?.id.replace(/:(?:p|t)\d+$/, "");
 }
@@ -91835,9 +92613,9 @@ var init_markdown3 = __esm(() => {
 // src/cli/read/index.ts
 var exports_read = {};
 __export(exports_read, {
-  run: () => run35
+  run: () => run37
 });
-async function run35(args) {
+async function run37(args) {
   const parsed = await tryParseArgs(args, {
     ast: { type: "boolean" },
     from: { type: "string" },
@@ -91847,16 +92625,16 @@ async function run35(args) {
     current: { type: "boolean" },
     comments: { type: "boolean" },
     help: { type: "boolean", short: "h" }
-  }, HELP31);
+  }, HELP33);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP31);
+    await writeStdout(HELP33);
     return EXIT2.OK;
   }
   const path2 = parsed.positionals[0];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP31);
+    return fail("USAGE", "Missing FILE argument", HELP33);
   const ast = Boolean(parsed.values.ast);
   const from = parsed.values.from;
   const to = parsed.values.to;
@@ -91865,11 +92643,11 @@ async function run35(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", HELP31);
+    return fail("USAGE", "--from, --to, --accepted, --baseline, --current, and --comments are Markdown-only and cannot be combined with --ast", HELP33);
   }
   const view = resolveView({ accepted, baseline, current });
   if (!view) {
-    return fail("USAGE", "--accepted, --baseline, and --current are mutually exclusive", HELP31);
+    return fail("USAGE", "--accepted, --baseline, and --current are mutually exclusive", HELP33);
   }
   const docView = await openOrFail(path2);
   if (typeof docView === "number")
@@ -91898,7 +92676,7 @@ async function run35(args) {
     throw err;
   }
 }
-var HELP31 = `docx read \u2014 render document body as Markdown, or print AST as JSON
+var HELP33 = `docx read \u2014 render document body as Markdown, or print AST as JSON
 
 Usage:
   docx read FILE [options]
@@ -91988,20 +92766,20 @@ function parsePagesSpec(spec) {
 // src/cli/render/index.ts
 var exports_render = {};
 __export(exports_render, {
-  run: () => run36
+  run: () => run38
 });
 import { basename as basename2, extname as extname2, resolve as resolve2 } from "path";
-async function run36(args) {
-  const parsed = await tryParseArgs(args, OPTION_SPEC6, HELP32);
+async function run38(args) {
+  const parsed = await tryParseArgs(args, OPTION_SPEC6, HELP34);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP32);
+    await writeStdout(HELP34);
     return EXIT2.OK;
   }
   const filePath = parsed.positionals[0];
   if (!filePath)
-    return fail("USAGE", "Missing FILE argument", HELP32);
+    return fail("USAGE", "Missing FILE argument", HELP34);
   if (!await Bun.file(filePath).exists()) {
     return fail("FILE_NOT_FOUND", `File not found: ${filePath}`);
   }
@@ -92081,7 +92859,7 @@ function availabilityHint(installed) {
   }
   return `Detected engines: ${installed.join(", ")} \u2014 but none chose auto-select; pass --engine explicitly.`;
 }
-var HELP32 = `docx render \u2014 render each page of a .docx as a PNG/JPG image
+var HELP34 = `docx render \u2014 render each page of a .docx as a PNG/JPG image
 
 Usage:
   docx render FILE [options]
@@ -92148,6 +92926,55 @@ var init_render2 = __esm(() => {
   };
 });
 
+// src/cli/replace/scope.ts
+function validateScopeShape(at) {
+  let parsed;
+  try {
+    parsed = parseLocator(at);
+  } catch (error) {
+    if (error instanceof LocatorParseError) {
+      throw new ScopeError("INVALID_LOCATOR", error.message);
+    }
+    throw error;
+  }
+  if (!isParagraphLocator(parsed)) {
+    throw new ScopeError("INVALID_LOCATOR", `--at scope must be a single paragraph (pN) or cell paragraph (tT:rRcC:pN), got "${at}" \u2014 replace targets text within one paragraph`);
+  }
+  return at;
+}
+function isParagraphLocator(parsed) {
+  if (parsed.kind === "block")
+    return parsed.blockId[0] === "p";
+  let inner2 = parsed;
+  while (inner2?.kind === "cell")
+    inner2 = inner2.inner;
+  return inner2?.kind === "block" && inner2.blockId[0] === "p";
+}
+function resolveReplaceScope(document4, at) {
+  const blockId = validateScopeShape(at);
+  try {
+    document4.body.resolveBlock(at);
+  } catch (error) {
+    throw new ScopeError("BLOCK_NOT_FOUND", error.message);
+  }
+  return blockId;
+}
+function matchesInScope(matches, blockId) {
+  return matches.filter((match) => match.blockId === blockId);
+}
+var ScopeError;
+var init_scope = __esm(() => {
+  init_core2();
+  ScopeError = class ScopeError extends Error {
+    code;
+    constructor(code3, message) {
+      super(message);
+      this.code = code3;
+      this.name = "ScopeError";
+    }
+  };
+});
+
 // src/cli/replace/batch.ts
 async function runReplaceBatch(filePath, batchSource, values2) {
   const authorFlag = values2.author;
@@ -92181,6 +93008,13 @@ async function runReplaceBatch(filePath, batchSource, values2) {
     const spec = specs[index2];
     if (!spec)
       continue;
+    if (spec.at !== undefined) {
+      try {
+        document4.body.resolveBlock(spec.at);
+      } catch {
+        return fail("BLOCK_NOT_FOUND", `entry ${index2}: scope "${spec.at}" not found`);
+      }
+    }
     let findResult;
     try {
       findResult = findTextSpans(document4.body, spec.pattern, {
@@ -92193,7 +93027,7 @@ async function runReplaceBatch(filePath, batchSource, values2) {
       const message = matcherError instanceof Error ? matcherError.message : String(matcherError);
       return fail("USAGE", `entry ${index2}: invalid pattern: ${message}`);
     }
-    const all2 = findResult.matches;
+    const all2 = spec.at !== undefined ? matchesInScope(findResult.matches, spec.at) : findResult.matches;
     const selected = spec.limit !== undefined ? all2.slice(0, spec.limit) : spec.all ? all2 : all2.slice(0, 1);
     const tracked = allocator ? {
       meta: {
@@ -92265,6 +93099,20 @@ function validateSpec(raw, index2) {
     }
     limit = value;
   }
+  let at;
+  if (raw.at !== undefined) {
+    if (typeof raw.at !== "string") {
+      throw new EntryError3("USAGE", `entry ${index2}: "at" must be a string`);
+    }
+    try {
+      at = validateScopeShape(raw.at);
+    } catch (error) {
+      if (error instanceof ScopeError) {
+        throw new EntryError3(error.code, `entry ${index2}: ${error.message}`);
+      }
+      throw error;
+    }
+  }
   return {
     pattern: raw.pattern,
     replacement: raw.replacement,
@@ -92274,7 +93122,8 @@ function validateSpec(raw, index2) {
     all: Boolean(raw.all),
     ...limit !== undefined ? { limit } : {},
     view: wantCurrent ? "current" : wantBaseline ? "baseline" : "accepted",
-    ...typeof raw.author === "string" ? { author: raw.author } : {}
+    ...typeof raw.author === "string" ? { author: raw.author } : {},
+    ...at !== undefined ? { at } : {}
   };
 }
 var EntryError3;
@@ -92283,6 +93132,7 @@ var init_batch4 = __esm(() => {
   init_find();
   init_parse_helpers();
   init_respond();
+  init_scope();
   EntryError3 = class EntryError3 extends Error {
     code;
     hint;
@@ -92298,11 +93148,12 @@ var init_batch4 = __esm(() => {
 // src/cli/replace/index.ts
 var exports_replace3 = {};
 __export(exports_replace3, {
-  run: () => run37
+  run: () => run39
 });
-async function run37(args) {
+async function run39(args) {
   const parsed = await tryParseArgs(args, {
     batch: { type: "string" },
+    at: { type: "string" },
     regex: { type: "boolean" },
     "ignore-case": { type: "boolean" },
     all: { type: "boolean" },
@@ -92313,30 +93164,33 @@ async function run37(args) {
     baseline: { type: "boolean" },
     exact: { type: "boolean" },
     ...SAVE_FLAGS
-  }, HELP33);
+  }, HELP35);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP33);
+    await writeStdout(HELP35);
     return EXIT2.OK;
   }
   setVerboseAck(Boolean(parsed.values.verbose));
   const path2 = parsed.positionals[0];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP33);
+    return fail("USAGE", "Missing FILE argument", HELP35);
   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", HELP33);
+      return fail("USAGE", "--batch reads pattern/replacement from the JSONL file; don't also pass them as positionals", HELP35);
+    }
+    if (parsed.values.at !== undefined) {
+      return fail("USAGE", '--at is per-entry in batch mode: put "at" on each JSONL line, not on the command', HELP35);
     }
     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", HELP33);
+    return fail("USAGE", "Missing PATTERN argument", HELP35);
   if (replacement == null) {
-    return fail("USAGE", "Missing REPLACEMENT argument", HELP33);
+    return fail("USAGE", "Missing REPLACEMENT argument", HELP35);
   }
   const ignoreCase = Boolean(parsed.values["ignore-case"]);
   const useRegex = Boolean(parsed.values.regex);
@@ -92366,7 +93220,19 @@ async function run37(args) {
     const message = matcherError instanceof Error ? matcherError.message : String(matcherError);
     return fail("USAGE", `Invalid pattern: ${message}`);
   }
-  const allMatches = findResult.matches;
+  const atScope = parsed.values.at;
+  let allMatches = findResult.matches;
+  if (atScope !== undefined) {
+    try {
+      const blockId = resolveReplaceScope(document4, atScope);
+      allMatches = matchesInScope(allMatches, blockId);
+    } catch (scopeError) {
+      if (scopeError instanceof ScopeError) {
+        return fail(scopeError.code, scopeError.message);
+      }
+      throw scopeError;
+    }
+  }
   const normalizationFields = findResult.normalizedQuery !== undefined ? {
     normalizedPattern: findResult.normalizedQuery,
     normalizationApplied: findResult.normalizationApplied
@@ -92397,6 +93263,7 @@ async function run37(args) {
       regex: useRegex,
       ignoreCase,
       view: findView,
+      ...atScope ? { at: atScope } : {},
       totalMatches: allMatches.length,
       replaced: selected.length,
       matches: matchesPayload,
@@ -92415,6 +93282,7 @@ async function run37(args) {
       regex: useRegex,
       ignoreCase,
       view: findView,
+      ...atScope ? { at: atScope } : {},
       totalMatches: 0,
       replaced: 0,
       matches: [],
@@ -92451,6 +93319,7 @@ async function run37(args) {
     regex: useRegex,
     ignoreCase,
     view: findView,
+    ...atScope ? { at: atScope } : {},
     totalMatches: allMatches.length,
     replaced: selected.length,
     matches: matchesPayload,
@@ -92458,7 +93327,7 @@ async function run37(args) {
   }, partialHint);
   return EXIT2.OK;
 }
-var HELP33 = `docx replace \u2014 substitute text spans (sed for docx)
+var HELP35 = `docx replace \u2014 substitute text spans (sed for docx)
 
 Usage:
   docx replace FILE PATTERN REPLACEMENT [options]
@@ -92466,9 +93335,16 @@ Usage:
   docx replace FILE --batch -          [options]   # read JSONL from stdin
 
 Options:
+  --at LOCATOR      confine the replace to ONE paragraph: a body pN or a cell
+                    paragraph tT:rRcC:pN. Use this when the same placeholder
+                    repeats across the document (a r\xE9sum\xE9's "City, State" /
+                    "Position Title" in every entry) and you want THE one in a
+                    specific paragraph \u2014 no find + offset-span edit needed:
+                      docx replace doc.docx --at p20 "City, State" "San Francisco, CA"
   --regex           treat PATTERN as a JavaScript regular expression
   --ignore-case     case-insensitive match
-  --all             replace every match (default: just the first)
+  --all             replace every match (default: just the first; with --at,
+                    scoped to that paragraph)
   --limit N         replace at most N matches (in document order)
   --author NAME     author for tracked changes (default: $DOCX_AUTHOR)
   --track           record substitutions as tracked changes even when the
@@ -92539,28 +93415,29 @@ var init_replace4 = __esm(() => {
   init_parse_helpers();
   init_respond();
   init_batch4();
+  init_scope();
 });
 
 // src/cli/sections/index.tsx
 var exports_sections = {};
 __export(exports_sections, {
-  run: () => run38
+  run: () => run40
 });
 function hasPageGeometry(flags) {
   return flags.pageSize !== undefined || flags.orientation !== undefined || flags.margins !== undefined;
 }
-async function run38(args) {
-  const parsed = await tryParseArgs(args, OPTION_SPEC7, HELP34);
+async function run40(args) {
+  const parsed = await tryParseArgs(args, OPTION_SPEC7, HELP36);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP34);
+    await writeStdout(HELP36);
     return EXIT2.OK;
   }
   setVerboseAck(Boolean(parsed.values.verbose));
   const filePath = parsed.positionals[0];
   if (!filePath)
-    return fail("USAGE", "Missing FILE argument", HELP34);
+    return fail("USAGE", "Missing FILE argument", HELP36);
   const at = parsed.values.at;
   const flags = await parseSectionFlags(parsed.values);
   if (typeof flags === "number")
@@ -92580,22 +93457,22 @@ async function run38(args) {
     if (hasPageGeometry(flags) && flags.columns === undefined && flags.sectionType === undefined) {
       return editAllSections(document4, opts);
     }
-    return fail("USAGE", "Missing --at LOCATOR (a section sN, or a range pN-pM to wrap in columns). To set PAGE GEOMETRY for the whole document, omit --at and pass only --margins/--orientation/--size.", HELP34);
+    return fail("USAGE", "Missing --at LOCATOR (a section sN, or a range pN-pM to wrap in columns). To set PAGE GEOMETRY for the whole document, omit --at and pass only --margins/--orientation/--size.", HELP36);
   }
   let locator;
   try {
     locator = parseLocator(at);
   } catch (error) {
     if (error instanceof LocatorParseError) {
-      return fail("INVALID_LOCATOR", error.message, HELP34);
+      return fail("INVALID_LOCATOR", error.message, HELP36);
     }
     throw error;
   }
   if (locator.kind === "blockRange") {
     if (hasPageGeometry(flags))
-      return fail("USAGE", WRAP_REJECTS_GEOMETRY, HELP34);
+      return fail("USAGE", WRAP_REJECTS_GEOMETRY, HELP36);
     if (flags.columns === undefined) {
-      return fail("USAGE", "Wrapping a range in a section needs --columns N", HELP34);
+      return fail("USAGE", "Wrapping a range in a section needs --columns N", HELP36);
     }
     const range = await resolveBlockRangeOrFail(document4, at);
     if (typeof range === "number")
@@ -92607,20 +93484,20 @@ async function run38(args) {
     return blockRef;
   if (blockRef.node.tag === "w:sectPr") {
     if (flags.columns === undefined && flags.sectionType === undefined && !hasPageGeometry(flags)) {
-      return fail("USAGE", "Section edit needs --columns, --type, --orientation, --size, or --margins", HELP34);
+      return fail("USAGE", "Section edit needs --columns, --type, --orientation, --size, or --margins", HELP36);
     }
     return editSection(document4, blockRef, at, opts);
   }
   if (blockRef.node.tag === "w:p") {
     if (hasPageGeometry(flags))
-      return fail("USAGE", WRAP_REJECTS_GEOMETRY, HELP34);
+      return fail("USAGE", WRAP_REJECTS_GEOMETRY, HELP36);
     if (flags.columns === undefined) {
-      return fail("USAGE", "Wrapping a paragraph in a section needs --columns N", HELP34);
+      return fail("USAGE", "Wrapping a paragraph in a section needs --columns N", HELP36);
     }
     const index2 = blockRef.parent.indexOf(blockRef.node);
     return wrapRange(document4, blockRef.parent, index2, index2, at, opts);
   }
-  return fail("INVALID_LOCATOR", `--at needs a section (sN) or a paragraph range (pN-pM); ${at} is neither`, HELP34);
+  return fail("INVALID_LOCATOR", `--at needs a section (sN) or a paragraph range (pN-pM); ${at} is neither`, HELP36);
 }
 async function editSection(document4, blockRef, at, opts) {
   const track = resolveTracked(document4, opts.trackFlag);
@@ -92873,7 +93750,7 @@ async function commit(document4, opts, meta) {
   }, realignedNote + renderVerifyHint(destination));
   return EXIT2.OK;
 }
-var HELP34 = `docx sections \u2014 multi-column layout, section breaks & page setup
+var HELP36 = `docx sections \u2014 multi-column layout, section breaks & page setup
 
 Usage:
   docx sections FILE --at LOCATOR (--columns N | page setup) [options]
@@ -93366,9 +94243,9 @@ function appliedStyleIds(document4) {
       continue;
     if (block.style)
       used.add(block.style);
-    for (const run39 of block.runs) {
-      if (run39.type === "text" && run39.runStyle)
-        used.add(run39.runStyle);
+    for (const run41 of block.runs) {
+      if (run41.type === "text" && run41.runStyle)
+        used.add(run41.runStyle);
     }
   }
   return used;
@@ -93524,8 +94401,8 @@ function countStyleUsage(document4, styleId) {
       continue;
     if (block.style === styleId)
       count++;
-    for (const run39 of block.runs) {
-      if (run39.type === "text" && run39.runStyle === styleId)
+    for (const run41 of block.runs) {
+      if (run41.type === "text" && run41.runStyle === styleId)
         count++;
     }
   }
@@ -93577,7 +94454,7 @@ Examples:
   docx styles set report.docx --at Normal --font "Times New Roman" --size 12
   docx styles set report.docx --at Quote --italic --indent-left 0.5 --space-after 6
 `;
-var init_set2 = __esm(() => {
+var init_set3 = __esm(() => {
   init_core2();
   init_respond();
   init_shared2();
@@ -93663,6 +94540,11 @@ theme-following headings adopt the font. Styles/runs that pin their OWN font
 (e.g. a code block's monospace, a deliberately-Arial run) are preserved; pass
 --all to repoint those too.
 
+Theme-following headings only adopt the font if the document HAS a theme part
+(every doc this CLI creates does; Word docs do too). The ack's "themeUpdated"
+is false for the rare theme-less doc \u2014 there the body changes but headings keep
+their fallback font; run with --all to force the headings onto the new font.
+
 Options:
   --size N           Also set the default font size, in points (e.g. 12).
   --all              Repoint EVERY explicit font \u2014 styles, body runs, and notes \u2014
@@ -93686,18 +94568,18 @@ var init_set_default_font = __esm(() => {
 // src/cli/styles/index.ts
 var exports_styles = {};
 __export(exports_styles, {
-  run: () => run39
+  run: () => run41
 });
-async function run39(args) {
+async function run41(args) {
   if (args[0] === "set-default-font")
     return runSetDefaultFont(args.slice(1));
   if (args[0] === "set")
     return runStylesSet(args.slice(1));
   if (args[0] === "create")
     return runStylesCreate(args.slice(1));
-  return runStylesRead(args, HELP35);
+  return runStylesRead(args, HELP37);
 }
-var HELP35 = `docx styles \u2014 inspect, edit, and create the styles a document can apply
+var HELP37 = `docx styles \u2014 inspect, edit, and create the styles a document can apply
 
 Usage:
   docx styles FILE [--used] [--at STYLEID] [--json]     # list / describe (read)
@@ -93740,16 +94622,16 @@ See \`docx styles set --help\`, \`docx styles create --help\`, and
 var init_styles2 = __esm(() => {
   init_create3();
   init_read4();
-  init_set2();
+  init_set3();
   init_set_default_font();
 });
 
 // src/cli/tables/insert-row.tsx
 var exports_insert_row = {};
 __export(exports_insert_row, {
-  run: () => run40
+  run: () => run42
 });
-async function run40(args) {
+async function run42(args) {
   const parsed = await tryParseArgs(args, {
     at: { type: "string" },
     position: { type: "string" },
@@ -93757,20 +94639,20 @@ async function run40(args) {
     author: { type: "string" },
     track: { type: "boolean" },
     ...SAVE_FLAGS
-  }, HELP36);
+  }, HELP38);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP36);
+    await writeStdout(HELP38);
     return EXIT2.OK;
   }
   setVerboseAck(Boolean(parsed.values.verbose));
   const path2 = parsed.positionals[0];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP36);
+    return fail("USAGE", "Missing FILE argument", HELP38);
   const at = parsed.values.at;
   if (!at)
-    return fail("USAGE", "Missing --at tN", HELP36);
+    return fail("USAGE", "Missing --at tN", HELP38);
   const tableId = parseTableAt(at);
   if (!tableId) {
     return fail("INVALID_LOCATOR", `--at must be a table id like t0 (got ${at})`);
@@ -93791,7 +94673,7 @@ async function run40(args) {
   }
   const cellTexts = parsed.values.cells ? parsed.values.cells.split(",") : [];
   for (const cell of cellTexts) {
-    const mangled = await rejectShellMangledValue(cell, HELP36, "--cells");
+    const mangled = await rejectShellMangledValue(cell, HELP38, "--cells");
     if (typeof mangled === "number")
       return mangled;
   }
@@ -93892,7 +94774,7 @@ function rowChildIndex(table, grid, position2) {
   const lastRow = grid.rows[grid.rows.length - 1]?.node;
   return lastRow ? table.children.indexOf(lastRow) + 1 : table.children.length;
 }
-var AT_FORMS6, HELP36;
+var AT_FORMS6, HELP38;
 var init_insert_row = __esm(() => {
   init_core2();
   init_blocks();
@@ -93903,7 +94785,7 @@ var init_insert_row = __esm(() => {
   init_respond();
   init_jsx_dev_runtime();
   AT_FORMS6 = describeForms(["table"], "                     ");
-  HELP36 = `docx tables insert-row \u2014 insert a table row
+  HELP38 = `docx tables insert-row \u2014 insert a table row
 
 Usage:
   docx tables insert-row FILE --at tN [options]
@@ -93952,28 +94834,28 @@ Examples:
 // src/cli/tables/delete-row.ts
 var exports_delete_row = {};
 __export(exports_delete_row, {
-  run: () => run41
+  run: () => run43
 });
-async function run41(args) {
+async function run43(args) {
   const parsed = await tryParseArgs(args, {
     at: { type: "string" },
     author: { type: "string" },
     track: { type: "boolean" },
     ...SAVE_FLAGS
-  }, HELP37);
+  }, HELP39);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP37);
+    await writeStdout(HELP39);
     return EXIT2.OK;
   }
   setVerboseAck(Boolean(parsed.values.verbose));
   const path2 = parsed.positionals[0];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP37);
+    return fail("USAGE", "Missing FILE argument", HELP39);
   const at = parsed.values.at;
   if (!at)
-    return fail("USAGE", "Missing --at tN:rR", HELP37);
+    return fail("USAGE", "Missing --at tN:rR", HELP39);
   const target = parseRowAt(at);
   if (!target) {
     return fail("INVALID_LOCATOR", `--at must be a row locator like t0:r1 (got ${at})`);
@@ -94040,14 +94922,14 @@ function findVMergeOrphan(grid, rowIndex) {
   }
   return null;
 }
-var AT_FORMS7, HELP37;
+var AT_FORMS7, HELP39;
 var init_delete_row = __esm(() => {
   init_core2();
   init_locators();
   init_table();
   init_respond();
   AT_FORMS7 = describeForms(["tableRow"], "                     ");
-  HELP37 = `docx tables delete-row \u2014 delete a table row
+  HELP39 = `docx tables delete-row \u2014 delete a table row
 
 Usage:
   docx tables delete-row FILE --at tN:rR [options]
@@ -94083,9 +94965,9 @@ Examples:
 // src/cli/tables/insert-column.tsx
 var exports_insert_column = {};
 __export(exports_insert_column, {
-  run: () => run42
+  run: () => run44
 });
-async function run42(args) {
+async function run44(args) {
   const parsed = await tryParseArgs(args, {
     at: { type: "string" },
     position: { type: "string" },
@@ -94093,20 +94975,20 @@ async function run42(args) {
     author: { type: "string" },
     track: { type: "boolean" },
     ...SAVE_FLAGS
-  }, HELP38);
+  }, HELP40);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP38);
+    await writeStdout(HELP40);
     return EXIT2.OK;
   }
   setVerboseAck(Boolean(parsed.values.verbose));
   const path2 = parsed.positionals[0];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP38);
+    return fail("USAGE", "Missing FILE argument", HELP40);
   const at = parsed.values.at;
   if (!at)
-    return fail("USAGE", "Missing --at tN", HELP38);
+    return fail("USAGE", "Missing --at tN", HELP40);
   const tableId = parseTableAt(at);
   if (!tableId) {
     return fail("INVALID_LOCATOR", `--at must be a table id like t0 (got ${at})`);
@@ -94221,14 +95103,14 @@ function insertCellAtColumn(row, position2, cell) {
   const at = lastCell ? row.node.children.indexOf(lastCell.node) + 1 : row.node.children.length;
   row.node.children.splice(at, 0, cell);
 }
-var AT_FORMS8, HELP38;
+var AT_FORMS8, HELP40;
 var init_insert_column = __esm(() => {
   init_core2();
   init_locators();
   init_table();
   init_respond();
   AT_FORMS8 = describeForms(["table"], "                     ");
-  HELP38 = `docx tables insert-column \u2014 insert a table column
+  HELP40 = `docx tables insert-column \u2014 insert a table column
 
 Usage:
   docx tables insert-column FILE --at tN [options]
@@ -94266,28 +95148,28 @@ Examples:
 // src/cli/tables/delete-column.ts
 var exports_delete_column = {};
 __export(exports_delete_column, {
-  run: () => run43
+  run: () => run45
 });
-async function run43(args) {
+async function run45(args) {
   const parsed = await tryParseArgs(args, {
     at: { type: "string" },
     author: { type: "string" },
     track: { type: "boolean" },
     ...SAVE_FLAGS
-  }, HELP39);
+  }, HELP41);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP39);
+    await writeStdout(HELP41);
     return EXIT2.OK;
   }
   setVerboseAck(Boolean(parsed.values.verbose));
   const path2 = parsed.positionals[0];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP39);
+    return fail("USAGE", "Missing FILE argument", HELP41);
   const at = parsed.values.at;
   if (!at)
-    return fail("USAGE", "Missing --at tN:cC", HELP39);
+    return fail("USAGE", "Missing --at tN:cC", HELP41);
   const target = parseColumnAt(at);
   if (!target) {
     return fail("INVALID_LOCATOR", `--at must be a column locator like t0:c2 (got ${at})`);
@@ -94371,14 +95253,14 @@ function removeGridColumn(tblGrid, col) {
   if (index2 !== -1)
     tblGrid.children.splice(index2, 1);
 }
-var AT_FORMS9, HELP39;
+var AT_FORMS9, HELP41;
 var init_delete_column = __esm(() => {
   init_core2();
   init_locators();
   init_table();
   init_respond();
   AT_FORMS9 = describeForms(["tableColumn"], "                     ");
-  HELP39 = `docx tables delete-column \u2014 delete a table column
+  HELP41 = `docx tables delete-column \u2014 delete a table column
 
 Usage:
   docx tables delete-column FILE --at tN:cC [options]
@@ -94413,36 +95295,36 @@ Examples:
 // src/cli/tables/set-widths.ts
 var exports_set_widths = {};
 __export(exports_set_widths, {
-  run: () => run44
+  run: () => run46
 });
-async function run44(args) {
+async function run46(args) {
   const parsed = await tryParseArgs(args, {
     at: { type: "string" },
     widths: { type: "string" },
     author: { type: "string" },
     track: { type: "boolean" },
     ...SAVE_FLAGS
-  }, HELP40);
+  }, HELP42);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP40);
+    await writeStdout(HELP42);
     return EXIT2.OK;
   }
   setVerboseAck(Boolean(parsed.values.verbose));
   const path2 = parsed.positionals[0];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP40);
+    return fail("USAGE", "Missing FILE argument", HELP42);
   const at = parsed.values.at;
   if (!at)
-    return fail("USAGE", "Missing --at tN", HELP40);
+    return fail("USAGE", "Missing --at tN", HELP42);
   const tableId = parseTableAt(at);
   if (!tableId) {
     return fail("INVALID_LOCATOR", `--at must be a table id like t0 (got ${at})`);
   }
   const widthsSpec = parsed.values.widths;
   if (!widthsSpec)
-    return fail("USAGE", "Missing --widths", HELP40);
+    return fail("USAGE", "Missing --widths", HELP42);
   const document4 = await openOrFail(path2);
   if (typeof document4 === "number")
     return document4;
@@ -94591,14 +95473,14 @@ function describeColumnWidths(twips) {
   const cells = twips.map((value, index2) => `g${index2}=${twipsToInches(value)}in`);
   return `widths: ${cells.join(" ")}`;
 }
-var AT_FORMS10, HELP40, MIN_COL_TWIPS = 288;
+var AT_FORMS10, HELP42, MIN_COL_TWIPS = 288;
 var init_set_widths = __esm(() => {
   init_core2();
   init_locators();
   init_table();
   init_respond();
   AT_FORMS10 = describeForms(["table"], "                     ");
-  HELP40 = `docx tables set-widths \u2014 set column widths
+  HELP42 = `docx tables set-widths \u2014 set column widths
 
 Usage:
   docx tables set-widths FILE --at tN --widths SPEC [options]
@@ -94667,28 +95549,28 @@ var init_common2 = __esm(() => {
 // src/cli/tables/merge.tsx
 var exports_merge = {};
 __export(exports_merge, {
-  run: () => run45
+  run: () => run47
 });
-async function run45(args) {
+async function run47(args) {
   const parsed = await tryParseArgs(args, {
     at: { type: "string" },
     author: { type: "string" },
     track: { type: "boolean" },
     ...SAVE_FLAGS
-  }, HELP41);
+  }, HELP43);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP41);
+    await writeStdout(HELP43);
     return EXIT2.OK;
   }
   setVerboseAck(Boolean(parsed.values.verbose));
   const path2 = parsed.positionals[0];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP41);
+    return fail("USAGE", "Missing FILE argument", HELP43);
   const at = parsed.values.at;
   if (!at)
-    return fail("USAGE", "Missing --at tN:rR1cC1-rR2cC2", HELP41);
+    return fail("USAGE", "Missing --at tN:rR1cC1-rR2cC2", HELP43);
   const region = parseCellRangeAt(at);
   if (!region) {
     return fail("INVALID_LOCATOR", `--at must be a cell-range locator like t0:r0c0-r1c1 (got ${at})`);
@@ -94781,7 +95663,7 @@ function mergeRow(row, c1, c2, width, isTop, vertical) {
   if (vertical && !isTop)
     clearCellContent(anchor.node);
 }
-var AT_FORMS11, HELP41;
+var AT_FORMS11, HELP43;
 var init_merge = __esm(() => {
   init_core2();
   init_locators();
@@ -94789,7 +95671,7 @@ var init_merge = __esm(() => {
   init_respond();
   init_common2();
   AT_FORMS11 = describeForms(["cellRange"], "                     ");
-  HELP41 = `docx tables merge \u2014 merge a rectangular cell region
+  HELP43 = `docx tables merge \u2014 merge a rectangular cell region
 
 Usage:
   docx tables merge FILE --at tN:rR1cC1-rR2cC2 [options]
@@ -94828,28 +95710,28 @@ Examples:
 // src/cli/tables/unmerge.tsx
 var exports_unmerge = {};
 __export(exports_unmerge, {
-  run: () => run46
+  run: () => run48
 });
-async function run46(args) {
+async function run48(args) {
   const parsed = await tryParseArgs(args, {
     at: { type: "string" },
     author: { type: "string" },
     track: { type: "boolean" },
     ...SAVE_FLAGS
-  }, HELP42);
+  }, HELP44);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP42);
+    await writeStdout(HELP44);
     return EXIT2.OK;
   }
   setVerboseAck(Boolean(parsed.values.verbose));
   const path2 = parsed.positionals[0];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP42);
+    return fail("USAGE", "Missing FILE argument", HELP44);
   const at = parsed.values.at;
   if (!at)
-    return fail("USAGE", "Missing --at tN:rRcC", HELP42);
+    return fail("USAGE", "Missing --at tN:rRcC", HELP44);
   const target = parseCellAt(at);
   if (!target) {
     return fail("INVALID_LOCATOR", `--at must be a cell locator like t0:r0c0 (got ${at})`);
@@ -94924,7 +95806,7 @@ function verticalSpanRows(grid, row, col, vertical) {
   }
   return rows;
 }
-var AT_FORMS12, HELP42;
+var AT_FORMS12, HELP44;
 var init_unmerge = __esm(() => {
   init_core2();
   init_locators();
@@ -94932,7 +95814,7 @@ var init_unmerge = __esm(() => {
   init_respond();
   init_common2();
   AT_FORMS12 = describeForms(["cell"], "                     ");
-  HELP42 = `docx tables unmerge \u2014 split a merged cell back into individual cells
+  HELP44 = `docx tables unmerge \u2014 split a merged cell back into individual cells
 
 Usage:
   docx tables unmerge FILE --at tN:rRcC [options]
@@ -94969,9 +95851,9 @@ Examples:
 // src/cli/tables/borders.tsx
 var exports_borders = {};
 __export(exports_borders, {
-  run: () => run47
+  run: () => run49
 });
-async function run47(args) {
+async function run49(args) {
   const parsed = await tryParseArgs(args, {
     at: { type: "string" },
     style: { type: "string" },
@@ -94980,20 +95862,20 @@ async function run47(args) {
     author: { type: "string" },
     track: { type: "boolean" },
     ...SAVE_FLAGS
-  }, HELP43);
+  }, HELP45);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP43);
+    await writeStdout(HELP45);
     return EXIT2.OK;
   }
   setVerboseAck(Boolean(parsed.values.verbose));
   const path2 = parsed.positionals[0];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP43);
+    return fail("USAGE", "Missing FILE argument", HELP45);
   const at = parsed.values.at;
   if (!at)
-    return fail("USAGE", "Missing --at tN", HELP43);
+    return fail("USAGE", "Missing --at tN", HELP45);
   const tableId = parseTableAt(at);
   if (!tableId) {
     return fail("INVALID_LOCATOR", `--at must be a table id like t0 (got ${at})`);
@@ -95070,7 +95952,7 @@ function buildBorders(style, sizeEighths, color2) {
     ]
   }, undefined, true, undefined, this);
 }
-var STYLES, AT_FORMS13, HELP43;
+var STYLES, AT_FORMS13, HELP45;
 var init_borders = __esm(() => {
   init_core2();
   init_jsx();
@@ -95081,7 +95963,7 @@ var init_borders = __esm(() => {
   init_jsx_dev_runtime();
   STYLES = new Set(["single", "double", "none"]);
   AT_FORMS13 = describeForms(["table"], "                     ");
-  HELP43 = `docx tables borders \u2014 set table borders
+  HELP45 = `docx tables borders \u2014 set table borders
 
 Usage:
   docx tables borders FILE --at tN [options]
@@ -95118,25 +96000,486 @@ Examples:
 `;
 });
 
+// src/cli/tables/format.tsx
+var exports_format = {};
+__export(exports_format, {
+  run: () => run50
+});
+async function run50(args) {
+  const parsed = await tryParseArgs(args, {
+    at: { type: "string" },
+    shade: { type: "string" },
+    valign: { type: "string" },
+    halign: { type: "string" },
+    "cell-borders": { type: "string" },
+    "border-style": { type: "string" },
+    "border-size": { type: "string" },
+    "border-color": { type: "string" },
+    align: { type: "string" },
+    style: { type: "string" },
+    "row-height": { type: "string" },
+    "height-rule": { type: "string" },
+    "repeat-header": { type: "boolean" },
+    "no-repeat-header": { type: "boolean" },
+    author: { type: "string" },
+    track: { type: "boolean" },
+    ...SAVE_FLAGS
+  }, HELP46);
+  if (typeof parsed === "number")
+    return parsed;
+  if (parsed.values.help) {
+    await writeStdout(HELP46);
+    return EXIT2.OK;
+  }
+  setVerboseAck(Boolean(parsed.values.verbose));
+  const path2 = parsed.positionals[0];
+  if (!path2)
+    return fail("USAGE", "Missing FILE argument", HELP46);
+  const at = parsed.values.at;
+  if (!at)
+    return fail("USAGE", "Missing --at LOCATOR", HELP46);
+  const scope = resolveScope(at);
+  if (!scope) {
+    return fail("INVALID_LOCATOR", `--at must address a table, row, column, cell, or cell range (got ${at})`, "e.g. t0 (table), t0:r0 (row), t0:c1 (column), t0:r0c0 (cell), t0:r0c0-r1c2 (range).");
+  }
+  const plan = buildPlan2(parsed.values);
+  if (typeof plan === "string")
+    return fail("USAGE", plan);
+  if (planIsEmpty(plan)) {
+    return fail("USAGE", "Nothing to format \u2014 pass at least one of --shade/--valign/--halign/--cell-borders/--align/--style/--row-height/--repeat-header");
+  }
+  const scopeError = validateScope(scope, plan);
+  if (scopeError)
+    return fail("USAGE", scopeError);
+  const document4 = await openOrFail(path2);
+  if (typeof document4 === "number")
+    return document4;
+  const tableNode = resolveTableNode(document4, scope.tableId);
+  if (!tableNode)
+    return fail("BLOCK_NOT_FOUND", `Table not found: ${scope.tableId}`);
+  const grid = buildGrid(tableNode);
+  const cells = selectCells(grid, scope);
+  const rows = selectRows(grid, scope);
+  const targetError = validateTargets(scope, plan, cells, rows);
+  if (targetError)
+    return fail("BLOCK_NOT_FOUND", targetError);
+  const outputPath = parsed.values.output;
+  if (parsed.values["dry-run"]) {
+    await respond({
+      operation: "tables.format",
+      dryRun: true,
+      path: path2,
+      at,
+      applied: appliedList2(plan),
+      ...outputPath ? { output: outputPath } : {}
+    });
+    return EXIT2.OK;
+  }
+  const tracking = resolveTracked(document4, parsed.values.track);
+  const author = parsed.values.author;
+  applyCellProps(document4, cells, plan, tracking, author);
+  if (plan.halign !== undefined)
+    applyHalign(document4, cells, plan.halign, tracking, author);
+  applyTableProps(tableNode, plan);
+  applyRowProps(rows, plan);
+  const untracked = untrackedSummary(plan);
+  if (untracked)
+    noteStructuralChange(document4, cells[0]?.node, untracked, author, parsed.values.track);
+  await document4.save(outputPath);
+  const destination = outputPath ?? path2;
+  await respondAck({
+    ok: true,
+    operation: "tables.format",
+    path: destination,
+    table: at,
+    applied: appliedList2(plan)
+  }, renderVerifyHint(destination));
+  return EXIT2.OK;
+}
+function resolveScope(at) {
+  const cell = parseCellAt(at);
+  if (cell)
+    return { kind: "cell", ...cell };
+  const range = parseCellRangeAt(at);
+  if (range)
+    return { kind: "range", ...range };
+  const row = parseRowAt(at);
+  if (row)
+    return { kind: "row", ...row };
+  const column = parseColumnAt(at);
+  if (column)
+    return { kind: "column", ...column };
+  const tableId = parseTableAt(at);
+  if (tableId)
+    return { kind: "table", tableId };
+  return null;
+}
+function buildPlan2(values2) {
+  const plan = {};
+  const shade = values2.shade;
+  if (shade !== undefined) {
+    if (isClear(shade))
+      plan.shade = null;
+    else {
+      const hex = resolveColor(shade);
+      if (!hex)
+        return colorError("--shade", shade);
+      plan.shade = hex;
+    }
+  }
+  const valign = values2.valign;
+  if (valign !== undefined) {
+    if (!VALIGNS.has(valign))
+      return "--valign must be top, center, or bottom";
+    plan.valign = valign;
+  }
+  const halign = values2.halign;
+  if (halign !== undefined) {
+    if (!HALIGNS.has(halign))
+      return "--halign must be left, center, right, or justify";
+    plan.halign = halign;
+  }
+  const cellBorders = values2["cell-borders"];
+  if (cellBorders !== undefined) {
+    const built = buildCellBorders(values2, cellBorders);
+    if (typeof built === "string")
+      return built;
+    plan.cellBorders = built;
+  }
+  const align = values2.align;
+  if (align !== undefined) {
+    if (!TABLE_ALIGNS.has(align))
+      return "--align must be left, center, or right";
+    plan.align = align;
+  }
+  const style = values2.style;
+  if (style !== undefined)
+    plan.style = isClear(style) ? null : style;
+  const rowHeight = values2["row-height"];
+  const heightRule = values2["height-rule"];
+  if (heightRule !== undefined && !HEIGHT_RULES.has(heightRule))
+    return "--height-rule must be atLeast, exact, or auto";
+  if (heightRule !== undefined && rowHeight === undefined)
+    return "--height-rule has no effect without --row-height";
+  if (rowHeight !== undefined) {
+    const twips = parseMeasureToTwips(rowHeight);
+    if (twips === null)
+      return `--row-height must be a positive measure WITH a unit, e.g. 0.4in or 28pt (got ${rowHeight})`;
+    plan.rowHeight = {
+      value: twips,
+      rule: heightRule ?? "atLeast"
+    };
+  }
+  if (values2["repeat-header"] && values2["no-repeat-header"])
+    return "--repeat-header and --no-repeat-header are mutually exclusive";
+  if (values2["repeat-header"])
+    plan.repeatHeader = true;
+  if (values2["no-repeat-header"])
+    plan.repeatHeader = false;
+  return plan;
+}
+function buildCellBorders(values2, sidesRaw) {
+  if (isClear(sidesRaw))
+    return { updates: [], clearAll: true };
+  const style = values2["border-style"] ?? "single";
+  if (!BORDER_STYLES.has(style))
+    return "--border-style must be single, double, or none";
+  const sizeRaw = values2["border-size"];
+  if (sizeRaw !== undefined && (!Number.isInteger(Number(sizeRaw)) || Number(sizeRaw) <= 0))
+    return "--border-size must be a positive integer (eighths of a point)";
+  const sizeEighths = sizeRaw ? Number(sizeRaw) : 4;
+  const colorRaw = values2["border-color"] ?? "auto";
+  const color2 = colorRaw === "auto" ? "auto" : resolveColor(colorRaw);
+  if (!color2)
+    return colorError("--border-color", colorRaw);
+  const edge = { style, sizeEighths, color: color2 };
+  const sides = new Set;
+  for (const token of sidesRaw.split(",").map((value) => value.trim())) {
+    if (token === "all") {
+      for (const side of ALL_SIDES)
+        sides.add(side);
+      continue;
+    }
+    if (!ALL_SIDES.includes(token))
+      return `--cell-borders side "${token}" must be one of ${ALL_SIDES.join(", ")}, all, or none`;
+    sides.add(token);
+  }
+  return {
+    updates: [...sides].map((side) => ({ side, edge })),
+    clearAll: false
+  };
+}
+function selectCells(grid, scope) {
+  if (scope.kind === "table")
+    return grid.rows.flatMap((row) => row.cells);
+  if (scope.kind === "row")
+    return grid.rows[scope.row]?.cells ?? [];
+  if (scope.kind === "cell") {
+    const cell = cellAt(grid.rows[scope.row], scope.col);
+    return cell ? [cell] : [];
+  }
+  if (scope.kind === "column") {
+    const out2 = [];
+    for (const row of grid.rows) {
+      const cell = cellAt(row, scope.col);
+      if (cell && !out2.includes(cell))
+        out2.push(cell);
+    }
+    return out2;
+  }
+  const r1 = Math.min(scope.start.row, scope.end.row);
+  const r2 = Math.max(scope.start.row, scope.end.row);
+  const c1 = Math.min(scope.start.col, scope.end.col);
+  const c2 = Math.max(scope.start.col, scope.end.col);
+  const out = [];
+  for (let row = r1;row <= r2; row++) {
+    for (const cell of grid.rows[row]?.cells ?? []) {
+      if (cell.colStart <= c2 && cell.colStart + cell.colSpan - 1 >= c1)
+        out.push(cell);
+    }
+  }
+  return out;
+}
+function selectRows(grid, scope) {
+  if (scope.kind === "table")
+    return grid.rows;
+  if (scope.kind === "row") {
+    const row = grid.rows[scope.row];
+    return row ? [row] : [];
+  }
+  return [];
+}
+function applyCellProps(document4, cells, plan, tracking, author) {
+  if (plan.shade === undefined && plan.valign === undefined && plan.cellBorders === undefined)
+    return;
+  for (const cell of cells) {
+    const prior = tracking ? (cell.node.findChild("w:tcPr")?.children ?? []).map((child2) => child2.clone()) : [];
+    if (plan.shade !== undefined)
+      setCellShading(cell.node, plan.shade);
+    if (plan.valign !== undefined)
+      setCellVAlign(cell.node, plan.valign);
+    if (plan.cellBorders !== undefined)
+      setCellBorders(cell.node, plan.cellBorders.updates, plan.cellBorders.clearAll);
+    if (tracking)
+      appendTcPrChange(cell.node, prior, new TrackChanges(document4).mintMeta(author));
+  }
+}
+function applyHalign(document4, cells, alignment, tracking, author) {
+  const edit = new Edit(document4);
+  for (const cell of cells) {
+    for (const paragraph2 of cell.node.findChildren("w:p")) {
+      edit.paragraphProperties({ node: paragraph2, parent: cell.node.children }, { alignment }, { authorFlag: author, track: tracking });
+    }
+  }
+}
+function applyTableProps(tableNode, plan) {
+  if (plan.align !== undefined)
+    setTableJustification(tableNode, plan.align);
+  if (plan.style !== undefined)
+    setTableStyle(tableNode, plan.style);
+}
+function applyRowProps(rows, plan) {
+  if (plan.rowHeight === undefined && plan.repeatHeader === undefined)
+    return;
+  for (const row of rows) {
+    if (plan.rowHeight !== undefined)
+      setRowHeight(row.node, plan.rowHeight);
+    if (plan.repeatHeader !== undefined)
+      setRepeatHeader(row.node, plan.repeatHeader);
+  }
+}
+function validateScope(scope, plan) {
+  const hasTableFlag = plan.align !== undefined || plan.style !== undefined;
+  if (hasTableFlag && scope.kind !== "table")
+    return "--align/--style position or restyle the whole table \u2014 use --at tN";
+  const hasRowFlag = plan.rowHeight !== undefined || plan.repeatHeader !== undefined;
+  if (hasRowFlag && scope.kind !== "table" && scope.kind !== "row")
+    return "--row-height/--repeat-header apply to a row \u2014 use --at tN:rR (or --at tN for every row)";
+  return null;
+}
+function validateTargets(scope, plan, cells, rows) {
+  const hasCellFlag = plan.shade !== undefined || plan.valign !== undefined || plan.halign !== undefined || plan.cellBorders !== undefined;
+  if (hasCellFlag && cells.length === 0)
+    return `No cells matched ${describeScope(scope)}`;
+  const hasRowFlag = plan.rowHeight !== undefined || plan.repeatHeader !== undefined;
+  if (hasRowFlag && rows.length === 0)
+    return `No rows matched ${describeScope(scope)}`;
+  return null;
+}
+function describeScope(scope) {
+  if (scope.kind === "table")
+    return scope.tableId;
+  if (scope.kind === "row")
+    return `${scope.tableId}:r${scope.row}`;
+  if (scope.kind === "column")
+    return `${scope.tableId}:c${scope.col}`;
+  if (scope.kind === "cell")
+    return `${scope.tableId}:r${scope.row}c${scope.col}`;
+  return `${scope.tableId}:r${scope.start.row}c${scope.start.col}-r${scope.end.row}c${scope.end.col}`;
+}
+function appliedList2(plan) {
+  const out = [];
+  if (plan.shade !== undefined)
+    out.push("shade");
+  if (plan.valign !== undefined)
+    out.push("valign");
+  if (plan.halign !== undefined)
+    out.push("halign");
+  if (plan.cellBorders !== undefined)
+    out.push("cell-borders");
+  if (plan.align !== undefined)
+    out.push("align");
+  if (plan.style !== undefined)
+    out.push("style");
+  if (plan.rowHeight !== undefined)
+    out.push("row-height");
+  if (plan.repeatHeader !== undefined)
+    out.push("repeat-header");
+  return out;
+}
+function untrackedSummary(plan) {
+  const parts = [];
+  if (plan.align !== undefined)
+    parts.push(`table align ${plan.align ?? "left"}`);
+  if (plan.style !== undefined)
+    parts.push(plan.style ? `table style ${plan.style}` : "table style cleared");
+  if (plan.rowHeight !== undefined)
+    parts.push("row height set");
+  if (plan.repeatHeader !== undefined)
+    parts.push(plan.repeatHeader ? "repeat-header on" : "repeat-header off");
+  return parts.length > 0 ? `set ${parts.join("; ")}` : "";
+}
+function planIsEmpty(plan) {
+  return appliedList2(plan).length === 0;
+}
+function isClear(value) {
+  const lower = value.toLowerCase();
+  return lower === "none" || lower === "auto";
+}
+function resolveColor(value) {
+  const named = COLOR_NAMES[value.toLowerCase()];
+  if (named)
+    return named;
+  const hex = normalizeHexColor(value).toUpperCase();
+  return /^[0-9A-F]{6}$/.test(hex) ? hex : null;
+}
+function colorError(flag, value) {
+  return `${flag} must be a 6-digit hex (e.g. D9D9D9) or a name (${Object.keys(COLOR_NAMES).slice(0, 6).join(", ")}, \u2026) \u2014 got ${value}`;
+}
+function parseMeasureToTwips(raw) {
+  const match = raw.trim().match(/^(\d*\.?\d+)\s*(in|pt)$/i);
+  if (!match)
+    return null;
+  const value = Number.parseFloat(match[1]);
+  if (!Number.isFinite(value) || value <= 0)
+    return null;
+  const unit = match[2].toLowerCase();
+  return Math.round(unit === "pt" ? value * 20 : value * 1440);
+}
+var HELP46 = `docx tables format \u2014 shade, align, border, and size table cells/rows/tables
+
+Usage:
+  docx tables format FILE --at LOCATOR [formatting options]
+
+The --at locator picks WHAT to format; its granularity picks which options apply.
+  --at t0            whole table
+  --at t0:r2         a row          --at t0:c1   a column
+  --at t0:r1c2       a single cell  --at t0:r1c0-r3c2   a rectangle of cells
+
+Cell options (any locator \u2014 broadcast to every cell it covers):
+  --shade HEX|NAME|none   Cell background fill (e.g. D9D9D9, "grey", or none to clear)
+  --valign top|center|bottom   Vertical alignment of cell content
+  --halign left|center|right|justify
+                          Horizontal alignment of cell TEXT (a paragraph property \u2014
+                          not the same as --align, which moves the whole table)
+  --cell-borders SIDES    Comma list of top,bottom,left,right,all,insideH,insideV
+                          (or none to clear). Styled by the --border-* options:
+  --border-style single|double|none   (default: single)
+  --border-size EIGHTHS   Thickness in eighths of a point (default: 4 = 0.5pt)
+  --border-color HEX|NAME (default: auto)
+
+Row options (--at t0:rR, or --at t0 for every row):
+  --row-height MEASURE    a unit is required: 0.4in or 28pt (a bare number is rejected)
+  --height-rule atLeast|exact|auto   (default: atLeast)
+  --repeat-header / --no-repeat-header
+                          Repeat the row as a header atop each page the table spans
+
+Table options (--at t0 only):
+  --align left|center|right   Position the whole table on the page
+  --style STYLEID|none    Apply (or clear) a table style from styles.xml
+
+Common:
+  --author NAME   Author for tracked changes / audit comments (default: $DOCX_AUTHOR)
+  --track         Record as a tracked change even if the doc toggle is off
+  -o, --output PATH / --dry-run / -v, --verbose / -h, --help
+
+Tracking: cell shading/vAlign/borders record as a real <w:tcPrChange> and --halign
+as a <w:pPrChange> (both round-trip in Word). Table align/style and row height/
+repeat-header have no tracked-change construct Word will revert, so under tracking
+they apply in place with a [docx-cli] audit comment (same policy as tables borders).
+
+Examples:
+  docx tables format invoice.docx --at t0:r0 --shade D9D9D9 --valign center
+  docx tables format invoice.docx --at t0:c2 --halign right
+  docx tables format invoice.docx --at t0:r1c0-r3c2 --cell-borders bottom
+  docx tables format invoice.docx --at t0 --align center --style LightGrid
+  docx tables format invoice.docx --at t0:r0 --repeat-header --row-height 0.4in
+`, VALIGNS, HALIGNS, TABLE_ALIGNS, BORDER_STYLES, HEIGHT_RULES, ALL_SIDES, COLOR_NAMES;
+var init_format = __esm(() => {
+  init_core2();
+  init_locators();
+  init_table();
+  init_parse_helpers();
+  init_respond();
+  init_common2();
+  VALIGNS = new Set(["top", "center", "bottom"]);
+  HALIGNS = new Set(["left", "center", "right", "justify"]);
+  TABLE_ALIGNS = new Set(["left", "center", "right"]);
+  BORDER_STYLES = new Set(["single", "double", "none"]);
+  HEIGHT_RULES = new Set(["atLeast", "exact", "auto"]);
+  ALL_SIDES = [
+    "top",
+    "left",
+    "bottom",
+    "right",
+    "insideH",
+    "insideV"
+  ];
+  COLOR_NAMES = {
+    white: "FFFFFF",
+    black: "000000",
+    gray: "808080",
+    grey: "808080",
+    lightgray: "D9D9D9",
+    lightgrey: "D9D9D9",
+    darkgray: "A6A6A6",
+    darkgrey: "A6A6A6",
+    red: "FF0000",
+    green: "00B050",
+    blue: "0070C0",
+    yellow: "FFFF00"
+  };
+});
+
 // src/cli/tables/index.ts
 var exports_tables = {};
 __export(exports_tables, {
-  run: () => run48
+  run: () => run51
 });
-async function run48(args) {
+async function run51(args) {
   const verb = args[0];
   if (!verb || verb === "--help" || verb === "-h" || verb === "help") {
-    await writeStdout(HELP44);
+    await writeStdout(HELP47);
     return verb ? 0 : 2;
   }
-  const loader = SUBCOMMANDS9[verb];
+  const loader = SUBCOMMANDS10[verb];
   if (!loader) {
     return fail("USAGE", `Unknown tables subcommand: ${verb}`, 'Run "docx tables --help".');
   }
   const module_ = await loader();
   return module_.run(args.slice(1));
 }
-var SUBCOMMANDS9, HELP44 = `docx tables \u2014 restructure tables (rows, columns, merges, widths, borders)
+var SUBCOMMANDS10, HELP47 = `docx tables \u2014 restructure & format tables (rows, columns, merges, widths, shading)
 
 Usage:
   docx tables <verb> FILE [options]
@@ -95150,6 +96493,9 @@ Verbs:
   merge           Merge a cell region (--at tN:rR1cC1-rR2cC2)
   unmerge         Split a merge anchor (--at tN:rRcC)
   borders         Set table borders (--at tN [--style] [--size] [--color])
+  format          Shade/align/border/size cells, rows, or the table
+                  (--at LOCATOR [--shade] [--valign] [--halign] [--cell-borders]
+                   [--align] [--style] [--row-height] [--repeat-header])
 
 These verbs restructure an existing table. The rest of the table lifecycle uses
 the standard verbs:
@@ -95162,7 +96508,7 @@ Run "docx tables <verb> --help" for verb-specific help.
 `;
 var init_tables = __esm(() => {
   init_respond();
-  SUBCOMMANDS9 = {
+  SUBCOMMANDS10 = {
     "insert-row": () => Promise.resolve().then(() => (init_insert_row(), exports_insert_row)),
     "delete-row": () => Promise.resolve().then(() => (init_delete_row(), exports_delete_row)),
     "insert-column": () => Promise.resolve().then(() => (init_insert_column(), exports_insert_column)),
@@ -95170,7 +96516,8 @@ var init_tables = __esm(() => {
     "set-widths": () => Promise.resolve().then(() => (init_set_widths(), exports_set_widths)),
     merge: () => Promise.resolve().then(() => (init_merge(), exports_merge)),
     unmerge: () => Promise.resolve().then(() => (init_unmerge(), exports_unmerge)),
-    borders: () => Promise.resolve().then(() => (init_borders(), exports_borders))
+    borders: () => Promise.resolve().then(() => (init_borders(), exports_borders)),
+    format: () => Promise.resolve().then(() => (init_format(), exports_format))
   };
 });
 
@@ -95232,42 +96579,23 @@ var init_groups = __esm(() => {
   };
 });
 
-// src/cli/track-changes/list.ts
-var exports_list5 = {};
-__export(exports_list5, {
-  run: () => run49
-});
-async function run49(args) {
-  const parsed = await tryParseArgs(args, {
-    help: { type: "boolean", short: "h" }
-  }, HELP45);
-  if (typeof parsed === "number")
-    return parsed;
-  if (parsed.values.help) {
-    await writeStdout(HELP45);
-    return EXIT2.OK;
-  }
-  const path2 = parsed.positionals[0];
-  if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP45);
-  const document4 = await openOrFail(path2);
-  if (typeof document4 === "number")
-    return document4;
+// src/cli/track-changes/list-view.ts
+function collectTrackedChangeRecords(document4) {
   const byId = new Map;
   for (const paragraph2 of flattenParagraphs(document4.body.blocks)) {
-    for (const run50 of paragraph2.runs) {
-      if (run50.type !== "text" || !run50.trackedChange)
+    for (const run52 of paragraph2.runs) {
+      if (run52.type !== "text" || !run52.trackedChange)
         continue;
-      const change = run50.trackedChange;
+      const change = run52.trackedChange;
       const existing = byId.get(change.id);
       if (existing) {
-        existing.text += run50.text;
+        existing.text += run52.text;
         continue;
       }
       byId.set(change.id, {
         ...change,
         blockId: paragraph2.id,
-        text: run50.text
+        text: run52.text
       });
     }
   }
@@ -95304,8 +96632,154 @@ async function run49(args) {
     if (group)
       record.group = group;
   }
-  await respond(sorted);
-  return EXIT2.OK;
+  return sorted;
+}
+function renderTrackedChangeTable(records) {
+  if (records.length === 0)
+    return `no tracked changes
+`;
+  const byGroup = new Map;
+  for (const record of records) {
+    if (!record.group)
+      continue;
+    const members = byGroup.get(record.group) ?? [];
+    members.push(record);
+    byGroup.set(record.group, members);
+  }
+  const rows = [];
+  const consumed = new Set;
+  for (const record of records) {
+    if (record.group) {
+      if (consumed.has(record.group))
+        continue;
+      consumed.add(record.group);
+      const members = byGroup.get(record.group) ?? [record];
+      const del = members.find((member) => member.kind === "del");
+      const ins = members.find((member) => member.kind === "ins");
+      rows.push({
+        handle: record.group,
+        verb: "replace",
+        block: record.blockId,
+        desc: `${quote(del?.text ?? "")} \u2192 ${quote(ins?.text ?? "")}`
+      });
+      continue;
+    }
+    rows.push({
+      handle: record.id,
+      verb: verbLabel(record.kind),
+      block: record.blockId,
+      desc: describeSolo(record)
+    });
+  }
+  const handleWidth = Math.max(...rows.map((row) => row.handle.length));
+  const verbWidth = Math.max(...rows.map((row) => row.verb.length));
+  const blockWidth = Math.max(...rows.map((row) => row.block.length));
+  const body = rows.map((row) => `  ${row.handle.padEnd(handleWidth)}  ${row.verb.padEnd(verbWidth)}  ${row.block.padEnd(blockWidth)}  ${row.desc}`).join(`
+`);
+  const total = records.length;
+  const header = `${total} tracked change${total === 1 ? "" : "s"}${rows.length === total ? "" : ` (${rows.length} logical)`}:`;
+  const footer = `Address by the leftmost handle: accept/reject --at <handle> (repeatable).
+` + "A revN handle resolves both halves of a replace in one call; --json for full detail.";
+  return `${header}
+
+${body}
+
+${footer}
+`;
+}
+async function remainingTrackedChangesBlock(path2, verb) {
+  let document4;
+  try {
+    document4 = await Document.open(path2);
+  } catch {
+    return "";
+  }
+  const remaining = collectTrackedChangeRecords(document4);
+  if (remaining.length === 0)
+    return "";
+  return `
+Remaining (ids renumbered after this ${verb}):
+
+${renderTrackedChangeTable(remaining)}`;
+}
+function quote(text6, max = 44) {
+  const collapsed = text6.replace(/\s+/g, " ").trim();
+  if (collapsed === "")
+    return "\xB6";
+  const clipped = collapsed.length > max ? `${collapsed.slice(0, max - 1)}\u2026` : collapsed;
+  return `"${clipped}"`;
+}
+function verbLabel(kind) {
+  const labels = {
+    ins: "insert",
+    del: "delete",
+    moveFrom: "move-from",
+    moveTo: "move-to",
+    sectPrChange: "section",
+    pPrChange: "format",
+    rowIns: "row-insert",
+    rowDel: "row-delete",
+    cellIns: "cell-insert",
+    cellDel: "cell-delete",
+    tblGridChange: "grid",
+    tblPrChange: "table-fmt",
+    tcPrChange: "cell-fmt",
+    checkboxToggle: "checkbox"
+  };
+  return labels[kind] ?? kind;
+}
+function describeSolo(record) {
+  if (record.kind === "ins" || record.kind === "del" || record.kind === "moveFrom" || record.kind === "moveTo") {
+    return record.text === "" ? "\xB6 paragraph mark" : quote(record.text);
+  }
+  if (record.kind === "pPrChange" || record.kind === "sectPrChange") {
+    const diff2 = propDiff(record.prior, record.current);
+    return diff2 || (record.kind === "pPrChange" ? "paragraph format" : "layout");
+  }
+  const notes = {
+    rowIns: "row inserted",
+    rowDel: "row deleted",
+    cellIns: "cell inserted",
+    cellDel: "cell deleted",
+    tblGridChange: "grid widths",
+    tblPrChange: "table properties",
+    tcPrChange: "cell properties",
+    checkboxToggle: "checkbox toggled"
+  };
+  return notes[record.kind] ?? "";
+}
+function propDiff(prior, current) {
+  const before = flattenProps(prior);
+  const after = flattenProps(current);
+  const keys = new Set([...before.keys(), ...after.keys()]);
+  const parts = [];
+  for (const key of keys) {
+    const from = before.get(key);
+    const to = after.get(key);
+    if (from === to)
+      continue;
+    parts.push(`${key} ${from ?? "\xB7"}\u2192${to ?? "\xB7"}`);
+  }
+  if (parts.length === 0)
+    return "";
+  if (parts.length > 3)
+    return `${parts.slice(0, 3).join(", ")}, \u2026`;
+  return parts.join(", ");
+}
+function flattenProps(obj, prefix = "") {
+  const out = new Map;
+  if (obj === null || typeof obj !== "object")
+    return out;
+  for (const [key, value] of Object.entries(obj)) {
+    const path2 = prefix ? `${prefix}.${key}` : key;
+    if (value !== null && typeof value === "object") {
+      for (const [k, v] of flattenProps(value, path2))
+        out.set(k, v);
+    } else if (typeof value === "string" || typeof value === "number") {
+      out.set(path2, value);
+    }
+  }
+  return out;
 }
 function trackedChangeIndex(id) {
   const match = id.match(/^tc(\d+)$/);
@@ -95355,12 +96829,50 @@ function readParagraphPropsSummary(children) {
   }
   return out;
 }
-var HELP45 = `docx track-changes list \u2014 inventory every revision wrapper
+var init_list_view = __esm(() => {
+  init_core2();
+  init_track_changes();
+  init_groups();
+});
+
+// src/cli/track-changes/list.ts
+var exports_list5 = {};
+__export(exports_list5, {
+  run: () => run52
+});
+async function run52(args) {
+  const parsed = await tryParseArgs(args, {
+    help: { type: "boolean", short: "h" },
+    json: { type: "boolean" }
+  }, HELP48);
+  if (typeof parsed === "number")
+    return parsed;
+  if (parsed.values.help) {
+    await writeStdout(HELP48);
+    return EXIT2.OK;
+  }
+  const path2 = parsed.positionals[0];
+  if (!path2)
+    return fail("USAGE", "Missing FILE argument", HELP48);
+  const document4 = await openOrFail(path2);
+  if (typeof document4 === "number")
+    return document4;
+  const records = collectTrackedChangeRecords(document4);
+  if (parsed.values.json) {
+    await respond(records);
+    return EXIT2.OK;
+  }
+  await writeStdout(renderTrackedChangeTable(records));
+  return EXIT2.OK;
+}
+var HELP48 = `docx track-changes list \u2014 inventory every revision wrapper
 
 Usage:
   docx track-changes list FILE [options]
 
 Options:
+  --json        Emit the full revision objects as a JSON array (default: a
+                text table, one LOGICAL change per line)
   -h, --help    Show this help
 
 Lists every revision wrapper with stable tcN ids \u2014 run-level <w:ins>, <w:del>,
@@ -95370,25 +96882,35 @@ paragraph-mark <w:ins>/<w:del> markers (a self-closing element inside
 of the same logical move appear as separate entries; their kind tells them
 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\`. 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", "pPrChange", "rowIns", "rowDel", "cellIns", "cellDel",
-"tblGridChange", "tblPrChange", "tcPrChange", "checkboxToggle". Paragraph-mark
-entries have kind "ins"/"del" with text "" \u2014 their blockId is the owning
-paragraph's pN. Table-structural entries (rowIns/rowDel/cellIns/cellDel and
-the property revisions tblGridChange/tblPrChange/tcPrChange) have text "" and
-blockId set to the owning table's tN. checkboxToggle entries surface a Word
-checkbox content control's tracked toggle (\u2610\u2194\u2612): metadata comes from the
-inner <w:ins> (the new glyph); reject restores the prior glyph and flips
-the w14:checked attribute back. Structural inserts/deletes of a checkbox
-(Word emits <w:customXmlDel/InsRangeStart/End> around the SDT) round-trip
-through the XmlNode tree but aren't yet enumerated as a dedicated kind.
+Output: a text table, ONE LOGICAL CHANGE per line \u2014
+
+  rev0  replace  p7   "Net 90 from the Company" \u2192 "Net 30 from the Company"
+  tc4   format   p22  spacing.line \u2192360
+  tc7   delete   p27  "Personal Guarantee."
+
+The leftmost token is the handle you pass to \`accept\`/\`reject --at\` (repeatable,
+e.g. \`--at rev0 --at tc4\`). A del+ins REPLACE pair on the same paragraph is
+collapsed onto ONE line under its shared revN handle, so accepting/rejecting the
+whole logical change is a single call \u2014 addressing the two tcN halves separately
+forces a re-list, because tcN ids renumber after each accept. All --at targets in
+one call resolve against the pre-mutation tree, so the renumbering never bites a
+batch.
+
+--json gives 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 granular
+handle; paired halves additionally carry "group": "revN". kind is one of: "ins",
+"del", "moveFrom", "moveTo", "sectPrChange", "pPrChange", "rowIns", "rowDel",
+"cellIns", "cellDel", "tblGridChange", "tblPrChange", "tcPrChange",
+"checkboxToggle". Paragraph-mark entries have kind "ins"/"del" with text "" \u2014
+their blockId is the owning paragraph's pN. Table-structural entries
+(rowIns/rowDel/cellIns/cellDel and the property revisions
+tblGridChange/tblPrChange/tcPrChange) have text "" and blockId set to the owning
+table's tN. checkboxToggle entries surface a Word checkbox content control's
+tracked toggle (\u2610\u2194\u2612): metadata comes from the inner <w:ins> (the new glyph);
+reject restores the prior glyph and flips the w14:checked attribute back.
+Structural inserts/deletes of a checkbox (Word emits
+<w:customXmlDel/InsRangeStart/End> around the SDT) round-trip through the
+XmlNode tree but aren't yet enumerated as a dedicated kind.
 
 Property revisions (kind="sectPrChange" or "pPrChange") additionally include
 { prior, current } objects from before and after the tracked edit, so agents
@@ -95398,19 +96920,17 @@ style/alignment/spacing/indent.
 
 Examples:
   docx track-changes list doc.docx
-  docx track-changes list doc.docx | jq '.[] | select(.kind == "del")'
-  docx track-changes list doc.docx | jq '.[] | select(.kind | test("move"))'
-  docx track-changes list doc.docx | jq '.[] | select(.kind == "sectPrChange") | .prior, .current'
-  docx track-changes list doc.docx | jq '.[] | select(.kind == "pPrChange") | .prior, .current'
+  docx track-changes accept doc.docx --at rev0 --at tc4
+  docx track-changes list doc.docx --json | jq '.[] | select(.kind == "del")'
+  docx track-changes list doc.docx --json | jq '.[] | select(.kind | test("move"))'
+  docx track-changes list doc.docx --json | jq '.[] | select(.kind == "pPrChange") | .prior, .current'
 `;
 var init_list8 = __esm(() => {
-  init_core2();
-  init_track_changes();
   init_respond();
-  init_groups();
+  init_list_view();
 });
 
-// src/cli/track-changes/apply.ts
+// src/cli/track-changes/run-apply.ts
 async function runApply(args, verb, help) {
   const parsed = await tryParseArgs(args, {
     at: { type: "string", multiple: true },
@@ -95472,6 +96992,11 @@ async function runApply(args, verb, help) {
       path: outputPath ?? path2,
       applied
     });
+    if (!all2 && !parsed.values.verbose) {
+      const remaining = await remainingTrackedChangesBlock(outputPath ?? path2, verb);
+      if (remaining)
+        await writeStdout(remaining);
+    }
     return EXIT2.OK;
   } catch (error) {
     if (error instanceof TrackedChangeNotFoundError) {
@@ -95480,26 +97005,27 @@ async function runApply(args, verb, help) {
     throw error;
   }
 }
-var init_apply2 = __esm(() => {
+var init_run_apply = __esm(() => {
   init_track_changes();
   init_respond();
   init_groups();
+  init_list_view();
 });
 
 // src/cli/track-changes/accept.ts
 var exports_accept = {};
 __export(exports_accept, {
-  run: () => run50
+  run: () => run53
 });
-async function run50(args) {
-  return runApply(args, "accept", HELP46);
+async function run53(args) {
+  return runApply(args, "accept", HELP49);
 }
-var AT_FORMS14, HELP46;
+var AT_FORMS14, HELP49;
 var init_accept = __esm(() => {
   init_core2();
-  init_apply2();
+  init_run_apply();
   AT_FORMS14 = describeForms(["trackedChange"], "                    ");
-  HELP46 = `docx track-changes accept \u2014 accept tracked changes (incorporate into the doc)
+  HELP49 = `docx track-changes accept \u2014 accept tracked changes (incorporate into the doc)
 
 Usage:
   docx track-changes accept FILE --at tcN [options]
@@ -95560,17 +97086,17 @@ Examples:
 // src/cli/track-changes/reject.ts
 var exports_reject = {};
 __export(exports_reject, {
-  run: () => run51
+  run: () => run54
 });
-async function run51(args) {
-  return runApply(args, "reject", HELP47);
+async function run54(args) {
+  return runApply(args, "reject", HELP50);
 }
-var AT_FORMS15, HELP47;
+var AT_FORMS15, HELP50;
 var init_reject = __esm(() => {
   init_core2();
-  init_apply2();
+  init_run_apply();
   AT_FORMS15 = describeForms(["trackedChange"], "                    ");
-  HELP47 = `docx track-changes reject \u2014 reject tracked changes (revert to pre-change state)
+  HELP50 = `docx track-changes reject \u2014 reject tracked changes (revert to pre-change state)
 
 Usage:
   docx track-changes reject FILE --at tcN [options]
@@ -95636,19 +97162,157 @@ Examples:
 `;
 });
 
+// src/cli/track-changes/apply.ts
+var exports_apply = {};
+__export(exports_apply, {
+  run: () => run55
+});
+async function run55(args) {
+  const parsed = await tryParseArgs(args, {
+    accept: { type: "string", multiple: true },
+    reject: { type: "string", multiple: true },
+    ...SAVE_FLAGS
+  }, HELP51);
+  if (typeof parsed === "number")
+    return parsed;
+  if (parsed.values.help) {
+    await writeStdout(HELP51);
+    return EXIT2.OK;
+  }
+  setVerboseAck(Boolean(parsed.values.verbose));
+  const path2 = parsed.positionals[0];
+  if (!path2)
+    return fail("USAGE", "Missing FILE argument", HELP51);
+  const acceptRaw = parsed.values.accept ?? [];
+  const rejectRaw = parsed.values.reject ?? [];
+  if (acceptRaw.length === 0 && rejectRaw.length === 0) {
+    return fail("USAGE", "Specify --accept and/or --reject (handle)", HELP51);
+  }
+  const document4 = await openOrFail(path2);
+  if (typeof document4 === "number")
+    return document4;
+  const trackChanges = new TrackChanges(document4);
+  const groups = revisionGroups(trackChanges.list());
+  let accepts;
+  let rejects;
+  try {
+    accepts = expandRevisionTargets(acceptRaw, groups);
+    rejects = expandRevisionTargets(rejectRaw, groups);
+  } 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 rejectSet = new Set(rejects);
+  const conflict = accepts.find((id) => rejectSet.has(id));
+  if (conflict) {
+    return fail("USAGE", `${conflict} is named in both --accept and --reject`, HELP51);
+  }
+  const outputPath = parsed.values.output;
+  try {
+    if (parsed.values["dry-run"]) {
+      const previewApplied = [
+        ...trackChanges.preview(accepts, "accept"),
+        ...trackChanges.preview(rejects, "reject")
+      ].sort((a2, b) => trackedChangeIndex2(a2.id) - trackedChangeIndex2(b.id));
+      await respond({
+        operation: "track-changes.apply",
+        dryRun: true,
+        path: path2,
+        ...outputPath ? { output: outputPath } : {},
+        applied: previewApplied
+      });
+      return EXIT2.OK;
+    }
+    const applied = trackChanges.apply(accepts, rejects);
+    await document4.save(outputPath);
+    await respondAck({
+      ok: true,
+      operation: "track-changes.apply",
+      path: outputPath ?? path2,
+      applied
+    });
+    if (!parsed.values.verbose) {
+      const remaining = await remainingTrackedChangesBlock(outputPath ?? path2, "apply");
+      if (remaining)
+        await writeStdout(remaining);
+    }
+    return EXIT2.OK;
+  } catch (error) {
+    if (error instanceof TrackedChangeNotFoundError) {
+      return fail("TRACKED_CHANGE_NOT_FOUND", error.message, "Run 'docx track-changes list FILE' to see available handles.");
+    }
+    throw error;
+  }
+}
+function trackedChangeIndex2(id) {
+  const match = id.match(/^tc(\d+)$/);
+  return match?.[1] ? Number(match[1]) : 0;
+}
+var HELP51 = `docx track-changes apply \u2014 finalize: accept AND reject in one atomic call
+
+Usage:
+  docx track-changes apply FILE (--accept H ... | --reject H ...) [options]
+
+A document review ends in a finalize: accept the changes you want, reject the
+rest. Doing that as separate \`accept\` and \`reject\` calls is a trap \u2014 tcN/revN
+ids renumber after every accept/reject, so the SECOND command addresses a
+moved target ("tc5 not found", or worse, silently the wrong change). \`apply\`
+takes BOTH decisions at once and resolves EVERY handle against the original
+pre-mutation tree, so nothing renumbers mid-operation and the file is never
+left half-finalized (there is no undo).
+
+Handles are the same ones \`track-changes list\` prints: a tcN, or a revN that
+covers both halves of a del+ins replace pair. Both flags repeat.
+
+Targets (at least one required):
+  --accept H        A handle (tcN or revN) to accept. Repeat for several
+                    (--accept rev0 --accept rev1 --accept tc4).
+  --reject H        A handle (tcN or revN) to reject. Repeat for several.
+
+A handle may not appear in both lists. Unknown handles error before anything is
+written. Leftover changes you name in neither list stay tracked (apply finalizes
+only what you address); the confirmation re-lists them so you can see what's left.
+
+Options:
+  -o, --output PATH Write to PATH instead of overwriting FILE
+  --dry-run         Print what would change; do not write the file
+  -v, --verbose     Print the success ack JSON (default: a one-line confirmation)
+  -h, --help        Show this help
+
+Output:
+  Prints a one-line confirmation on success (exit 0); when changes remain it
+  also re-lists them with their renumbered handles. --verbose prints
+  {ok:true, operation, path, applied}. --dry-run previews. Errors print
+  {code, error, hint?} with a nonzero exit. Discover handles with
+  \`docx track-changes list FILE\`.
+
+Examples:
+  docx track-changes apply doc.docx --accept rev0 --accept rev1 --accept tc4 \\
+                                    --reject rev2 --reject tc7
+  docx track-changes apply doc.docx --reject rev0 --dry-run
+`;
+var init_apply2 = __esm(() => {
+  init_track_changes();
+  init_respond();
+  init_groups();
+  init_list_view();
+});
+
 // src/cli/track-changes/toggle.tsx
 var exports_toggle = {};
 __export(exports_toggle, {
-  run: () => run52
+  run: () => run56
 });
-async function run52(args) {
+async function run56(args) {
   const parsed = await tryParseArgs(args, {
     ...SAVE_FLAGS
-  }, HELP48);
+  }, HELP52);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP48);
+    await writeStdout(HELP52);
     return EXIT2.OK;
   }
   setVerboseAck(Boolean(parsed.values.verbose));
@@ -95657,10 +97321,10 @@ async function run52(args) {
   const mode = modeFirst ? first : second;
   const path2 = modeFirst ? second : first;
   if (mode !== "on" && mode !== "off") {
-    return fail("USAGE", `Expected "on" or "off" (e.g. \`docx track-changes on FILE\`), got: ${parsed.positionals.join(" ") || "<nothing>"}`, HELP48);
+    return fail("USAGE", `Expected "on" or "off" (e.g. \`docx track-changes on FILE\`), got: ${parsed.positionals.join(" ") || "<nothing>"}`, HELP52);
   }
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP48);
+    return fail("USAGE", "Missing FILE argument", HELP52);
   const document4 = await openOrFail(path2);
   if (typeof document4 === "number")
     return document4;
@@ -95690,7 +97354,7 @@ async function run52(args) {
   });
   return EXIT2.OK;
 }
-var HELP48 = `docx track-changes \u2014 toggle the document's tracked-changes mode
+var HELP52 = `docx track-changes \u2014 toggle the document's tracked-changes mode
 
 Usage:
   docx track-changes on|off FILE [options]
@@ -95728,16 +97392,16 @@ var init_toggle2 = __esm(() => {
 // src/cli/track-changes/index.ts
 var exports_track_changes = {};
 __export(exports_track_changes, {
-  run: () => run53
+  run: () => run57
 });
-async function run53(args) {
+async function run57(args) {
   const first = args[0];
   if (first === "--help" || first === "-h" || first === "help") {
-    await writeStdout(HELP49);
+    await writeStdout(HELP53);
     return 0;
   }
   if (!first) {
-    return fail("USAGE", "Missing arguments", HELP49);
+    return fail("USAGE", "Missing arguments", HELP53);
   }
   if (first === "list") {
     const module_2 = await Promise.resolve().then(() => (init_list8(), exports_list5));
@@ -95751,16 +97415,21 @@ async function run53(args) {
     const module_2 = await Promise.resolve().then(() => (init_reject(), exports_reject));
     return module_2.run(args.slice(1));
   }
+  if (first === "apply") {
+    const module_2 = await Promise.resolve().then(() => (init_apply2(), exports_apply));
+    return module_2.run(args.slice(1));
+  }
   const module_ = await Promise.resolve().then(() => (init_toggle2(), exports_toggle));
   return module_.run(args);
 }
-var HELP49 = `docx track-changes \u2014 manage tracked-changes
+var HELP53 = `docx track-changes \u2014 manage tracked-changes
 
 Usage:
   docx track-changes on|off FILE [options]
   docx track-changes list FILE [options]
   docx track-changes accept FILE (--at tcN | --all) [options]
   docx track-changes reject FILE (--at tcN | --all) [options]
+  docx track-changes apply  FILE (--accept H ... | --reject H ...) [options]
 
 Verbs:
   on        Set <w:trackChanges/> in word/settings.xml
@@ -95775,9 +97444,14 @@ Verbs:
             paragraph-mark ins the entire paragraph is removed); del/moveFrom
             unwrap (with <w:delText> \u2192 <w:t> rename); sectPrChange restores
             its snapshot
+  apply     Finalize: accept AND reject in ONE atomic call, every handle
+            resolved against the original tree \u2014 the safe way to apply a
+            review, since separate accept/reject calls renumber ids between
+            them
 
 Exact-change addressing is always --at tcN (repeatable); --all targets every
-change. Discover ids with "docx track-changes list FILE".
+change; \`apply\` takes --accept/--reject handle lists. Discover ids with
+"docx track-changes list FILE".
 
 When tracking is on, the SUBSEQUENT insert/edit/delete/replace commands emit
 <w:ins>/<w:del> markers (attributed via --author or $DOCX_AUTHOR on those
@@ -95894,29 +97568,29 @@ var init_count = __esm(() => {
 // src/cli/wc/index.ts
 var exports_wc = {};
 __export(exports_wc, {
-  run: () => run54
+  run: () => run58
 });
-async function run54(args) {
+async function run58(args) {
   const parsed = await tryParseArgs(args, {
     accepted: { type: "boolean" },
     baseline: { type: "boolean" },
     current: { type: "boolean" },
     json: { type: "boolean" },
     help: { type: "boolean", short: "h" }
-  }, HELP50);
+  }, HELP54);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP50);
+    await writeStdout(HELP54);
     return EXIT2.OK;
   }
   const path2 = parsed.positionals[0];
   const locatorInput = parsed.positionals[1];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP50);
+    return fail("USAGE", "Missing FILE argument", HELP54);
   const view = resolveView(parsed.values);
   if (!view) {
-    return fail("USAGE", "--accepted, --baseline, and --current are mutually exclusive", HELP50);
+    return fail("USAGE", "--accepted, --baseline, and --current are mutually exclusive", HELP54);
   }
   const json2 = Boolean(parsed.values.json);
   const pickText = paragraphTextFor(view);
@@ -96094,13 +97768,13 @@ function paragraphTextFor(view) {
     return paragraphTextBaseline;
   return paragraphText2;
 }
-var HELP50;
+var HELP54;
 var init_wc = __esm(() => {
   init_core2();
   init_parse_helpers();
   init_respond();
   init_count();
-  HELP50 = `docx wc \u2014 count words in a document or a locator-addressed slice
+  HELP54 = `docx wc \u2014 count words in a document or a locator-addressed slice
 
 Usage:
   docx wc FILE [LOCATOR] [options]
@@ -96164,7 +97838,7 @@ Examples:
 // package.json
 var package_default = {
   name: "bun-docx",
-  version: "0.16.0",
+  version: "0.18.0",
   description: "CLI for AI agents (Claude, Codex) to read, edit, and comment on .docx files with full format fidelity.",
   keywords: [
     "docx",
@@ -96272,6 +97946,7 @@ Commands (each one-liner names capabilities you'd otherwise miss; see <command>
   images    \u2026     Add (--caption "Figure 1: \u2026" for a captioned figure), extract, replace, delete, list images
   hyperlinks \u2026    Add, list, replace, delete hyperlinks (add uses --url; replace uses --with)
   tables    \u2026     Restructure tables \u2014 insert/delete rows & columns, merge/unmerge, set widths, borders
+  lists     FILE  Renumber a numbered list \u2014 "lists set --at pN --start 5" / "--format upper-roman" / "--restart" / "--continue"
   track-changes \u2026  Toggle (on|off FILE); list / accept / reject revisions; "read" shows them as CriticMarkup
   info      \u2026     Reference material, no FILE needed (schema for read --ast, locator grammar)
 
@@ -96332,6 +98007,7 @@ var COMMANDS = {
   images: () => Promise.resolve().then(() => (init_images(), exports_images)),
   info: () => Promise.resolve().then(() => (init_info(), exports_info)),
   insert: () => Promise.resolve().then(() => (init_insert2(), exports_insert)),
+  lists: () => Promise.resolve().then(() => (init_lists2(), exports_lists)),
   outline: () => Promise.resolve().then(() => (init_outline(), exports_outline)),
   read: () => Promise.resolve().then(() => (init_read3(), exports_read)),
   render: () => Promise.resolve().then(() => (init_render2(), exports_render)),