bun-docx 0.17.0 → 0.19.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",
@@ -21607,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);
@@ -22380,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;
   }
@@ -22692,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 = [];
@@ -22711,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++;
   }
@@ -22721,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;
 }
@@ -22854,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");
@@ -22891,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();
@@ -22902,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",
@@ -22924,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
@@ -23731,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) {
@@ -72485,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");
@@ -72515,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, {
@@ -72566,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)
@@ -72600,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",
@@ -72644,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
@@ -73741,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;
@@ -82082,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();
@@ -89569,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
@@ -89642,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[];
 };
 
@@ -89650,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 = {
@@ -89674,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 = {
@@ -90042,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"] },
@@ -90236,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: {
@@ -90254,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)"
@@ -90264,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" }
               }
             }
           }
@@ -90539,15 +91030,190 @@ var init_locators2 = __esm(() => {
   ];
 });
 
+// src/cli/info/skill.ts
+var exports_skill = {};
+__export(exports_skill, {
+  run: () => run33
+});
+function renderMarkdown() {
+  return `---
+name: ${NAME}
+description: ${JSON.stringify(DESCRIPTION)}
+---
+
+${BODY}`;
+}
+async function run33(args) {
+  const parsed = await tryParseArgs(args, {
+    json: { type: "boolean" },
+    help: { type: "boolean", short: "h" }
+  }, HELP29);
+  if (typeof parsed === "number")
+    return parsed;
+  if (parsed.values.help) {
+    await writeStdout(HELP29);
+    return EXIT2.OK;
+  }
+  if (parsed.values.json) {
+    await writeStdout(`${JSON.stringify({ name: NAME, description: DESCRIPTION, shortDescription: SHORT_DESCRIPTION, body: BODY }, null, 2)}
+`);
+    return EXIT2.OK;
+  }
+  await writeStdout(renderMarkdown());
+  return EXIT2.OK;
+}
+var HELP29 = `docx info skill \u2014 print the canonical Agent Skill (SKILL.md)
+
+The binary is the source of truth for the skill. Regenerate the committed copy with:
+  docx info skill > skills/docx-cli/SKILL.md
+A CI drift test fails if the committed SKILL.md no longer matches this output.
+
+Usage:
+  docx info skill [options]
+
+Options:
+  --json       Emit { name, description, shortDescription, body } as JSON
+  -h, --help   Show this help
+
+Examples:
+  docx info skill
+  docx info skill > skills/docx-cli/SKILL.md
+  docx info skill --json | jq -r '.description'
+`, NAME = "docx-cli", DESCRIPTION, SHORT_DESCRIPTION = "Read, edit, redline, and comment on Microsoft Word .docx files from the command line \u2014 built for AI agents.", BODY = `# docx-cli
+
+\`docx\` is a command-line tool for reading, editing, redlining, and commenting on
+Microsoft Word \`.docx\` files. It edits the underlying OOXML **in place** (it never
+rebuilds the document from a lossy view), addresses everything with **stable
+locators**, and signals success through an **exit code** plus a one-line
+confirmation \u2014 so even small, cheap models can drive it reliably.
+
+## 0. Make sure the binary is on PATH
+
+Run \`docx --version\`. If you get "command not found", install it:
+
+\`\`\`sh
+curl -fsSL https://raw.githubusercontent.com/kklimuk/docx-cli/main/install.sh | sh
+\`\`\`
+
+Or, from this skill folder, run \`bash scripts/bootstrap.sh\` \u2014 it checks the
+installed version against the latest release and self-updates. Every verb works
+against the \`.docx\` zip directly; only \`docx render\` needs Word (macOS/Windows)
+or LibreOffice installed.
+
+## 1. The contract is \`--help\` / \`docx info\` \u2014 start there
+
+The help text is authoritative and versioned with the binary. This skill is thin
+on purpose and defers to it. Before doing anything, run (none of these need a FILE):
+
+\`\`\`sh
+docx --help              # every command + a one-line capability hint each
+docx info locators       # the addressing grammar \u2014 READ THIS, it is the backbone
+docx info schema         # the JSON-AST shape that "docx read --ast" emits
+\`\`\`
+
+Then \`docx <command> --help\` for any verb before you use it.
+
+## 2. Locators \u2014 how you address things
+
+- \`pN\` paragraph, \`tN\` table, \`sN\` section; \`p3:5-20\` = characters 5..19 of \`p3\`;
+  \`pN-pM\` a block range; \`tN:rRcC\` a table cell.
+- Entities: \`cN\` comment, \`imgN\` image, \`linkN\` hyperlink, \`fnN\`/\`enN\`
+  foot/endnote, \`tcN\` tracked change, \`eqN\` equation.
+- Get them from \`docx read FILE\` (locators ride the Markdown as \`<!-- pN -->\`
+  comments) or \`docx read FILE --ast\` (lossless JSON).
+- **Ids are positional and SHIFT after structural edits.** Re-read between
+  mutations \u2014 OR apply many changes from ONE read with \`--batch\` (below).
+- Pass a locator with \`--at\` (edit / delete / comments / footnotes / images /
+  hyperlinks / tables / track-changes), \`--after\`/\`--before\` (insert), or
+  \`--from\`/\`--to\` (read a slice).
+- Don't hand-count character offsets: \`docx find FILE "phrase"\` returns the exact
+  span locator (e.g. \`p3:5-20\`) to paste into \`--at\`.
+
+## 3. Golden workflows
+
+### Fill out a form or contract (keeps formatting)
+\`docx replace\` swaps only the text and preserves the run's bold/font and any tab
+stops \u2014 so it fills bold, tabbed template lines without rebuilding runs.
+\`\`\`sh
+docx read contract.docx                                  # see content + locators
+docx replace contract.docx "[Client Name]" "Acme, Inc."  # one field
+docx replace contract.docx --batch fills.jsonl           # many fields, one read/write
+\`\`\`
+
+### Redline with tracked changes
+\`\`\`sh
+docx track-changes on contract.docx       # turn tracking on (doc-level)
+docx replace contract.docx "Net 90" "Net 30"   # now auto-emits <w:ins>/<w:del>
+docx edit --at p12:0-40 contract.docx --text "\u2026" --track   # or redline one edit
+docx track-changes list contract.docx     # the tcN handles
+docx read contract.docx --current         # view redlines as CriticMarkup
+docx track-changes accept contract.docx --at tc3   # or --all / reject
+\`\`\`
+
+### Comment on clauses
+\`\`\`sh
+docx comments add contract.docx --anchor "limitation of liability" --text "Cap is too low."
+docx comments list contract.docx
+docx comments reply contract.docx --at c0 --text "Agreed, raising to \\$5M."
+docx comments resolve contract.docx --at c0
+\`\`\`
+
+### Read / extract
+\`\`\`sh
+docx read FILE            # Markdown (default; tracked changes shown accepted-clean)
+docx read FILE --ast      # lossless JSON AST
+docx wc FILE              # word count (whole doc or a slice)
+docx outline FILE         # headings as a locator tree
+\`\`\`
+
+### Build from scratch / verify layout
+\`\`\`sh
+docx create out.docx --from draft.md      # GFM + math + CriticMarkup + inline HTML
+docx render FILE --out pages/             # PNG per page \u2014 only when LAYOUT is the question
+\`\`\`
+
+## 4. Apply many changes from one read \u2014 \`--batch\`
+
+\`edit\`, \`insert\`, \`replace\`, \`delete\`, and the \`comments\` verbs take
+\`--batch FILE.jsonl\` (one JSON change per line; \`-\` reads stdin). Every locator
+in the batch addresses the document **as read**, so ids stay valid across the whole
+batch \u2014 one read, one write, no re-reading between changes. Keys mirror the
+command's flags. This is the right tool for filling a form or applying a review.
+
+## 5. Output & safety contract
+
+- **Exit code is the success signal:** \`0\` ok, \`1\` error, \`2\` usage, \`3\`
+  not-found. Every command also prints a one-line text confirmation \u2014 you never
+  have to re-read just to learn whether a mutation landed.
+- Mutators overwrite \`FILE\` **in place** (git is your history). \`-o/--output PATH\`
+  writes a copy instead; \`--dry-run\` previews without writing.
+- A command that mints a new handle (\`comments add\`\u2192\`cN\`, \`insert\`\u2192\`pN\`,
+  \`footnotes add\`\u2192\`fnN\`, \u2026) prints the bare locator(s), one per line.
+- Re-read after structural edits (ids shift), or batch from one read.
+- Need exact literal text in (a URL, prose GFM would mangle)? \`insert\` and
+  \`create\` take \`--text-file PATH\` (\`-\` = stdin): every character lands verbatim,
+  each newline a new paragraph. No escaping burden.
+
+## 6. Going deeper
+
+- \`references/commands.md\` \u2014 the full command surface at a glance.
+- \`references/troubleshooting.md\` \u2014 install, PATH, render runtime, common errors.
+- Or just run \`docx <command> --help\` \u2014 the authoritative, versioned contract.
+`;
+var init_skill = __esm(() => {
+  init_respond();
+  DESCRIPTION = "Read, edit, redline, comment on, and create Microsoft Word .docx files. " + "Use to fill out or edit a Word doc, redline a contract with tracked changes, " + "add/resolve comments, replace text keeping its formatting, restyle headings/fonts, " + "edit tables, or read/extract a .docx as Markdown or text. Also BUILD a new .docx \u2014 " + "from Markdown or programmatically (code that outputs a Word report with headings, " + "tables, images). Not for PDF, Google Docs, Excel, PowerPoint, or .doc.";
+});
+
 // src/cli/info/index.ts
 var exports_info = {};
 __export(exports_info, {
-  run: () => run33
+  run: () => run34
 });
-async function run33(args) {
+async function run34(args) {
   const topic = args[0];
   if (!topic || topic === "--help" || topic === "-h" || topic === "help") {
-    await writeStdout(HELP29);
+    await writeStdout(HELP30);
     return topic ? 0 : 2;
   }
   const loader = SUBCOMMANDS8[topic];
@@ -90557,7 +91223,7 @@ async function run33(args) {
   const module_ = await loader();
   return module_.run(args.slice(1));
 }
-var SUBCOMMANDS8, HELP29 = `docx info \u2014 print reference material about the CLI
+var SUBCOMMANDS8, HELP30 = `docx info \u2014 print reference material about the CLI
 
 Usage:
   docx info <topic> [options]
@@ -90565,6 +91231,7 @@ Usage:
 Topics:
   schema    Dump AST JSON Schema (or TS source via --ts)
   locators  Dump locator grammar reference
+  skill     Print the canonical Agent Skill (SKILL.md)
 
 Run "docx info <topic> --help" for topic-specific help.
 `;
@@ -90572,7 +91239,218 @@ var init_info = __esm(() => {
   init_respond();
   SUBCOMMANDS8 = {
     schema: () => Promise.resolve().then(() => (init_schema(), exports_schema)),
-    locators: () => Promise.resolve().then(() => (init_locators2(), exports_locators))
+    locators: () => Promise.resolve().then(() => (init_locators2(), exports_locators)),
+    skill: () => Promise.resolve().then(() => (init_skill(), exports_skill))
+  };
+});
+
+// src/cli/lists/set.ts
+var exports_set = {};
+__export(exports_set, {
+  run: () => run35
+});
+async function run35(args) {
+  const parsed = await tryParseArgs(args, {
+    at: { type: "string" },
+    start: { type: "string" },
+    format: { type: "string" },
+    restart: { type: "boolean" },
+    continue: { type: "boolean" },
+    ...SAVE_FLAGS
+  }, HELP31);
+  if (typeof parsed === "number")
+    return parsed;
+  if (parsed.values.help) {
+    await writeStdout(HELP31);
+    return EXIT2.OK;
+  }
+  setVerboseAck(Boolean(parsed.values.verbose));
+  const path2 = parsed.positionals[0];
+  if (!path2)
+    return fail("USAGE", "Missing FILE argument", HELP31);
+  const at = parsed.values.at;
+  if (!at) {
+    return fail("USAGE", "Missing --at LOCATOR (a list item, e.g. p5)", HELP31);
+  }
+  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 HELP31 = `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: () => run36
+});
+async function run36(args) {
+  const verb = args[0];
+  if (!verb || verb === "--help" || verb === "-h" || verb === "help") {
+    await writeStdout(HELP32);
+    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, HELP32 = `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))
   };
 });
 
@@ -90637,23 +91515,23 @@ var init_build = __esm(() => {
 // src/cli/outline/index.ts
 var exports_outline = {};
 __export(exports_outline, {
-  run: () => run34
+  run: () => run37
 });
-async function run34(args) {
+async function run37(args) {
   const parsed = await tryParseArgs(args, {
     "style-prefix": { type: "string" },
     json: { type: "boolean" },
     help: { type: "boolean", short: "h" }
-  }, HELP30);
+  }, HELP33);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP30);
+    await writeStdout(HELP33);
     return EXIT2.OK;
   }
   const path2 = parsed.positionals[0];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP30);
+    return fail("USAGE", "Missing FILE argument", HELP33);
   const stylePrefix = parsed.values["style-prefix"] ?? "Heading";
   if (stylePrefix.length === 0) {
     return fail("USAGE", "--style-prefix cannot be empty");
@@ -90681,7 +91559,7 @@ function renderOutlineText(entries, depth = 0) {
   }
   return lines;
 }
-var HELP30 = `docx outline \u2014 list headings as a hierarchical tree
+var HELP33 = `docx outline \u2014 list headings as a hierarchical tree
 
 Usage:
   docx outline FILE [options]
@@ -90739,7 +91617,7 @@ function emuToInches(emu) {
 function deviation(value, def) {
   return value !== undefined && value !== def ? value : undefined;
 }
-function renderMarkdown(doc, options = {}) {
+function renderMarkdown2(doc, options = {}) {
   const blocks = sliceBlocks(doc.blocks, options.from, options.to);
   const dominant = detectFormatBaseline(blocks);
   const baseline = {
@@ -90761,6 +91639,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: [],
@@ -90847,17 +91727,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 run38 of paragraph2.runs) {
+      if (run38.type !== "text")
         continue;
-      const length = run35.text.length;
+      const length = run38.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 (run38.font)
+        fontChars.set(run38.font, (fontChars.get(run38.font) ?? 0) + length);
+      if (run38.sizeHalfPoints !== undefined) {
+        sizeChars.set(run38.sizeHalfPoints, (sizeChars.get(run38.sizeHalfPoints) ?? 0) + length);
       }
     }
   }
@@ -90891,8 +91771,8 @@ function emptyCommentIndex() {
     orderedIds: []
   };
 }
-function isRunVisible(run35, view) {
-  const kind = run35.trackedChange?.kind;
+function isRunVisible(run38, view) {
+  const kind = run38.trackedChange?.kind;
   if (!kind)
     return true;
   if (view === "accepted" && (kind === "del" || kind === "moveFrom"))
@@ -90907,13 +91787,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((run38, index2) => {
+      const comments = runComments(run38);
       if (!comments)
         return;
-      if (run35.type === "text" && !isRunVisible(run35, view))
+      if (run38.type === "text" && !isRunVisible(run38, view))
         return;
-      const spanContribution = run35.type === "text" ? run35.text : run35.type === "equation" ? run35.text : "";
+      const spanContribution = run38.type === "text" ? run38.text : run38.type === "equation" ? run38.text : "";
       for (const commentId of comments) {
         if (!spanText.has(commentId))
           orderedIds.push(commentId);
@@ -90933,11 +91813,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(run38) {
+  if (run38.type === "text")
+    return run38.comments;
+  if (run38.type === "equation")
+    return run38.comments;
   return;
 }
 function slotKey(paragraphId, runIndex) {
@@ -90946,6 +91826,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;
@@ -91009,7 +91890,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((run38) => run38.type === "tab"))
     return "";
   const cols = ctx.governingColumns.get(paragraph2.id) ?? 1;
   if (cols > 1) {
@@ -91082,25 +91963,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(run38, contentEmu) {
   const pairs = [];
-  if (run35.widthEmu && run35.heightEmu) {
+  if (run38.widthEmu && run38.heightEmu) {
     pairs.push([
       "size",
-      `${emuToInches(run35.widthEmu)}x${emuToInches(run35.heightEmu)}in`
+      `${emuToInches(run38.widthEmu)}x${emuToInches(run38.heightEmu)}in`
     ]);
   }
-  if (run35.floating)
+  if (run38.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 (run38.wrap)
+    pairs.push(["wrap", run38.wrap]);
+  if (run38.align)
+    pairs.push(["align", run38.align]);
+  if (run38.widthEmu && run38.widthEmu > contentEmu)
     pairs.push(["overflow", "yes"]);
   if (pairs.length === 0)
     return "";
-  return ` ${formatNote("image", pairs, [run35.id])}`;
+  return ` ${formatNote("image", pairs, [run38.id])}`;
 }
 function documentGeometry(blocks) {
   const geometric = blocks.filter((block) => block.type === "sectionBreak" && hasGeometry(block));
@@ -91206,14 +92087,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 run38 of paragraph2.runs) {
+        if (run38.type === "text" && run38.trackedChange) {
+          ctx.referencedTrackedChanges.set(run38.trackedChange.id, run38.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((run38) => run38.type === "text" && typeof run38.text === "string").map((run38) => run38.text).join(""));
   const firstId = paragraphs[0]?.id ?? "";
   const lastId = paragraphs[paragraphs.length - 1]?.id ?? firstId;
   const language = codeBlockLanguageFromStyleId(paragraphs[0]?.style) ?? "";
@@ -91227,11 +92108,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)) {
@@ -91296,7 +92180,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(":");
@@ -91306,6 +92191,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);
@@ -91336,10 +92247,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((run38, index2) => {
+    if (run38.type === "text" && !isRunVisible(run38, view))
       return;
-    visibleEntries.push({ run: run35, originalIndex: index2 });
+    visibleEntries.push({ run: run38, originalIndex: index2 });
   });
   let out = "";
   let cursor = 0;
@@ -91350,14 +92261,14 @@ function renderRuns(paragraphId, runs, ctx, mask, baseOffset) {
       cursor++;
       continue;
     }
-    const { run: run35 } = entry;
-    if (run35.type === "text") {
+    const { run: run38 } = entry;
+    if (run38.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(run38, next.run))
           break;
         lookahead2++;
       }
@@ -91378,29 +92289,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 (run38.type === "image") {
+      const alt = sanitizeAltText(run38.alt ?? run38.id);
+      const extension2 = extensionForImageMime(run38.contentType) ?? "bin";
+      out += `![${alt}](${run38.hash}.${extension2})`;
+      out += formatImageNote(run38, ctx.contentWidthEmu);
+    } else if (run38.type === "break") {
+      if (run38.kind === "line")
         out += `
 `;
-    } else if (run35.type === "tab") {
+    } else if (run38.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 (run38.type === "equation") {
+      const body = run38.latex.length > 0 ? run38.latex : run38.text;
+      out += run38.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 (run38.type === "noteRef") {
+      if (run38.kind === "footnote")
+        ctx.referencedFootnoteIds.add(run38.id);
       else
-        ctx.referencedEndnoteIds.add(run35.id);
-      out += `[^${run35.id}]`;
-    } else if (run35.type === "chart") {
-      out += `\`[${run35.kind}]\``;
+        ctx.referencedEndnoteIds.add(run38.id);
+      out += `[^${run38.id}]`;
+    } else if (run38.type === "chart") {
+      out += `\`[${run38.kind}]\``;
     }
     cursor++;
   }
@@ -91434,7 +92345,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((run38) => run38.text).join("");
   if (text6.length === 0)
     return "";
   const first = runs[0];
@@ -91478,33 +92389,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(run38, baseline) {
+  return Boolean(run38.color && !isDefaultColor(run38.color) || run38.colorTheme && !isDefaultThemeColor(run38) || run38.shade || run38.font && run38.font !== baseline.font || run38.sizeHalfPoints !== undefined && run38.sizeHalfPoints !== baseline.sizeHalfPoints || run38.smallCaps || run38.allCaps || run38.underline || run38.vertAlign === "superscript" || run38.vertAlign === "subscript" || run38.highlight);
 }
-function wrapRunFormatting(body, run35, baseline) {
+function wrapRunFormatting(body, run38, 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 (run38.color && !isDefaultColor(run38.color))
+    styles.push(`color:#${run38.color}`);
+  if (run38.shade)
+    styles.push(`background-color:#${run38.shade}`);
+  if (run38.font && run38.font !== baseline.font) {
+    styles.push(`font-family:${cssFontFamily(run38.font)}`);
   }
-  if (run35.sizeHalfPoints !== undefined && run35.sizeHalfPoints !== baseline.sizeHalfPoints) {
-    styles.push(`font-size:${run35.sizeHalfPoints / 2}pt`);
+  if (run38.sizeHalfPoints !== undefined && run38.sizeHalfPoints !== baseline.sizeHalfPoints) {
+    styles.push(`font-size:${run38.sizeHalfPoints / 2}pt`);
   }
-  if (run35.smallCaps)
+  if (run38.smallCaps)
     styles.push("font-variant:small-caps");
-  if (run35.allCaps)
+  if (run38.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 (run38.colorTheme && !isDefaultThemeColor(run38)) {
+    attrs.push(htmlAttr("data-color-theme", run38.colorTheme));
+    if (run38.colorThemeTint) {
+      attrs.push(htmlAttr("data-color-theme-tint", run38.colorThemeTint));
     }
-    if (run35.colorThemeShade) {
-      attrs.push(htmlAttr("data-color-theme-shade", run35.colorThemeShade));
+    if (run38.colorThemeShade) {
+      attrs.push(htmlAttr("data-color-theme-shade", run38.colorThemeShade));
     }
   }
   let out = body;
@@ -91513,18 +92424,18 @@ function wrapRunFormatting(body, run35, baseline) {
     const attrPart = attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
     out = `<span${stylePart}${attrPart}>${out}</span>`;
   }
-  if (run35.underline === "single") {
+  if (run38.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 (run38.underline) {
+    const color2 = run38.underlineColor ? ` ${htmlAttr("data-underline-color", run38.underlineColor)}` : "";
+    out = `<u ${htmlAttr("data-underline", run38.underline)}${color2}>${out}</u>`;
   }
-  if (run35.vertAlign === "superscript")
+  if (run38.vertAlign === "superscript")
     out = `<sup>${out}</sup>`;
-  else if (run35.vertAlign === "subscript")
+  else if (run38.vertAlign === "subscript")
     out = `<sub>${out}</sub>`;
-  if (run35.highlight) {
-    const named = run35.highlight === "yellow" ? "" : ` ${htmlAttr("data-highlight", run35.highlight)}`;
+  if (run38.highlight) {
+    const named = run38.highlight === "yellow" ? "" : ` ${htmlAttr("data-highlight", run38.highlight)}`;
     out = `<mark${named}>${out}</mark>`;
   }
   return out;
@@ -91533,8 +92444,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(run38) {
+  return (run38.colorTheme === "text1" || run38.colorTheme === "dark1") && !run38.colorThemeTint && !run38.colorThemeShade;
 }
 function cssFontFamily(font) {
   return /\s/.test(font) ? `'${font}'` : font;
@@ -91551,19 +92462,19 @@ function applyEscapeMask(text6, mask, offset2) {
 }
 function paragraphContent(runs, view) {
   let content3 = "";
-  for (const run35 of runs) {
-    if (run35.type !== "text")
+  for (const run38 of runs) {
+    if (run38.type !== "text")
       continue;
-    if (run35.runStyle === "Code")
+    if (run38.runStyle === "Code")
       continue;
-    if (!isRunVisible(run35, view))
+    if (!isRunVisible(run38, view))
       continue;
-    content3 += run35.text;
+    content3 += run38.text;
   }
   return content3;
 }
 function hasEquationRun(runs) {
-  return runs.some((run35) => run35.type === "equation");
+  return runs.some((run38) => run38.type === "equation");
 }
 function renderTable(table, ctx) {
   const view = ctx.options.view ?? "accepted";
@@ -91607,10 +92518,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;
@@ -91667,11 +92592,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+$/, "");
 }
@@ -91849,9 +92790,9 @@ var init_markdown3 = __esm(() => {
 // src/cli/read/index.ts
 var exports_read = {};
 __export(exports_read, {
-  run: () => run35
+  run: () => run38
 });
-async function run35(args) {
+async function run38(args) {
   const parsed = await tryParseArgs(args, {
     ast: { type: "boolean" },
     from: { type: "string" },
@@ -91861,16 +92802,16 @@ async function run35(args) {
     current: { type: "boolean" },
     comments: { type: "boolean" },
     help: { type: "boolean", short: "h" }
-  }, HELP31);
+  }, HELP34);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP31);
+    await writeStdout(HELP34);
     return EXIT2.OK;
   }
   const path2 = parsed.positionals[0];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP31);
+    return fail("USAGE", "Missing FILE argument", HELP34);
   const ast = Boolean(parsed.values.ast);
   const from = parsed.values.from;
   const to = parsed.values.to;
@@ -91879,11 +92820,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", HELP34);
   }
   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", HELP34);
   }
   const docView = await openOrFail(path2);
   if (typeof docView === "number")
@@ -91894,7 +92835,7 @@ async function run35(args) {
     return EXIT2.OK;
   }
   try {
-    const rendered = renderMarkdown(docView.body, {
+    const rendered = renderMarkdown2(docView.body, {
       from,
       to,
       view,
@@ -91912,7 +92853,7 @@ async function run35(args) {
     throw err;
   }
 }
-var HELP31 = `docx read \u2014 render document body as Markdown, or print AST as JSON
+var HELP34 = `docx read \u2014 render document body as Markdown, or print AST as JSON
 
 Usage:
   docx read FILE [options]
@@ -92002,20 +92943,20 @@ function parsePagesSpec(spec) {
 // src/cli/render/index.ts
 var exports_render = {};
 __export(exports_render, {
-  run: () => run36
+  run: () => run39
 });
 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 run39(args) {
+  const parsed = await tryParseArgs(args, OPTION_SPEC6, HELP35);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP32);
+    await writeStdout(HELP35);
     return EXIT2.OK;
   }
   const filePath = parsed.positionals[0];
   if (!filePath)
-    return fail("USAGE", "Missing FILE argument", HELP32);
+    return fail("USAGE", "Missing FILE argument", HELP35);
   if (!await Bun.file(filePath).exists()) {
     return fail("FILE_NOT_FOUND", `File not found: ${filePath}`);
   }
@@ -92095,7 +93036,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 HELP35 = `docx render \u2014 render each page of a .docx as a PNG/JPG image
 
 Usage:
   docx render FILE [options]
@@ -92384,9 +93325,9 @@ var init_batch4 = __esm(() => {
 // src/cli/replace/index.ts
 var exports_replace3 = {};
 __export(exports_replace3, {
-  run: () => run37
+  run: () => run40
 });
-async function run37(args) {
+async function run40(args) {
   const parsed = await tryParseArgs(args, {
     batch: { type: "string" },
     at: { type: "string" },
@@ -92400,33 +93341,33 @@ async function run37(args) {
     baseline: { type: "boolean" },
     exact: { type: "boolean" },
     ...SAVE_FLAGS
-  }, HELP33);
+  }, HELP36);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP33);
+    await writeStdout(HELP36);
     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", HELP36);
   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", HELP36);
     }
     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', HELP33);
+      return fail("USAGE", '--at is per-entry in batch mode: put "at" on each JSONL line, not on the command', HELP36);
     }
     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", HELP36);
   if (replacement == null) {
-    return fail("USAGE", "Missing REPLACEMENT argument", HELP33);
+    return fail("USAGE", "Missing REPLACEMENT argument", HELP36);
   }
   const ignoreCase = Boolean(parsed.values["ignore-case"]);
   const useRegex = Boolean(parsed.values.regex);
@@ -92563,7 +93504,7 @@ async function run37(args) {
   }, partialHint);
   return EXIT2.OK;
 }
-var HELP33 = `docx replace \u2014 substitute text spans (sed for docx)
+var HELP36 = `docx replace \u2014 substitute text spans (sed for docx)
 
 Usage:
   docx replace FILE PATTERN REPLACEMENT [options]
@@ -92657,23 +93598,23 @@ var init_replace4 = __esm(() => {
 // src/cli/sections/index.tsx
 var exports_sections = {};
 __export(exports_sections, {
-  run: () => run38
+  run: () => run41
 });
 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 run41(args) {
+  const parsed = await tryParseArgs(args, OPTION_SPEC7, HELP37);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP34);
+    await writeStdout(HELP37);
     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", HELP37);
   const at = parsed.values.at;
   const flags = await parseSectionFlags(parsed.values);
   if (typeof flags === "number")
@@ -92693,22 +93634,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.", HELP37);
   }
   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, HELP37);
     }
     throw error;
   }
   if (locator.kind === "blockRange") {
     if (hasPageGeometry(flags))
-      return fail("USAGE", WRAP_REJECTS_GEOMETRY, HELP34);
+      return fail("USAGE", WRAP_REJECTS_GEOMETRY, HELP37);
     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", HELP37);
     }
     const range = await resolveBlockRangeOrFail(document4, at);
     if (typeof range === "number")
@@ -92720,20 +93661,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", HELP37);
     }
     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, HELP37);
     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", HELP37);
     }
     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`, HELP37);
 }
 async function editSection(document4, blockRef, at, opts) {
   const track = resolveTracked(document4, opts.trackFlag);
@@ -92986,7 +93927,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 HELP37 = `docx sections \u2014 multi-column layout, section breaks & page setup
 
 Usage:
   docx sections FILE --at LOCATOR (--columns N | page setup) [options]
@@ -93479,9 +94420,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 run42 of block.runs) {
+      if (run42.type === "text" && run42.runStyle)
+        used.add(run42.runStyle);
     }
   }
   return used;
@@ -93637,8 +94578,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 run42 of block.runs) {
+      if (run42.type === "text" && run42.runStyle === styleId)
         count++;
     }
   }
@@ -93690,7 +94631,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();
@@ -93804,18 +94745,18 @@ var init_set_default_font = __esm(() => {
 // src/cli/styles/index.ts
 var exports_styles = {};
 __export(exports_styles, {
-  run: () => run39
+  run: () => run42
 });
-async function run39(args) {
+async function run42(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, HELP38);
 }
-var HELP35 = `docx styles \u2014 inspect, edit, and create the styles a document can apply
+var HELP38 = `docx styles \u2014 inspect, edit, and create the styles a document can apply
 
 Usage:
   docx styles FILE [--used] [--at STYLEID] [--json]     # list / describe (read)
@@ -93858,16 +94799,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: () => run43
 });
-async function run40(args) {
+async function run43(args) {
   const parsed = await tryParseArgs(args, {
     at: { type: "string" },
     position: { type: "string" },
@@ -93875,20 +94816,20 @@ async function run40(args) {
     author: { type: "string" },
     track: { type: "boolean" },
     ...SAVE_FLAGS
-  }, HELP36);
+  }, HELP39);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP36);
+    await writeStdout(HELP39);
     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", HELP39);
   const at = parsed.values.at;
   if (!at)
-    return fail("USAGE", "Missing --at tN", HELP36);
+    return fail("USAGE", "Missing --at tN", HELP39);
   const tableId = parseTableAt(at);
   if (!tableId) {
     return fail("INVALID_LOCATOR", `--at must be a table id like t0 (got ${at})`);
@@ -93909,7 +94850,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, HELP39, "--cells");
     if (typeof mangled === "number")
       return mangled;
   }
@@ -94010,7 +94951,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, HELP39;
 var init_insert_row = __esm(() => {
   init_core2();
   init_blocks();
@@ -94021,7 +94962,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
+  HELP39 = `docx tables insert-row \u2014 insert a table row
 
 Usage:
   docx tables insert-row FILE --at tN [options]
@@ -94070,28 +95011,28 @@ Examples:
 // src/cli/tables/delete-row.ts
 var exports_delete_row = {};
 __export(exports_delete_row, {
-  run: () => run41
+  run: () => run44
 });
-async function run41(args) {
+async function run44(args) {
   const parsed = await tryParseArgs(args, {
     at: { type: "string" },
     author: { type: "string" },
     track: { type: "boolean" },
     ...SAVE_FLAGS
-  }, HELP37);
+  }, HELP40);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP37);
+    await writeStdout(HELP40);
     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", HELP40);
   const at = parsed.values.at;
   if (!at)
-    return fail("USAGE", "Missing --at tN:rR", HELP37);
+    return fail("USAGE", "Missing --at tN:rR", HELP40);
   const target = parseRowAt(at);
   if (!target) {
     return fail("INVALID_LOCATOR", `--at must be a row locator like t0:r1 (got ${at})`);
@@ -94158,14 +95099,14 @@ function findVMergeOrphan(grid, rowIndex) {
   }
   return null;
 }
-var AT_FORMS7, HELP37;
+var AT_FORMS7, HELP40;
 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
+  HELP40 = `docx tables delete-row \u2014 delete a table row
 
 Usage:
   docx tables delete-row FILE --at tN:rR [options]
@@ -94201,9 +95142,9 @@ Examples:
 // src/cli/tables/insert-column.tsx
 var exports_insert_column = {};
 __export(exports_insert_column, {
-  run: () => run42
+  run: () => run45
 });
-async function run42(args) {
+async function run45(args) {
   const parsed = await tryParseArgs(args, {
     at: { type: "string" },
     position: { type: "string" },
@@ -94211,20 +95152,20 @@ async function run42(args) {
     author: { type: "string" },
     track: { type: "boolean" },
     ...SAVE_FLAGS
-  }, HELP38);
+  }, HELP41);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP38);
+    await writeStdout(HELP41);
     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", HELP41);
   const at = parsed.values.at;
   if (!at)
-    return fail("USAGE", "Missing --at tN", HELP38);
+    return fail("USAGE", "Missing --at tN", HELP41);
   const tableId = parseTableAt(at);
   if (!tableId) {
     return fail("INVALID_LOCATOR", `--at must be a table id like t0 (got ${at})`);
@@ -94339,14 +95280,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, HELP41;
 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
+  HELP41 = `docx tables insert-column \u2014 insert a table column
 
 Usage:
   docx tables insert-column FILE --at tN [options]
@@ -94384,28 +95325,28 @@ Examples:
 // src/cli/tables/delete-column.ts
 var exports_delete_column = {};
 __export(exports_delete_column, {
-  run: () => run43
+  run: () => run46
 });
-async function run43(args) {
+async function run46(args) {
   const parsed = await tryParseArgs(args, {
     at: { type: "string" },
     author: { type: "string" },
     track: { type: "boolean" },
     ...SAVE_FLAGS
-  }, HELP39);
+  }, HELP42);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP39);
+    await writeStdout(HELP42);
     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", HELP42);
   const at = parsed.values.at;
   if (!at)
-    return fail("USAGE", "Missing --at tN:cC", HELP39);
+    return fail("USAGE", "Missing --at tN:cC", HELP42);
   const target = parseColumnAt(at);
   if (!target) {
     return fail("INVALID_LOCATOR", `--at must be a column locator like t0:c2 (got ${at})`);
@@ -94489,14 +95430,14 @@ function removeGridColumn(tblGrid, col) {
   if (index2 !== -1)
     tblGrid.children.splice(index2, 1);
 }
-var AT_FORMS9, HELP39;
+var AT_FORMS9, HELP42;
 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
+  HELP42 = `docx tables delete-column \u2014 delete a table column
 
 Usage:
   docx tables delete-column FILE --at tN:cC [options]
@@ -94531,36 +95472,36 @@ Examples:
 // src/cli/tables/set-widths.ts
 var exports_set_widths = {};
 __export(exports_set_widths, {
-  run: () => run44
+  run: () => run47
 });
-async function run44(args) {
+async function run47(args) {
   const parsed = await tryParseArgs(args, {
     at: { type: "string" },
     widths: { type: "string" },
     author: { type: "string" },
     track: { type: "boolean" },
     ...SAVE_FLAGS
-  }, HELP40);
+  }, HELP43);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP40);
+    await writeStdout(HELP43);
     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", HELP43);
   const at = parsed.values.at;
   if (!at)
-    return fail("USAGE", "Missing --at tN", HELP40);
+    return fail("USAGE", "Missing --at tN", HELP43);
   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", HELP43);
   const document4 = await openOrFail(path2);
   if (typeof document4 === "number")
     return document4;
@@ -94709,14 +95650,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, HELP43, 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
+  HELP43 = `docx tables set-widths \u2014 set column widths
 
 Usage:
   docx tables set-widths FILE --at tN --widths SPEC [options]
@@ -94785,28 +95726,28 @@ var init_common2 = __esm(() => {
 // src/cli/tables/merge.tsx
 var exports_merge = {};
 __export(exports_merge, {
-  run: () => run45
+  run: () => run48
 });
-async function run45(args) {
+async function run48(args) {
   const parsed = await tryParseArgs(args, {
     at: { type: "string" },
     author: { type: "string" },
     track: { type: "boolean" },
     ...SAVE_FLAGS
-  }, HELP41);
+  }, HELP44);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP41);
+    await writeStdout(HELP44);
     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", HELP44);
   const at = parsed.values.at;
   if (!at)
-    return fail("USAGE", "Missing --at tN:rR1cC1-rR2cC2", HELP41);
+    return fail("USAGE", "Missing --at tN:rR1cC1-rR2cC2", HELP44);
   const region = parseCellRangeAt(at);
   if (!region) {
     return fail("INVALID_LOCATOR", `--at must be a cell-range locator like t0:r0c0-r1c1 (got ${at})`);
@@ -94899,7 +95840,7 @@ function mergeRow(row, c1, c2, width, isTop, vertical) {
   if (vertical && !isTop)
     clearCellContent(anchor.node);
 }
-var AT_FORMS11, HELP41;
+var AT_FORMS11, HELP44;
 var init_merge = __esm(() => {
   init_core2();
   init_locators();
@@ -94907,7 +95848,7 @@ var init_merge = __esm(() => {
   init_respond();
   init_common2();
   AT_FORMS11 = describeForms(["cellRange"], "                     ");
-  HELP41 = `docx tables merge \u2014 merge a rectangular cell region
+  HELP44 = `docx tables merge \u2014 merge a rectangular cell region
 
 Usage:
   docx tables merge FILE --at tN:rR1cC1-rR2cC2 [options]
@@ -94946,28 +95887,28 @@ Examples:
 // src/cli/tables/unmerge.tsx
 var exports_unmerge = {};
 __export(exports_unmerge, {
-  run: () => run46
+  run: () => run49
 });
-async function run46(args) {
+async function run49(args) {
   const parsed = await tryParseArgs(args, {
     at: { type: "string" },
     author: { type: "string" },
     track: { type: "boolean" },
     ...SAVE_FLAGS
-  }, HELP42);
+  }, HELP45);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP42);
+    await writeStdout(HELP45);
     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", HELP45);
   const at = parsed.values.at;
   if (!at)
-    return fail("USAGE", "Missing --at tN:rRcC", HELP42);
+    return fail("USAGE", "Missing --at tN:rRcC", HELP45);
   const target = parseCellAt(at);
   if (!target) {
     return fail("INVALID_LOCATOR", `--at must be a cell locator like t0:r0c0 (got ${at})`);
@@ -95042,7 +95983,7 @@ function verticalSpanRows(grid, row, col, vertical) {
   }
   return rows;
 }
-var AT_FORMS12, HELP42;
+var AT_FORMS12, HELP45;
 var init_unmerge = __esm(() => {
   init_core2();
   init_locators();
@@ -95050,7 +95991,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
+  HELP45 = `docx tables unmerge \u2014 split a merged cell back into individual cells
 
 Usage:
   docx tables unmerge FILE --at tN:rRcC [options]
@@ -95087,9 +96028,9 @@ Examples:
 // src/cli/tables/borders.tsx
 var exports_borders = {};
 __export(exports_borders, {
-  run: () => run47
+  run: () => run50
 });
-async function run47(args) {
+async function run50(args) {
   const parsed = await tryParseArgs(args, {
     at: { type: "string" },
     style: { type: "string" },
@@ -95098,20 +96039,20 @@ async function run47(args) {
     author: { type: "string" },
     track: { type: "boolean" },
     ...SAVE_FLAGS
-  }, HELP43);
+  }, HELP46);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP43);
+    await writeStdout(HELP46);
     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", HELP46);
   const at = parsed.values.at;
   if (!at)
-    return fail("USAGE", "Missing --at tN", HELP43);
+    return fail("USAGE", "Missing --at tN", HELP46);
   const tableId = parseTableAt(at);
   if (!tableId) {
     return fail("INVALID_LOCATOR", `--at must be a table id like t0 (got ${at})`);
@@ -95188,7 +96129,7 @@ function buildBorders(style, sizeEighths, color2) {
     ]
   }, undefined, true, undefined, this);
 }
-var STYLES, AT_FORMS13, HELP43;
+var STYLES, AT_FORMS13, HELP46;
 var init_borders = __esm(() => {
   init_core2();
   init_jsx();
@@ -95199,7 +96140,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
+  HELP46 = `docx tables borders \u2014 set table borders
 
 Usage:
   docx tables borders FILE --at tN [options]
@@ -95236,25 +96177,486 @@ Examples:
 `;
 });
 
+// src/cli/tables/format.tsx
+var exports_format = {};
+__export(exports_format, {
+  run: () => run51
+});
+async function run51(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
+  }, HELP47);
+  if (typeof parsed === "number")
+    return parsed;
+  if (parsed.values.help) {
+    await writeStdout(HELP47);
+    return EXIT2.OK;
+  }
+  setVerboseAck(Boolean(parsed.values.verbose));
+  const path2 = parsed.positionals[0];
+  if (!path2)
+    return fail("USAGE", "Missing FILE argument", HELP47);
+  const at = parsed.values.at;
+  if (!at)
+    return fail("USAGE", "Missing --at LOCATOR", HELP47);
+  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 HELP47 = `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: () => run52
 });
-async function run48(args) {
+async function run52(args) {
   const verb = args[0];
   if (!verb || verb === "--help" || verb === "-h" || verb === "help") {
-    await writeStdout(HELP44);
+    await writeStdout(HELP48);
     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, HELP48 = `docx tables \u2014 restructure & format tables (rows, columns, merges, widths, shading)
 
 Usage:
   docx tables <verb> FILE [options]
@@ -95268,6 +96670,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:
@@ -95280,7 +96685,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)),
@@ -95288,7 +96693,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))
   };
 });
 
@@ -95354,19 +96760,19 @@ var init_groups = __esm(() => {
 function collectTrackedChangeRecords(document4) {
   const byId = new Map;
   for (const paragraph2 of flattenParagraphs(document4.body.blocks)) {
-    for (const run49 of paragraph2.runs) {
-      if (run49.type !== "text" || !run49.trackedChange)
+    for (const run53 of paragraph2.runs) {
+      if (run53.type !== "text" || !run53.trackedChange)
         continue;
-      const change = run49.trackedChange;
+      const change = run53.trackedChange;
       const existing = byId.get(change.id);
       if (existing) {
-        existing.text += run49.text;
+        existing.text += run53.text;
         continue;
       }
       byId.set(change.id, {
         ...change,
         blockId: paragraph2.id,
-        text: run49.text
+        text: run53.text
       });
     }
   }
@@ -95609,22 +97015,22 @@ var init_list_view = __esm(() => {
 // src/cli/track-changes/list.ts
 var exports_list5 = {};
 __export(exports_list5, {
-  run: () => run49
+  run: () => run53
 });
-async function run49(args) {
+async function run53(args) {
   const parsed = await tryParseArgs(args, {
     help: { type: "boolean", short: "h" },
     json: { type: "boolean" }
-  }, HELP45);
+  }, HELP49);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP45);
+    await writeStdout(HELP49);
     return EXIT2.OK;
   }
   const path2 = parsed.positionals[0];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP45);
+    return fail("USAGE", "Missing FILE argument", HELP49);
   const document4 = await openOrFail(path2);
   if (typeof document4 === "number")
     return document4;
@@ -95636,7 +97042,7 @@ async function run49(args) {
   await writeStdout(renderTrackedChangeTable(records));
   return EXIT2.OK;
 }
-var HELP45 = `docx track-changes list \u2014 inventory every revision wrapper
+var HELP49 = `docx track-changes list \u2014 inventory every revision wrapper
 
 Usage:
   docx track-changes list FILE [options]
@@ -95786,17 +97192,17 @@ var init_run_apply = __esm(() => {
 // src/cli/track-changes/accept.ts
 var exports_accept = {};
 __export(exports_accept, {
-  run: () => run50
+  run: () => run54
 });
-async function run50(args) {
-  return runApply(args, "accept", HELP46);
+async function run54(args) {
+  return runApply(args, "accept", HELP50);
 }
-var AT_FORMS14, HELP46;
+var AT_FORMS14, HELP50;
 var init_accept = __esm(() => {
   init_core2();
   init_run_apply();
   AT_FORMS14 = describeForms(["trackedChange"], "                    ");
-  HELP46 = `docx track-changes accept \u2014 accept tracked changes (incorporate into the doc)
+  HELP50 = `docx track-changes accept \u2014 accept tracked changes (incorporate into the doc)
 
 Usage:
   docx track-changes accept FILE --at tcN [options]
@@ -95857,17 +97263,17 @@ Examples:
 // src/cli/track-changes/reject.ts
 var exports_reject = {};
 __export(exports_reject, {
-  run: () => run51
+  run: () => run55
 });
-async function run51(args) {
-  return runApply(args, "reject", HELP47);
+async function run55(args) {
+  return runApply(args, "reject", HELP51);
 }
-var AT_FORMS15, HELP47;
+var AT_FORMS15, HELP51;
 var init_reject = __esm(() => {
   init_core2();
   init_run_apply();
   AT_FORMS15 = describeForms(["trackedChange"], "                    ");
-  HELP47 = `docx track-changes reject \u2014 reject tracked changes (revert to pre-change state)
+  HELP51 = `docx track-changes reject \u2014 reject tracked changes (revert to pre-change state)
 
 Usage:
   docx track-changes reject FILE --at tcN [options]
@@ -95936,28 +97342,28 @@ Examples:
 // src/cli/track-changes/apply.ts
 var exports_apply = {};
 __export(exports_apply, {
-  run: () => run52
+  run: () => run56
 });
-async function run52(args) {
+async function run56(args) {
   const parsed = await tryParseArgs(args, {
     accept: { type: "string", multiple: true },
     reject: { type: "string", multiple: true },
     ...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));
   const path2 = parsed.positionals[0];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP48);
+    return fail("USAGE", "Missing FILE argument", HELP52);
   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)", HELP48);
+    return fail("USAGE", "Specify --accept and/or --reject (handle)", HELP52);
   }
   const document4 = await openOrFail(path2);
   if (typeof document4 === "number")
@@ -95978,7 +97384,7 @@ async function run52(args) {
   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`, HELP48);
+    return fail("USAGE", `${conflict} is named in both --accept and --reject`, HELP52);
   }
   const outputPath = parsed.values.output;
   try {
@@ -96021,7 +97427,7 @@ function trackedChangeIndex2(id) {
   const match = id.match(/^tc(\d+)$/);
   return match?.[1] ? Number(match[1]) : 0;
 }
-var HELP48 = `docx track-changes apply \u2014 finalize: accept AND reject in one atomic call
+var HELP52 = `docx track-changes apply \u2014 finalize: accept AND reject in one atomic call
 
 Usage:
   docx track-changes apply FILE (--accept H ... | --reject H ...) [options]
@@ -96074,16 +97480,16 @@ var init_apply2 = __esm(() => {
 // src/cli/track-changes/toggle.tsx
 var exports_toggle = {};
 __export(exports_toggle, {
-  run: () => run53
+  run: () => run57
 });
-async function run53(args) {
+async function run57(args) {
   const parsed = await tryParseArgs(args, {
     ...SAVE_FLAGS
-  }, HELP49);
+  }, HELP53);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP49);
+    await writeStdout(HELP53);
     return EXIT2.OK;
   }
   setVerboseAck(Boolean(parsed.values.verbose));
@@ -96092,10 +97498,10 @@ async function run53(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>"}`, HELP49);
+    return fail("USAGE", `Expected "on" or "off" (e.g. \`docx track-changes on FILE\`), got: ${parsed.positionals.join(" ") || "<nothing>"}`, HELP53);
   }
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP49);
+    return fail("USAGE", "Missing FILE argument", HELP53);
   const document4 = await openOrFail(path2);
   if (typeof document4 === "number")
     return document4;
@@ -96125,7 +97531,7 @@ async function run53(args) {
   });
   return EXIT2.OK;
 }
-var HELP49 = `docx track-changes \u2014 toggle the document's tracked-changes mode
+var HELP53 = `docx track-changes \u2014 toggle the document's tracked-changes mode
 
 Usage:
   docx track-changes on|off FILE [options]
@@ -96163,16 +97569,16 @@ var init_toggle2 = __esm(() => {
 // src/cli/track-changes/index.ts
 var exports_track_changes = {};
 __export(exports_track_changes, {
-  run: () => run54
+  run: () => run58
 });
-async function run54(args) {
+async function run58(args) {
   const first = args[0];
   if (first === "--help" || first === "-h" || first === "help") {
-    await writeStdout(HELP50);
+    await writeStdout(HELP54);
     return 0;
   }
   if (!first) {
-    return fail("USAGE", "Missing arguments", HELP50);
+    return fail("USAGE", "Missing arguments", HELP54);
   }
   if (first === "list") {
     const module_2 = await Promise.resolve().then(() => (init_list8(), exports_list5));
@@ -96193,7 +97599,7 @@ async function run54(args) {
   const module_ = await Promise.resolve().then(() => (init_toggle2(), exports_toggle));
   return module_.run(args);
 }
-var HELP50 = `docx track-changes \u2014 manage tracked-changes
+var HELP54 = `docx track-changes \u2014 manage tracked-changes
 
 Usage:
   docx track-changes on|off FILE [options]
@@ -96339,29 +97745,29 @@ var init_count = __esm(() => {
 // src/cli/wc/index.ts
 var exports_wc = {};
 __export(exports_wc, {
-  run: () => run55
+  run: () => run59
 });
-async function run55(args) {
+async function run59(args) {
   const parsed = await tryParseArgs(args, {
     accepted: { type: "boolean" },
     baseline: { type: "boolean" },
     current: { type: "boolean" },
     json: { type: "boolean" },
     help: { type: "boolean", short: "h" }
-  }, HELP51);
+  }, HELP55);
   if (typeof parsed === "number")
     return parsed;
   if (parsed.values.help) {
-    await writeStdout(HELP51);
+    await writeStdout(HELP55);
     return EXIT2.OK;
   }
   const path2 = parsed.positionals[0];
   const locatorInput = parsed.positionals[1];
   if (!path2)
-    return fail("USAGE", "Missing FILE argument", HELP51);
+    return fail("USAGE", "Missing FILE argument", HELP55);
   const view = resolveView(parsed.values);
   if (!view) {
-    return fail("USAGE", "--accepted, --baseline, and --current are mutually exclusive", HELP51);
+    return fail("USAGE", "--accepted, --baseline, and --current are mutually exclusive", HELP55);
   }
   const json2 = Boolean(parsed.values.json);
   const pickText = paragraphTextFor(view);
@@ -96539,13 +97945,13 @@ function paragraphTextFor(view) {
     return paragraphTextBaseline;
   return paragraphText2;
 }
-var HELP51;
+var HELP55;
 var init_wc = __esm(() => {
   init_core2();
   init_parse_helpers();
   init_respond();
   init_count();
-  HELP51 = `docx wc \u2014 count words in a document or a locator-addressed slice
+  HELP55 = `docx wc \u2014 count words in a document or a locator-addressed slice
 
 Usage:
   docx wc FILE [LOCATOR] [options]
@@ -96609,8 +98015,8 @@ Examples:
 // package.json
 var package_default = {
   name: "bun-docx",
-  version: "0.17.0",
-  description: "CLI for AI agents (Claude, Codex) to read, edit, and comment on .docx files with full format fidelity.",
+  version: "0.19.0",
+  description: "Read, edit, redline, and comment on Microsoft Word .docx files from the command line \u2014 built for AI agents.",
   keywords: [
     "docx",
     "openxml",
@@ -96620,8 +98026,15 @@ var package_default = {
     "ai",
     "claude",
     "codex",
-    "agentic"
+    "agentic",
+    "agent-skill",
+    "pi-package"
   ],
+  pi: {
+    skills: [
+      "./skills"
+    ]
+  },
   license: "MIT",
   author: "Kirill Klimuk",
   repository: {
@@ -96638,6 +98051,7 @@ var package_default = {
   files: [
     "dist/index.js",
     "dist/pdfium-*.wasm",
+    "skills/",
     "README.md",
     "LICENSE",
     "LGPL-3.0.txt",
@@ -96717,6 +98131,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)
 
@@ -96777,6 +98192,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)),