bun-docx 0.4.0 → 0.6.0

package/dist/index.js

@@ -13762,7 +13762,7 @@ var init_package = __esm(() => {
 
 // src/core/ast/read.ts
 function buildDoc(view, path) {
-  readImageRelationships(view);
+  readRelationships(view);
   const properties = readDocProperties(view);
   const documentRoot = XmlNode2.findRoot(view.documentTree, "w:document");
   if (!documentRoot) {
@@ -13774,12 +13774,23 @@ function buildDoc(view, path) {
   }
   const state = {
     imageIndex: 0,
+    hyperlinkIndex: 0,
     commentAnchors: new Map,
     openComments: new Map
   };
   const blocks = readBlocks(view, body, state);
   const comments = readComments(view, state.commentAnchors);
-  return { schemaVersion: 1, path, properties, blocks, comments };
+  const footnotes = readNotes(view.footnotesTree, "w:footnotes", "w:footnote", "fn");
+  const endnotes = readNotes(view.endnotesTree, "w:endnotes", "w:endnote", "en");
+  return {
+    schemaVersion: 1,
+    path,
+    properties,
+    blocks,
+    comments,
+    footnotes,
+    endnotes
+  };
 }
 function readBlocks(view, body, state) {
   const blocks = [];
@@ -13813,17 +13824,30 @@ function readParagraph(view, node, id, state) {
   if (paragraphProperties) {
     applyParagraphProperties(paragraph, paragraphProperties);
   }
-  const activeComments = new Set;
-  let offset = 0;
-  for (const child of node.children) {
+  const context = {
+    view,
+    blockId: id,
+    paragraph,
+    activeComments: new Set,
+    state,
+    offsetRef: { value: 0 }
+  };
+  walkRunContainer(context, node, undefined, undefined);
+  return paragraph;
+}
+function walkRunContainer(context, container, trackedChange, hyperlink) {
+  for (const child of container.children) {
     if (child.tag === "w:pPr")
       continue;
     if (child.tag === "w:commentRangeStart") {
       const commentId = child.getAttribute("w:id");
       if (commentId) {
         const key = `c${commentId}`;
-        activeComments.add(key);
-        state.openComments.set(key, { blockId: id, offset });
+        context.activeComments.add(key);
+        context.state.openComments.set(key, {
+          blockId: context.blockId,
+          offset: context.offsetRef.value
+        });
       }
       continue;
     }
@@ -13831,26 +13855,48 @@ function readParagraph(view, node, id, state) {
       const commentId = child.getAttribute("w:id");
       if (commentId) {
         const key = `c${commentId}`;
-        activeComments.delete(key);
-        const opened = state.openComments.get(key);
+        context.activeComments.delete(key);
+        const opened = context.state.openComments.get(key);
         if (opened) {
-          state.commentAnchors.set(key, {
+          context.state.commentAnchors.set(key, {
             startBlockId: opened.blockId,
             startOffset: opened.offset,
-            endBlockId: id,
-            endOffset: offset
+            endBlockId: context.blockId,
+            endOffset: context.offsetRef.value
           });
-          state.openComments.delete(key);
+          context.state.openComments.delete(key);
         }
       }
       continue;
     }
     if (child.tag === "w:r") {
-      const run = readRun(view, child, activeComments, undefined, state);
+      const run = readRun(context.view, child, context.activeComments, trackedChange, hyperlink, context.state);
       if (run) {
         if (run.type === "text")
-          offset += run.text.length;
-        paragraph.runs.push(run);
+          context.offsetRef.value += run.text.length;
+        context.paragraph.runs.push(run);
+      }
+      continue;
+    }
+    if (child.tag === "m:oMath") {
+      const text = collectMathText(child);
+      if (text.length > 0) {
+        context.paragraph.runs.push({
+          type: "equation",
+          text,
+          display: false
+        });
+      }
+      continue;
+    }
+    if (child.tag === "m:oMathPara") {
+      const text = collectMathText(child);
+      if (text.length > 0) {
+        context.paragraph.runs.push({
+          type: "equation",
+          text,
+          display: true
+        });
       }
       continue;
     }
@@ -13861,46 +13907,40 @@ function readParagraph(view, node, id, state) {
         date: child.getAttribute("w:date") ?? "",
         revisionId: child.getAttribute("w:id") ?? ""
       };
-      for (const inner of child.children) {
-        if (inner.tag === "w:commentRangeStart") {
-          const commentId = inner.getAttribute("w:id");
-          if (commentId) {
-            const key = `c${commentId}`;
-            activeComments.add(key);
-            state.openComments.set(key, { blockId: id, offset });
-          }
-          continue;
-        }
-        if (inner.tag === "w:commentRangeEnd") {
-          const commentId = inner.getAttribute("w:id");
-          if (commentId) {
-            const key = `c${commentId}`;
-            activeComments.delete(key);
-            const opened = state.openComments.get(key);
-            if (opened) {
-              state.commentAnchors.set(key, {
-                startBlockId: opened.blockId,
-                startOffset: opened.offset,
-                endBlockId: id,
-                endOffset: offset
-              });
-              state.openComments.delete(key);
-            }
-          }
-          continue;
-        }
-        if (inner.tag !== "w:r")
-          continue;
-        const run = readRun(view, inner, activeComments, change, state);
-        if (!run)
-          continue;
-        if (run.type === "text")
-          offset += run.text.length;
-        paragraph.runs.push(run);
-      }
+      walkRunContainer(context, child, change, hyperlink);
+      continue;
+    }
+    if (child.tag === "w:hyperlink") {
+      const link = readHyperlinkProperties(context.view, child, container.children, context.state);
+      walkRunContainer(context, child, trackedChange, link);
     }
   }
-  return paragraph;
+}
+function readHyperlinkProperties(view, node, parent, state) {
+  const id = `link${state.hyperlinkIndex++}`;
+  const link = { id };
+  const relationshipId = node.getAttribute("r:id");
+  if (relationshipId) {
+    const relationship = view.hyperlinksByRelationshipId.get(relationshipId);
+    if (relationship?.url)
+      link.url = relationship.url;
+  }
+  const anchor = node.getAttribute("w:anchor");
+  if (anchor)
+    link.anchor = anchor;
+  const tooltip = node.getAttribute("w:tooltip");
+  if (tooltip)
+    link.tooltip = tooltip;
+  if (!link.url && !link.anchor && !link.tooltip) {
+    state.hyperlinkIndex--;
+    return;
+  }
+  view.hyperlinkById.set(id, {
+    node,
+    parent,
+    ...relationshipId ? { relationshipId } : {}
+  });
+  return link;
 }
 function applyParagraphProperties(paragraph, paragraphProperties) {
   const styleNode = paragraphProperties.findChild("w:pStyle");
@@ -13925,13 +13965,13 @@ function applyParagraphProperties(paragraph, paragraphProperties) {
     paragraph.list = { level, numId: id };
   }
 }
-function readRun(view, node, activeComments, trackedChange, state) {
+function readRun(view, node, activeComments, trackedChange, hyperlink, state) {
   const runProperties = node.findChild("w:rPr");
   for (const child of node.children) {
     if (child.tag === "w:drawing") {
-      const image = readImageFromDrawing(view, child, state);
-      if (image)
-        return image;
+      const drawing = readDrawing(view, child, state);
+      if (drawing)
+        return drawing;
     }
     if (child.tag === "w:br") {
       const kind = child.getAttribute("w:type") ?? "line";
@@ -13940,6 +13980,16 @@ function readRun(view, node, activeComments, trackedChange, state) {
     if (child.tag === "w:tab") {
       return { type: "tab" };
     }
+    if (child.tag === "w:footnoteReference") {
+      const id = child.getAttribute("w:id");
+      if (id)
+        return { type: "footnoteRef", kind: "footnote", id: `fn${id}` };
+    }
+    if (child.tag === "w:endnoteReference") {
+      const id = child.getAttribute("w:id");
+      if (id)
+        return { type: "footnoteRef", kind: "endnote", id: `en${id}` };
+    }
   }
   let combinedText = "";
   for (const child of node.children) {
@@ -13956,8 +14006,33 @@ function readRun(view, node, activeComments, trackedChange, state) {
     run.comments = [...activeComments];
   if (trackedChange)
     run.trackedChange = trackedChange;
+  if (hyperlink)
+    run.hyperlink = hyperlink;
   return run;
 }
+function readDrawing(view, drawing, state) {
+  const image = readImageFromDrawing(view, drawing, state);
+  if (image)
+    return image;
+  if (drawing.findDescendant("c:chart"))
+    return { type: "chart", kind: "chart" };
+  if (drawing.findDescendant("dgm:relIds"))
+    return { type: "chart", kind: "smartart" };
+  if (drawing.findDescendant("wps:wsp"))
+    return { type: "chart", kind: "shape" };
+  return { type: "chart", kind: "drawing" };
+}
+function collectMathText(node) {
+  let out = "";
+  for (const child of node.children) {
+    if (child.tag === "m:t") {
+      out += child.collectText();
+      continue;
+    }
+    out += collectMathText(child);
+  }
+  return out;
+}
 function applyRunProperties(run, runProperties) {
   const colorNode = runProperties.findChild("w:color");
   if (colorNode) {
@@ -14060,22 +14135,30 @@ function readCellBlocks(view, cell, tableId, rowIndex, columnIndex, state) {
   }
   return blocks;
 }
-function readImageRelationships(view) {
+function readRelationships(view) {
   const relationships = XmlNode2.findRoot(view.relationshipsTree, "Relationships");
   if (!relationships)
     return;
   for (const child of relationships.children) {
     if (child.tag !== "Relationship")
       continue;
-    if (child.getAttribute("Type") !== RELATIONSHIP_NAMESPACE_IMAGE)
-      continue;
+    const type = child.getAttribute("Type");
     const relationshipId = child.getAttribute("Id");
     const target = child.getAttribute("Target");
     if (!relationshipId || !target)
       continue;
-    const partName = target.startsWith("/") ? target.slice(1) : `word/${target}`;
-    const contentType = lookupContentType(view, partName);
-    view.imagesByRelationshipId.set(relationshipId, { partName, contentType });
+    if (type === RELATIONSHIP_NAMESPACE_IMAGE) {
+      const partName = target.startsWith("/") ? target.slice(1) : `word/${target}`;
+      const contentType = lookupContentType(view, partName);
+      view.imagesByRelationshipId.set(relationshipId, {
+        partName,
+        contentType
+      });
+      continue;
+    }
+    if (type === RELATIONSHIP_NAMESPACE_HYPERLINK) {
+      view.hyperlinksByRelationshipId.set(relationshipId, { url: target });
+    }
   }
 }
 function lookupContentType(view, partName) {
@@ -14204,7 +14287,27 @@ function readCommentsExtended(view) {
   }
   return out;
 }
-var RELATIONSHIP_NAMESPACE_IMAGE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
+function readNotes(tree, rootTag, itemTag, idPrefix) {
+  if (!tree)
+    return [];
+  const root = XmlNode2.findRoot(tree, rootTag);
+  if (!root)
+    return [];
+  const out = [];
+  for (const child of root.children) {
+    if (child.tag !== itemTag)
+      continue;
+    if (child.getAttribute("w:type"))
+      continue;
+    const numericId = child.getAttribute("w:id");
+    if (numericId == null)
+      continue;
+    const text = child.collectText().replace(/\s+/g, " ").trim();
+    out.push({ id: `${idPrefix}${numericId}`, text });
+  }
+  return out;
+}
+var RELATIONSHIP_NAMESPACE_IMAGE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image", RELATIONSHIP_NAMESPACE_HYPERLINK = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink";
 var init_read = __esm(() => {
   init_parser();
 });
@@ -14219,11 +14322,15 @@ async function openDocView(path) {
   const commentsExtTree = pkg.hasPart("word/commentsExtended.xml") ? XmlNode2.parse(await pkg.readText("word/commentsExtended.xml")) : undefined;
   const corePropertiesTree = pkg.hasPart("docProps/core.xml") ? XmlNode2.parse(await pkg.readText("docProps/core.xml")) : undefined;
   const settingsTree = pkg.hasPart("word/settings.xml") ? XmlNode2.parse(await pkg.readText("word/settings.xml")) : undefined;
+  const footnotesTree = pkg.hasPart("word/footnotes.xml") ? XmlNode2.parse(await pkg.readText("word/footnotes.xml")) : undefined;
+  const endnotesTree = pkg.hasPart("word/endnotes.xml") ? XmlNode2.parse(await pkg.readText("word/endnotes.xml")) : undefined;
   const view = {
     pkg,
     documentTree,
     commentsTree,
     commentsExtTree,
+    footnotesTree,
+    endnotesTree,
     relationshipsTree,
     contentTypesTree,
     corePropertiesTree,
@@ -14232,7 +14339,9 @@ async function openDocView(path) {
     blockReferences: new Map,
     commentReferences: new Map,
     imagesByRelationshipId: new Map,
-    imageById: new Map
+    imageById: new Map,
+    hyperlinksByRelationshipId: new Map,
+    hyperlinkById: new Map
   };
   view.doc = buildDoc(view, pkg.path);
   return view;
@@ -14302,6 +14411,49 @@ var init_doc_view = __esm(() => {
   init_read();
 });
 
+// src/core/ast/text.ts
+function paragraphText(paragraph) {
+  let out = "";
+  for (const run of paragraph.runs) {
+    if (run.type === "text")
+      out += run.text;
+  }
+  return out;
+}
+function flattenParagraphs(blocks) {
+  const out = [];
+  for (const block of blocks) {
+    if (block.type === "paragraph") {
+      out.push(block);
+      continue;
+    }
+    if (block.type === "table") {
+      for (const row of block.rows) {
+        for (const cell of row.cells) {
+          out.push(...flattenParagraphs(cell.blocks));
+        }
+      }
+    }
+  }
+  return out;
+}
+function findBlockById(blocks, blockId) {
+  for (const block of blocks) {
+    if (block.id === blockId)
+      return block;
+    if (block.type === "table") {
+      for (const row of block.rows) {
+        for (const cell of row.cells) {
+          const inner = findBlockById(cell.blocks, blockId);
+          if (inner)
+            return inner;
+        }
+      }
+    }
+  }
+  return null;
+}
+
 // src/core/ast/index.ts
 var init_ast = __esm(() => {
   init_doc_view();
@@ -14319,6 +14471,10 @@ function parseLocator(input) {
   const imageMatch = trimmed.match(IMAGE_RE);
   if (imageMatch)
     return { kind: "image", imageId: `img${imageMatch[1]}` };
+  const linkMatch = trimmed.match(LINK_RE);
+  if (linkMatch) {
+    return { kind: "hyperlink", hyperlinkId: `link${linkMatch[1]}` };
+  }
   const cellMatch = trimmed.match(CELL_RE);
   if (cellMatch) {
     const [, tableIndex, rowIndex, columnIndex, rest] = cellMatch;
@@ -14367,7 +14523,7 @@ function validateOffsets(input, start, end, crossBlock) {
     throw new LocatorParseError(input, "end offset precedes start");
   }
 }
-var LocatorParseError, BLOCK_RE, SPAN_RE, RANGE_RE, COMMENT_RE, IMAGE_RE, CELL_RE;
+var LocatorParseError, BLOCK_RE, SPAN_RE, RANGE_RE, COMMENT_RE, IMAGE_RE, LINK_RE, CELL_RE;
 var init_parse = __esm(() => {
   LocatorParseError = class LocatorParseError extends Error {
     input;
@@ -14382,6 +14538,7 @@ var init_parse = __esm(() => {
   RANGE_RE = /^p(\d+):(\d+)-p(\d+):(\d+)$/;
   COMMENT_RE = /^c(\d+)$/;
   IMAGE_RE = /^img(\d+)$/;
+  LINK_RE = /^link(\d+)$/;
   CELL_RE = /^t(\d+):r(\d+)c(\d+)(?::(.+))?$/;
 });
 
@@ -14431,6 +14588,39 @@ var init_locators = __esm(() => {
   init_resolve();
 });
 
+// src/core/relationships.ts
+function mintRelationshipId(relationshipsRoot) {
+  let highest = 0;
+  for (const child of relationshipsRoot.children) {
+    if (child.tag !== "Relationship")
+      continue;
+    const id = child.getAttribute("Id");
+    if (!id)
+      continue;
+    const match = id.match(/^rId(\d+)$/);
+    if (match?.[1]) {
+      const number = Number(match[1]);
+      if (number > highest)
+        highest = number;
+    }
+  }
+  return `rId${highest + 1}`;
+}
+function addHyperlinkRelationship(relationshipsRoot, url) {
+  const id = mintRelationshipId(relationshipsRoot);
+  relationshipsRoot.children.push(new XmlNode2("Relationship", {
+    Id: id,
+    Type: HYPERLINK_RELATIONSHIP_TYPE,
+    Target: url,
+    TargetMode: "External"
+  }));
+  return id;
+}
+var HYPERLINK_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink";
+var init_relationships = __esm(() => {
+  init_parser();
+});
+
 // src/core/track-changes/index.ts
 function isTrackChangesEnabled(view) {
   if (!view.settingsTree)
@@ -14607,7 +14797,8 @@ var init_jsx = __esm(() => {
     "comments",
     "comment",
     "settings",
-    "trackChanges"
+    "trackChanges",
+    "hyperlink"
   ];
   R_TAGS = ["embed", "link", "id"];
   A_TAGS = [
@@ -14722,6 +14913,7 @@ var init_core = __esm(() => {
   init_locators();
   init_package();
   init_parser();
+  init_relationships();
   init_track_changes();
   init_emit();
 });
@@ -14755,6 +14947,7 @@ function exitCodeFor(code) {
     case "BLOCK_NOT_FOUND":
     case "COMMENT_NOT_FOUND":
     case "IMAGE_NOT_FOUND":
+    case "HYPERLINK_NOT_FOUND":
     case "MATCH_NOT_FOUND":
       return EXIT.NOT_FOUND;
     case "NOT_A_ZIP":
@@ -16124,7 +16317,7 @@ function RunElement({ run: run9 }) {
       children: /* @__PURE__ */ jsxDEV(w.tab, {}, undefined, false, undefined, this)
     }, undefined, false, undefined, this);
   }
-  throw new Error(`Cannot emit run of type "${run9.type}" \u2014 image emission lives in the images command.`);
+  return null;
 }
 function TextRunElement({ run: run9 }) {
   return /* @__PURE__ */ jsxDEV(w.r, {
@@ -16426,15 +16619,15 @@ function literalMatcher(query, ignoreCase) {
     throw new Error("query cannot be empty");
   }
   const needle = ignoreCase ? query.toLowerCase() : query;
-  return (paragraphText) => {
-    const haystack = ignoreCase ? paragraphText.toLowerCase() : paragraphText;
+  return (paragraphText2) => {
+    const haystack = ignoreCase ? paragraphText2.toLowerCase() : paragraphText2;
     const matches = [];
     let cursor = haystack.indexOf(needle);
     while (cursor !== -1) {
       matches.push({
         start: cursor,
         end: cursor + needle.length,
-        text: paragraphText.slice(cursor, cursor + needle.length)
+        text: paragraphText2.slice(cursor, cursor + needle.length)
       });
       cursor = haystack.indexOf(needle, cursor + needle.length);
     }
@@ -16444,15 +16637,15 @@ function literalMatcher(query, ignoreCase) {
 function regexMatcher(pattern, ignoreCase) {
   const flags = `g${ignoreCase ? "i" : ""}`;
   const regex = new RegExp(pattern, flags);
-  return (paragraphText) => {
+  return (paragraphText2) => {
     const matches = [];
     regex.lastIndex = 0;
-    let result = regex.exec(paragraphText);
+    let result = regex.exec(paragraphText2);
     while (result !== null) {
       const matched = result[0];
       if (matched.length === 0) {
         regex.lastIndex += 1;
-        result = regex.exec(paragraphText);
+        result = regex.exec(paragraphText2);
         continue;
       }
       matches.push({
@@ -16460,7 +16653,7 @@ function regexMatcher(pattern, ignoreCase) {
         end: result.index + matched.length,
         text: matched
       });
-      result = regex.exec(paragraphText);
+      result = regex.exec(paragraphText2);
     }
     return matches;
   };
@@ -16468,8 +16661,8 @@ function regexMatcher(pattern, ignoreCase) {
 function collectMatches(blocks, matcher, out) {
   for (const block of blocks) {
     if (block.type === "paragraph") {
-      const paragraphText = block.runs.map((run10) => run10.type === "text" ? run10.text : "").join("");
-      for (const span of matcher(paragraphText)) {
+      const paragraphText2 = block.runs.map((run10) => run10.type === "text" ? run10.text : "").join("");
+      for (const span of matcher(paragraphText2)) {
         const match = {
           blockId: block.id,
           start: span.start,
@@ -16629,12 +16822,107 @@ var init_find = __esm(() => {
   init_respond();
 });
 
-// src/cli/images/extract.ts
-var exports_extract = {};
-__export(exports_extract, {
+// src/cli/hyperlinks/wrap.tsx
+function wrapSpanInHyperlink(paragraph, span, relationshipId) {
+  if (span.start >= span.end) {
+    throw new HyperlinkWrapError(`Empty or inverted span ${span.start}-${span.end}`);
+  }
+  const newChildren = [];
+  const wrappedRuns = [];
+  let offset = 0;
+  let placed = false;
+  const placeWrapper = () => {
+    if (placed || wrappedRuns.length === 0)
+      return;
+    newChildren.push(hyperlinkWrapper(relationshipId, wrappedRuns));
+    wrappedRuns.length = 0;
+    placed = true;
+  };
+  for (const child of paragraph.children) {
+    if (child.tag === "w:r") {
+      const length = runTextLength(child);
+      const runStart = offset;
+      const runEnd = offset + length;
+      offset = runEnd;
+      if (runEnd <= span.start || runStart >= span.end) {
+        placeWrapper();
+        newChildren.push(child);
+        continue;
+      }
+      const sliceStartInRun = Math.max(0, span.start - runStart);
+      const sliceEndInRun = Math.min(length, span.end - runStart);
+      if (sliceStartInRun > 0) {
+        newChildren.push(sliceRun(child, 0, sliceStartInRun));
+      }
+      wrappedRuns.push(sliceRun(child, sliceStartInRun, sliceEndInRun));
+      if (runEnd >= span.end)
+        placeWrapper();
+      if (sliceEndInRun < length) {
+        newChildren.push(sliceRun(child, sliceEndInRun, length));
+      }
+      continue;
+    }
+    if (child.tag === "w:hyperlink") {
+      const hyperlinkLength = sumInnerRunLengths(child);
+      const hyperlinkStart = offset;
+      const hyperlinkEnd = offset + hyperlinkLength;
+      offset = hyperlinkEnd;
+      if (hyperlinkEnd <= span.start || hyperlinkStart >= span.end) {
+        placeWrapper();
+        newChildren.push(child);
+        continue;
+      }
+      throw new HyperlinkWrapError(`Span ${span.start}-${span.end} overlaps an existing hyperlink at ${hyperlinkStart}-${hyperlinkEnd}; nested hyperlinks are not allowed`);
+    }
+    if (child.tag === "w:ins" || child.tag === "w:del") {
+      const innerLength = sumInnerRunLengths(child);
+      const wrapperStart = offset;
+      const wrapperEnd = offset + innerLength;
+      offset = wrapperEnd;
+      if (wrapperEnd <= span.start || wrapperStart >= span.end) {
+        placeWrapper();
+        newChildren.push(child);
+        continue;
+      }
+      throw new HyperlinkWrapError(`Span ${span.start}-${span.end} crosses a tracked-change wrapper at ${wrapperStart}-${wrapperEnd}; resolve or accept the change first`);
+    }
+    newChildren.push(child);
+  }
+  placeWrapper();
+  paragraph.children = newChildren;
+}
+function hyperlinkWrapper(relationshipId, runs) {
+  return /* @__PURE__ */ jsxDEV(w.hyperlink, {
+    "r:id": relationshipId,
+    children: runs
+  }, undefined, false, undefined, this);
+}
+function sumInnerRunLengths(wrapper) {
+  let total = 0;
+  for (const inner of wrapper.children) {
+    if (inner.tag === "w:r")
+      total += runTextLength(inner);
+  }
+  return total;
+}
+var HyperlinkWrapError;
+var init_wrap = __esm(() => {
+  init_jsx();
+  init_parser();
+  init_jsx_dev_runtime();
+  HyperlinkWrapError = class HyperlinkWrapError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "HyperlinkWrapError";
+    }
+  };
+});
+
+// src/cli/hyperlinks/add.tsx
+var exports_add2 = {};
+__export(exports_add2, {
   run: () => run11
 });
-import { join } from "path";
 import { parseArgs as parseArgs10 } from "util";
 async function run11(args) {
   let parsed;
@@ -16643,8 +16931,10 @@ async function run11(args) {
       args,
       allowPositionals: true,
       options: {
-        to: { type: "string" },
-        id: { type: "string" },
+        at: { type: "string" },
+        url: { type: "string" },
+        output: { type: "string", short: "o" },
+        "dry-run": { type: "boolean" },
         help: { type: "boolean", short: "h" }
       }
     });
@@ -16659,49 +16949,569 @@ async function run11(args) {
   const path = parsed.positionals[0];
   if (!path)
     return fail("USAGE", "Missing FILE argument", HELP11);
-  const outputDir = parsed.values.to;
-  if (!outputDir)
-    return fail("USAGE", "Missing --to DIR", HELP11);
-  const targetId = parsed.values.id;
+  const atInput = parsed.values.at;
+  const url = parsed.values.url;
+  if (!atInput)
+    return fail("USAGE", "Missing --at LOCATOR", HELP11);
+  if (!url)
+    return fail("USAGE", "Missing --url URL", HELP11);
+  let locator;
+  try {
+    locator = parseLocator(atInput);
+  } catch (error) {
+    if (error instanceof LocatorParseError) {
+      return fail("INVALID_LOCATOR", error.message);
+    }
+    throw error;
+  }
+  const target = locatorToBlockTarget(locator);
+  if (!target?.span) {
+    return fail("INVALID_LOCATOR", "hyperlinks add requires a span locator like pN:S-E or tT:rRcC:pK:S-E");
+  }
   const view = await openOrFail(path);
   if (typeof view === "number")
     return view;
-  await enrichImageHashes(view);
-  const allImages = [];
-  collectImages(view.doc.blocks, allImages);
-  const targets = targetId ? allImages.filter((image) => image.id === targetId) : allImages;
-  if (targetId && targets.length === 0) {
-    return fail("IMAGE_NOT_FOUND", `Image not found: ${targetId}`);
+  const paragraphRef = await resolveBlockOrFail(view, target.blockId);
+  if (typeof paragraphRef === "number")
+    return paragraphRef;
+  const outputPath = parsed.values.output;
+  if (parsed.values["dry-run"]) {
+    await respond({
+      ok: true,
+      operation: "hyperlinks.add",
+      dryRun: true,
+      path,
+      at: atInput,
+      url,
+      ...outputPath ? { output: outputPath } : {}
+    });
+    return EXIT.OK;
   }
-  const manifest = [];
-  const seenHashes = new Set;
-  for (const image of targets) {
-    const reference = view.imageById.get(image.id);
-    if (!reference)
-      continue;
-    const extension = extensionFor(image.contentType, reference.partName);
-    const fileName = `${image.hash}.${extension}`;
-    const outputPath = join(outputDir, fileName);
-    if (!seenHashes.has(image.hash)) {
-      const bytes = await view.pkg.readBytes(reference.partName);
-      await Bun.write(outputPath, bytes);
-      seenHashes.add(image.hash);
+  const relationships = XmlNode2.findRoot(view.relationshipsTree, "Relationships");
+  if (!relationships) {
+    return fail("UNHANDLED", "Missing <Relationships> root in document rels");
+  }
+  const relationshipId = addHyperlinkRelationship(relationships, url);
+  try {
+    wrapSpanInHyperlink(paragraphRef.node, target.span, relationshipId);
+  } catch (error) {
+    if (error instanceof HyperlinkWrapError) {
+      return fail("USAGE", error.message);
     }
-    manifest.push({
-      id: image.id,
-      path: outputPath,
-      bytes: (await Bun.file(outputPath).arrayBuffer()).byteLength
-    });
+    throw error;
   }
-  await respond({ ok: true, operation: "images.extract", path, manifest });
+  view.hyperlinksByRelationshipId.set(relationshipId, { url });
+  await saveDocView(view, outputPath);
+  await respond({
+    ok: true,
+    operation: "hyperlinks.add",
+    path: outputPath ?? path,
+    at: atInput,
+    url
+  });
   return EXIT.OK;
 }
-function collectImages(blocks, out) {
-  for (const block of blocks) {
+var HELP11 = `docx hyperlinks add \u2014 wrap an existing span in a hyperlink
+
+Usage:
+  docx hyperlinks add FILE --at LOCATOR --url URL [options]
+
+Required:
+  --at LOCATOR      Where to wrap. Supports:
+                      pN:S-E          chars S..E of pN
+                      tT:rRcC:pK:S-E  chars S..E of a cell paragraph
+  --url URL         Target URL
+
+Optional:
+  -o, --output PATH Write to PATH instead of overwriting FILE
+  --dry-run         Print what would change; do not write the file
+  -h, --help        Show this help
+
+The span must lie inside a single paragraph and must not overlap an existing
+hyperlink or a tracked-change wrapper.
+
+Examples:
+  docx hyperlinks add doc.docx --at p3:5-20 --url https://example.com
+`;
+var init_add2 = __esm(() => {
+  init_core();
+  init_parser();
+  init_respond();
+  init_wrap();
+});
+
+// src/cli/hyperlinks/delete.ts
+var exports_delete3 = {};
+__export(exports_delete3, {
+  run: () => run12
+});
+import { parseArgs as parseArgs11 } from "util";
+async function run12(args) {
+  let parsed;
+  try {
+    parsed = parseArgs11({
+      args,
+      allowPositionals: true,
+      options: {
+        at: { type: "string" },
+        output: { type: "string", short: "o" },
+        "dry-run": { type: "boolean" },
+        help: { type: "boolean", short: "h" }
+      }
+    });
+  } catch (parseError) {
+    const message = parseError instanceof Error ? parseError.message : String(parseError);
+    return fail("USAGE", message, HELP12);
+  }
+  if (parsed.values.help) {
+    await writeStdout(HELP12);
+    return EXIT.OK;
+  }
+  const path = parsed.positionals[0];
+  if (!path)
+    return fail("USAGE", "Missing FILE argument", HELP12);
+  const targetId = parsed.values.at;
+  if (!targetId)
+    return fail("USAGE", "Missing --at LINK_ID", HELP12);
+  const view = await openOrFail(path);
+  if (typeof view === "number")
+    return view;
+  const reference = view.hyperlinkById.get(targetId);
+  if (!reference) {
+    return fail("HYPERLINK_NOT_FOUND", `Hyperlink not found: ${targetId}`);
+  }
+  const oldUrl = reference.relationshipId ? view.hyperlinksByRelationshipId.get(reference.relationshipId)?.url : undefined;
+  const outputPath = parsed.values.output;
+  if (parsed.values["dry-run"]) {
+    await respond({
+      ok: true,
+      operation: "hyperlinks.delete",
+      dryRun: true,
+      path,
+      hyperlinkId: targetId,
+      from: oldUrl,
+      ...outputPath ? { output: outputPath } : {}
+    });
+    return EXIT.OK;
+  }
+  const index = reference.parent.indexOf(reference.node);
+  if (index === -1) {
+    return fail("HYPERLINK_NOT_FOUND", `Hyperlink reference is stale (parent does not contain it): ${targetId}`);
+  }
+  reference.parent.splice(index, 1, ...reference.node.children);
+  view.hyperlinkById.delete(targetId);
+  if (reference.relationshipId) {
+    const remaining = countHyperlinkUsages(view.documentTree, reference.relationshipId);
+    if (remaining === 0) {
+      pruneRelationship(view.relationshipsTree, reference.relationshipId);
+      view.hyperlinksByRelationshipId.delete(reference.relationshipId);
+    }
+  }
+  await saveDocView(view, outputPath);
+  await respond({
+    ok: true,
+    operation: "hyperlinks.delete",
+    path: outputPath ?? path,
+    hyperlinkId: targetId,
+    from: oldUrl
+  });
+  return EXIT.OK;
+}
+function countHyperlinkUsages(documentTree, relationshipId) {
+  let count = 0;
+  for (const root of documentTree) {
+    count += countInNode(root, relationshipId);
+  }
+  return count;
+}
+function countInNode(node, relationshipId) {
+  let count = 0;
+  if (node.tag === "w:hyperlink" && node.getAttribute("r:id") === relationshipId) {
+    count++;
+  }
+  for (const child of node.children) {
+    count += countInNode(child, relationshipId);
+  }
+  return count;
+}
+function pruneRelationship(relationshipsTree, relationshipId) {
+  const relationships = XmlNode2.findRoot(relationshipsTree, "Relationships");
+  if (!relationships)
+    return;
+  relationships.children = relationships.children.filter((child) => !(child.tag === "Relationship" && child.getAttribute("Id") === relationshipId));
+}
+var HELP12 = `docx hyperlinks delete \u2014 unwrap a hyperlink (keep the text)
+
+Usage:
+  docx hyperlinks delete FILE --at LINK_ID [options]
+
+Required:
+  --at LINK_ID      Existing hyperlink to remove (e.g., link0)
+
+Optional:
+  -o, --output PATH Write to PATH instead of overwriting FILE
+  --dry-run         Print what would change; do not write the file
+  -h, --help        Show this help
+
+The display text stays in place; only the <w:hyperlink> wrapper is removed.
+If the underlying relationship is no longer referenced, it is pruned from the
+rels file too.
+
+Examples:
+  docx hyperlinks delete doc.docx --at link0
+`;
+var init_delete3 = __esm(() => {
+  init_core();
+  init_parser();
+  init_respond();
+});
+
+// src/cli/hyperlinks/list.ts
+var exports_list2 = {};
+__export(exports_list2, {
+  run: () => run13
+});
+import { parseArgs as parseArgs12 } from "util";
+async function run13(args) {
+  let parsed;
+  try {
+    parsed = parseArgs12({
+      args,
+      allowPositionals: true,
+      options: {
+        help: { type: "boolean", short: "h" }
+      }
+    });
+  } catch (parseError) {
+    const message = parseError instanceof Error ? parseError.message : String(parseError);
+    return fail("USAGE", message, HELP13);
+  }
+  if (parsed.values.help) {
+    await writeStdout(HELP13);
+    return EXIT.OK;
+  }
+  const path = parsed.positionals[0];
+  if (!path)
+    return fail("USAGE", "Missing FILE argument", HELP13);
+  const view = await openOrFail(path);
+  if (typeof view === "number")
+    return view;
+  const entries = new Map;
+  collectHyperlinks(view.doc.blocks, entries);
+  await respond([...entries.values()]);
+  return EXIT.OK;
+}
+function collectHyperlinks(blocks, entries) {
+  for (const block of blocks) {
     if (block.type === "paragraph") {
-      for (const run12 of block.runs) {
-        if (run12.type === "image")
-          out.push(run12);
+      for (const run14 of block.runs) {
+        if (run14.type !== "text" || !run14.hyperlink)
+          continue;
+        addToEntry(entries, run14.hyperlink, block.id, run14.text);
+      }
+      continue;
+    }
+    if (block.type === "table") {
+      for (const row of block.rows) {
+        for (const cell of row.cells) {
+          collectHyperlinks(cell.blocks, entries);
+        }
+      }
+    }
+  }
+}
+function addToEntry(entries, hyperlink, blockId, text) {
+  const existing = entries.get(hyperlink.id);
+  if (existing) {
+    existing.text += text;
+    return;
+  }
+  const entry = {
+    id: hyperlink.id,
+    text,
+    blockId
+  };
+  if (hyperlink.url)
+    entry.url = hyperlink.url;
+  if (hyperlink.anchor)
+    entry.anchor = hyperlink.anchor;
+  if (hyperlink.tooltip)
+    entry.tooltip = hyperlink.tooltip;
+  entries.set(hyperlink.id, entry);
+}
+var HELP13 = `docx hyperlinks list \u2014 print hyperlink manifest as JSON
+
+Usage:
+  docx hyperlinks list FILE [options]
+
+Options:
+  -h, --help        Show this help
+
+Each entry has: id, url (or anchor), tooltip (if set), text (display text),
+and blockId (the paragraph containing the link).
+
+Examples:
+  docx hyperlinks list doc.docx | jq -c '.[] | {id, url, text}'
+`;
+var init_list2 = __esm(() => {
+  init_respond();
+});
+
+// src/cli/hyperlinks/replace.ts
+var exports_replace = {};
+__export(exports_replace, {
+  run: () => run14
+});
+import { parseArgs as parseArgs13 } from "util";
+async function run14(args) {
+  let parsed;
+  try {
+    parsed = parseArgs13({
+      args,
+      allowPositionals: true,
+      options: {
+        at: { type: "string" },
+        with: { type: "string" },
+        output: { type: "string", short: "o" },
+        "dry-run": { type: "boolean" },
+        help: { type: "boolean", short: "h" }
+      }
+    });
+  } catch (parseError) {
+    const message = parseError instanceof Error ? parseError.message : String(parseError);
+    return fail("USAGE", message, HELP14);
+  }
+  if (parsed.values.help) {
+    await writeStdout(HELP14);
+    return EXIT.OK;
+  }
+  const path = parsed.positionals[0];
+  if (!path)
+    return fail("USAGE", "Missing FILE argument", HELP14);
+  const targetId = parsed.values.at;
+  if (!targetId)
+    return fail("USAGE", "Missing --at LINK_ID", HELP14);
+  const newUrl = parsed.values.with;
+  if (!newUrl)
+    return fail("USAGE", "Missing --with URL", HELP14);
+  const view = await openOrFail(path);
+  if (typeof view === "number")
+    return view;
+  const reference = view.hyperlinkById.get(targetId);
+  if (!reference) {
+    return fail("HYPERLINK_NOT_FOUND", `Hyperlink not found: ${targetId}`);
+  }
+  const relationships = XmlNode2.findRoot(view.relationshipsTree, "Relationships");
+  if (!relationships) {
+    return fail("UNHANDLED", "Missing <Relationships> root in document rels");
+  }
+  const existingId = reference.relationshipId;
+  const oldUrl = existingId ? view.hyperlinksByRelationshipId.get(existingId)?.url : undefined;
+  const sharedCount = existingId ? countHyperlinkUsages2(view.documentTree, existingId) : 0;
+  const willAllocateNew = !existingId || sharedCount > 1;
+  const outputPath = parsed.values.output;
+  if (parsed.values["dry-run"]) {
+    await respond({
+      ok: true,
+      operation: "hyperlinks.replace",
+      dryRun: true,
+      path,
+      hyperlinkId: targetId,
+      from: oldUrl,
+      to: newUrl,
+      sharedRelationship: sharedCount > 1,
+      ...outputPath ? { output: outputPath } : {}
+    });
+    return EXIT.OK;
+  }
+  if (willAllocateNew) {
+    const newRelationshipId = addHyperlinkRelationship(relationships, newUrl);
+    reference.node.setAttribute("r:id", newRelationshipId);
+    reference.relationshipId = newRelationshipId;
+    view.hyperlinksByRelationshipId.set(newRelationshipId, { url: newUrl });
+  } else if (existingId) {
+    updateRelationshipTarget(relationships, existingId, newUrl);
+    view.hyperlinksByRelationshipId.set(existingId, { url: newUrl });
+  }
+  await saveDocView(view, outputPath);
+  await respond({
+    ok: true,
+    operation: "hyperlinks.replace",
+    path: outputPath ?? path,
+    hyperlinkId: targetId,
+    from: oldUrl,
+    to: newUrl
+  });
+  return EXIT.OK;
+}
+function updateRelationshipTarget(relationships, relationshipId, newTarget) {
+  for (const child of relationships.children) {
+    if (child.tag !== "Relationship")
+      continue;
+    if (child.getAttribute("Id") === relationshipId) {
+      child.setAttribute("Target", newTarget);
+      return;
+    }
+  }
+}
+function countHyperlinkUsages2(documentTree, relationshipId) {
+  let count = 0;
+  for (const root of documentTree) {
+    count += countInNode2(root, relationshipId);
+  }
+  return count;
+}
+function countInNode2(node, relationshipId) {
+  let count = 0;
+  if (node.tag === "w:hyperlink" && node.getAttribute("r:id") === relationshipId) {
+    count++;
+  }
+  for (const child of node.children) {
+    count += countInNode2(child, relationshipId);
+  }
+  return count;
+}
+var HELP14 = `docx hyperlinks replace \u2014 change a hyperlink's URL
+
+Usage:
+  docx hyperlinks replace FILE --at LINK_ID --with URL [options]
+
+Required:
+  --at LINK_ID      Existing hyperlink to update (e.g., link0)
+  --with URL        New target URL
+
+Optional:
+  -o, --output PATH Write to PATH instead of overwriting FILE
+  --dry-run         Print what would change; do not write the file
+  -h, --help        Show this help
+
+Replaces only the targeted hyperlink. If multiple hyperlinks shared the same
+underlying relationship, a new relationship is allocated so the others are
+unaffected.
+
+Examples:
+  docx hyperlinks replace doc.docx --at link0 --with https://example.com
+`;
+var init_replace = __esm(() => {
+  init_core();
+  init_parser();
+  init_respond();
+});
+
+// src/cli/hyperlinks/index.ts
+var exports_hyperlinks = {};
+__export(exports_hyperlinks, {
+  run: () => run15
+});
+async function run15(args) {
+  const verb = args[0];
+  if (!verb || verb === "--help" || verb === "-h" || verb === "help") {
+    await writeStdout(HELP15);
+    return verb ? 0 : 2;
+  }
+  const loader = SUBCOMMANDS2[verb];
+  if (!loader) {
+    return fail("USAGE", `Unknown hyperlinks subcommand: ${verb}`, 'Run "docx hyperlinks --help".');
+  }
+  const module_ = await loader();
+  return module_.run(args.slice(1));
+}
+var SUBCOMMANDS2, HELP15 = `docx hyperlinks \u2014 manage hyperlinks
+
+Usage:
+  docx hyperlinks <verb> FILE [options]
+
+Verbs:
+  add      Wrap an existing span in a hyperlink
+  delete   Unwrap a hyperlink (keep the text)
+  list     Print hyperlink manifest as JSON
+  replace  Change a hyperlink's URL
+
+Run "docx hyperlinks <verb> --help" for verb-specific help.
+`;
+var init_hyperlinks = __esm(() => {
+  init_respond();
+  SUBCOMMANDS2 = {
+    add: () => Promise.resolve().then(() => (init_add2(), exports_add2)),
+    delete: () => Promise.resolve().then(() => (init_delete3(), exports_delete3)),
+    list: () => Promise.resolve().then(() => (init_list2(), exports_list2)),
+    replace: () => Promise.resolve().then(() => (init_replace(), exports_replace))
+  };
+});
+
+// src/cli/images/extract.ts
+var exports_extract = {};
+__export(exports_extract, {
+  run: () => run16
+});
+import { join } from "path";
+import { parseArgs as parseArgs14 } from "util";
+async function run16(args) {
+  let parsed;
+  try {
+    parsed = parseArgs14({
+      args,
+      allowPositionals: true,
+      options: {
+        to: { type: "string" },
+        id: { type: "string" },
+        help: { type: "boolean", short: "h" }
+      }
+    });
+  } catch (parseError) {
+    const message = parseError instanceof Error ? parseError.message : String(parseError);
+    return fail("USAGE", message, HELP16);
+  }
+  if (parsed.values.help) {
+    await writeStdout(HELP16);
+    return EXIT.OK;
+  }
+  const path = parsed.positionals[0];
+  if (!path)
+    return fail("USAGE", "Missing FILE argument", HELP16);
+  const outputDir = parsed.values.to;
+  if (!outputDir)
+    return fail("USAGE", "Missing --to DIR", HELP16);
+  const targetId = parsed.values.id;
+  const view = await openOrFail(path);
+  if (typeof view === "number")
+    return view;
+  await enrichImageHashes(view);
+  const allImages = [];
+  collectImages(view.doc.blocks, allImages);
+  const targets = targetId ? allImages.filter((image) => image.id === targetId) : allImages;
+  if (targetId && targets.length === 0) {
+    return fail("IMAGE_NOT_FOUND", `Image not found: ${targetId}`);
+  }
+  const manifest = [];
+  const seenHashes = new Set;
+  for (const image of targets) {
+    const reference = view.imageById.get(image.id);
+    if (!reference)
+      continue;
+    const extension = extensionFor(image.contentType, reference.partName);
+    const fileName = `${image.hash}.${extension}`;
+    const outputPath = join(outputDir, fileName);
+    if (!seenHashes.has(image.hash)) {
+      const bytes = await view.pkg.readBytes(reference.partName);
+      await Bun.write(outputPath, bytes);
+      seenHashes.add(image.hash);
+    }
+    manifest.push({
+      id: image.id,
+      path: outputPath,
+      bytes: (await Bun.file(outputPath).arrayBuffer()).byteLength
+    });
+  }
+  await respond({ ok: true, operation: "images.extract", path, manifest });
+  return EXIT.OK;
+}
+function collectImages(blocks, out) {
+  for (const block of blocks) {
+    if (block.type === "paragraph") {
+      for (const run17 of block.runs) {
+        if (run17.type === "image")
+          out.push(run17);
       }
       continue;
     }
@@ -16721,7 +17531,7 @@ function extensionFor(contentType, partName) {
   const fromName = partName.split(".").pop()?.toLowerCase();
   return fromName ?? "bin";
 }
-var HELP11 = `docx images extract \u2014 dump image bytes to a directory
+var HELP16 = `docx images extract \u2014 dump image bytes to a directory
 
 Usage:
   docx images extract FILE --to DIR [options]
@@ -16760,15 +17570,15 @@ var init_extract = __esm(() => {
 });
 
 // src/cli/images/list.ts
-var exports_list2 = {};
-__export(exports_list2, {
-  run: () => run12
+var exports_list3 = {};
+__export(exports_list3, {
+  run: () => run17
 });
-import { parseArgs as parseArgs11 } from "util";
-async function run12(args) {
+import { parseArgs as parseArgs15 } from "util";
+async function run17(args) {
   let parsed;
   try {
-    parsed = parseArgs11({
+    parsed = parseArgs15({
       args,
       allowPositionals: true,
       options: {
@@ -16777,15 +17587,15 @@ async function run12(args) {
     });
   } catch (parseError) {
     const message = parseError instanceof Error ? parseError.message : String(parseError);
-    return fail("USAGE", message, HELP12);
+    return fail("USAGE", message, HELP17);
   }
   if (parsed.values.help) {
-    await writeStdout(HELP12);
+    await writeStdout(HELP17);
     return EXIT.OK;
   }
   const path = parsed.positionals[0];
   if (!path)
-    return fail("USAGE", "Missing FILE argument", HELP12);
+    return fail("USAGE", "Missing FILE argument", HELP17);
   const view = await openOrFail(path);
   if (typeof view === "number")
     return view;
@@ -16798,9 +17608,9 @@ async function run12(args) {
 function collectImages2(blocks, out) {
   for (const block of blocks) {
     if (block.type === "paragraph") {
-      for (const run13 of block.runs) {
-        if (run13.type === "image")
-          out.push(run13);
+      for (const run18 of block.runs) {
+        if (run18.type === "image")
+          out.push(run18);
       }
       continue;
     }
@@ -16813,7 +17623,7 @@ function collectImages2(blocks, out) {
     }
   }
 }
-var HELP12 = `docx images list \u2014 print image manifest as JSON
+var HELP17 = `docx images list \u2014 print image manifest as JSON
 
 Usage:
   docx images list FILE [options]
@@ -16824,21 +17634,21 @@ Options:
 Examples:
   docx images list doc.docx | jq -c '.[] | {id, contentType, hash}'
 `;
-var init_list2 = __esm(() => {
+var init_list3 = __esm(() => {
   init_core();
   init_respond();
 });
 
 // src/cli/images/replace.ts
-var exports_replace = {};
-__export(exports_replace, {
-  run: () => run13
+var exports_replace2 = {};
+__export(exports_replace2, {
+  run: () => run18
 });
-import { parseArgs as parseArgs12 } from "util";
-async function run13(args) {
+import { parseArgs as parseArgs16 } from "util";
+async function run18(args) {
   let parsed;
   try {
-    parsed = parseArgs12({
+    parsed = parseArgs16({
       args,
       allowPositionals: true,
       options: {
@@ -16851,21 +17661,21 @@ async function run13(args) {
     });
   } catch (parseError) {
     const message = parseError instanceof Error ? parseError.message : String(parseError);
-    return fail("USAGE", message, HELP13);
+    return fail("USAGE", message, HELP18);
   }
   if (parsed.values.help) {
-    await writeStdout(HELP13);
+    await writeStdout(HELP18);
     return EXIT.OK;
   }
   const path = parsed.positionals[0];
   if (!path)
-    return fail("USAGE", "Missing FILE argument", HELP13);
+    return fail("USAGE", "Missing FILE argument", HELP18);
   const targetId = parsed.values.at;
   if (!targetId)
-    return fail("USAGE", "Missing --at IMG_ID", HELP13);
+    return fail("USAGE", "Missing --at IMG_ID", HELP18);
   const sourcePath = parsed.values.with;
   if (!sourcePath)
-    return fail("USAGE", "Missing --with PATH", HELP13);
+    return fail("USAGE", "Missing --with PATH", HELP18);
   const sourceFile = Bun.file(sourcePath);
   if (!await sourceFile.exists()) {
     return fail("FILE_NOT_FOUND", `Replacement file not found: ${sourcePath}`);
@@ -16904,7 +17714,7 @@ async function run13(args) {
   } else {
     view.pkg.writeBytes(newPartName, bytes);
     view.pkg.deletePart(originalPartName);
-    updateRelationshipTarget(view.relationshipsTree, reference.relationshipId, relativeTargetFor(newPartName));
+    updateRelationshipTarget2(view.relationshipsTree, reference.relationshipId, relativeTargetFor(newPartName));
     ensureContentTypeDefault(view.contentTypesTree, newExtension, newMimeType);
     reference.partName = newPartName;
     reference.contentType = newMimeType;
@@ -16932,7 +17742,7 @@ function renameExtension(partName, newExtension) {
 function relativeTargetFor(partName) {
   return partName.startsWith("word/") ? partName.slice("word/".length) : partName;
 }
-function updateRelationshipTarget(relationshipsTree, relationshipId, newTarget) {
+function updateRelationshipTarget2(relationshipsTree, relationshipId, newTarget) {
   const relationships = XmlNode2.findRoot(relationshipsTree, "Relationships");
   if (!relationships)
     return;
@@ -16957,7 +17767,7 @@ function ensureContentTypeDefault(contentTypesTree, extension, mimeType) {
   }
   types.children.push(new XmlNode2("Default", { Extension: extension, ContentType: mimeType }));
 }
-var HELP13 = `docx images replace \u2014 swap an image's bytes
+var HELP18 = `docx images replace \u2014 swap an image's bytes
 
 Usage:
   docx images replace FILE --at IMG_ID --with PATH [options]
@@ -16979,7 +17789,7 @@ Examples:
   docx images replace doc.docx --at img2 --with ./new-photo.png
   docx images replace doc.docx --at img0 --with ./diagram.svg
 `, EXTENSION_BY_MIME;
-var init_replace = __esm(() => {
+var init_replace2 = __esm(() => {
   init_core();
   init_parser();
   init_respond();
@@ -17000,22 +17810,22 @@ var init_replace = __esm(() => {
 // src/cli/images/index.ts
 var exports_images = {};
 __export(exports_images, {
-  run: () => run14
+  run: () => run19
 });
-async function run14(args) {
+async function run19(args) {
   const verb = args[0];
   if (!verb || verb === "--help" || verb === "-h" || verb === "help") {
-    await writeStdout(HELP14);
+    await writeStdout(HELP19);
     return verb ? 0 : 2;
   }
-  const loader = SUBCOMMANDS2[verb];
+  const loader = SUBCOMMANDS3[verb];
   if (!loader) {
     return fail("USAGE", `Unknown images subcommand: ${verb}`, 'Run "docx images --help".');
   }
   const module_ = await loader();
   return module_.run(args.slice(1));
 }
-var SUBCOMMANDS2, HELP14 = `docx images \u2014 manage embedded images
+var SUBCOMMANDS3, HELP19 = `docx images \u2014 manage embedded images
 
 Usage:
   docx images <verb> FILE [options]
@@ -17029,10 +17839,10 @@ Run "docx images <verb> --help" for verb-specific help.
 `;
 var init_images = __esm(() => {
   init_respond();
-  SUBCOMMANDS2 = {
+  SUBCOMMANDS3 = {
     extract: () => Promise.resolve().then(() => (init_extract(), exports_extract)),
-    list: () => Promise.resolve().then(() => (init_list2(), exports_list2)),
-    replace: () => Promise.resolve().then(() => (init_replace(), exports_replace))
+    list: () => Promise.resolve().then(() => (init_list3(), exports_list3)),
+    replace: () => Promise.resolve().then(() => (init_replace2(), exports_replace2))
   };
 });
 
@@ -17043,6 +17853,8 @@ var types_default = `export type Doc = {
 	properties: DocProperties;
 	blocks: Block[];
 	comments: Comment[];
+	footnotes: Footnote[];
+	endnotes: Footnote[];
 };
 
 export type DocProperties = {
@@ -17082,7 +17894,14 @@ export type SectionBreak = {
 	type: "sectionBreak";
 };
 
-export type Run = TextRun | ImageRun | BreakRun | TabRun;
+export type Run =
+	| TextRun
+	| ImageRun
+	| BreakRun
+	| TabRun
+	| EquationRun
+	| FootnoteRefRun
+	| ChartRun;
 
 export type TextRun = {
 	type: "text";
@@ -17097,6 +17916,14 @@ export type TextRun = {
 	sizeHalfPoints?: number;
 	comments?: string[];
 	trackedChange?: TrackedChange;
+	hyperlink?: Hyperlink;
+};
+
+export type Hyperlink = {
+	id: string;
+	url?: string;
+	anchor?: string;
+	tooltip?: string;
 };
 
 export type ImageRun = {
@@ -17118,6 +17945,37 @@ export type TabRun = {
 	type: "tab";
 };
 
+/** A math equation surfaced as concatenated <m:t> plaintext. The structural
+ * OOMath markup (subscripts, fractions, etc.) is collapsed to literal characters,
+ * so the rendering is degraded. \`display\` distinguishes inline equations
+ * (<m:oMath>) from block-level display equations (<m:oMathPara>). */
+export type EquationRun = {
+	type: "equation";
+	text: string;
+	display: boolean;
+};
+
+/** Reference to a footnote or endnote whose body lives in Doc.footnotes or
+ * Doc.endnotes. The id matches the footnote/endnote id (\`fn1\`, \`en1\`). */
+export type FootnoteRefRun = {
+	type: "footnoteRef";
+	kind: "footnote" | "endnote";
+	id: string;
+};
+
+/** Placeholder for a non-picture drawing (chart, shape, SmartArt, etc.). The
+ * full content is preserved in the underlying XML; the run is a marker so
+ * callers can know "something visual lives here." */
+export type ChartRun = {
+	type: "chart";
+	kind: "chart" | "shape" | "smartart" | "drawing";
+};
+
+export type Footnote = {
+	id: string;
+	text: string;
+};
+
 export type TrackedChange = {
 	kind: "ins" | "del";
 	author: string;
@@ -17148,13 +18006,13 @@ var init_types = () => {};
 // src/cli/info/schema.ts
 var exports_schema = {};
 __export(exports_schema, {
-  run: () => run15
+  run: () => run20
 });
-import { parseArgs as parseArgs13 } from "util";
-async function run15(args) {
+import { parseArgs as parseArgs17 } from "util";
+async function run20(args) {
   let parsed;
   try {
-    parsed = parseArgs13({
+    parsed = parseArgs17({
       args,
       allowPositionals: true,
       options: {
@@ -17165,10 +18023,10 @@ async function run15(args) {
     });
   } catch (parseError) {
     const message = parseError instanceof Error ? parseError.message : String(parseError);
-    return fail("USAGE", message, HELP15);
+    return fail("USAGE", message, HELP20);
   }
   if (parsed.values.help) {
-    await writeStdout(HELP15);
+    await writeStdout(HELP20);
     return EXIT.OK;
   }
   if (parsed.values.ts) {
@@ -17178,7 +18036,7 @@ async function run15(args) {
   await respond(JSON_SCHEMA);
   return EXIT.OK;
 }
-var HELP15 = `docx schema \u2014 print the AST type definitions
+var HELP20 = `docx schema \u2014 print the AST type definitions
 
 Usage:
   docx schema [options]
@@ -17200,7 +18058,15 @@ var init_schema = __esm(() => {
     $id: "https://github.com/kklimuk/docx-cli/schema",
     title: "docx-cli AST",
     type: "object",
-    required: ["schemaVersion", "path", "properties", "blocks", "comments"],
+    required: [
+      "schemaVersion",
+      "path",
+      "properties",
+      "blocks",
+      "comments",
+      "footnotes",
+      "endnotes"
+    ],
     properties: {
       schemaVersion: { const: 1 },
       path: { type: "string" },
@@ -17214,7 +18080,9 @@ var init_schema = __esm(() => {
         }
       },
       blocks: { type: "array", items: { $ref: "#/$defs/Block" } },
-      comments: { type: "array", items: { $ref: "#/$defs/Comment" } }
+      comments: { type: "array", items: { $ref: "#/$defs/Comment" } },
+      footnotes: { type: "array", items: { $ref: "#/$defs/Footnote" } },
+      endnotes: { type: "array", items: { $ref: "#/$defs/Footnote" } }
     },
     $defs: {
       Block: {
@@ -17248,7 +18116,10 @@ var init_schema = __esm(() => {
           { $ref: "#/$defs/TextRun" },
           { $ref: "#/$defs/ImageRun" },
           { $ref: "#/$defs/BreakRun" },
-          { $ref: "#/$defs/TabRun" }
+          { $ref: "#/$defs/TabRun" },
+          { $ref: "#/$defs/EquationRun" },
+          { $ref: "#/$defs/FootnoteRefRun" },
+          { $ref: "#/$defs/ChartRun" }
         ]
       },
       TextRun: {
@@ -17275,7 +18146,18 @@ var init_schema = __esm(() => {
               date: { type: "string" },
               revisionId: { type: "string" }
             }
-          }
+          },
+          hyperlink: { $ref: "#/$defs/Hyperlink" }
+        }
+      },
+      Hyperlink: {
+        type: "object",
+        required: ["id"],
+        properties: {
+          id: { type: "string" },
+          url: { type: "string" },
+          anchor: { type: "string" },
+          tooltip: { type: "string" }
         }
       },
       ImageRun: {
@@ -17304,6 +18186,40 @@ var init_schema = __esm(() => {
         required: ["type"],
         properties: { type: { const: "tab" } }
       },
+      EquationRun: {
+        type: "object",
+        required: ["type", "text", "display"],
+        properties: {
+          type: { const: "equation" },
+          text: { type: "string" },
+          display: { type: "boolean" }
+        }
+      },
+      FootnoteRefRun: {
+        type: "object",
+        required: ["type", "kind", "id"],
+        properties: {
+          type: { const: "footnoteRef" },
+          kind: { enum: ["footnote", "endnote"] },
+          id: { type: "string" }
+        }
+      },
+      ChartRun: {
+        type: "object",
+        required: ["type", "kind"],
+        properties: {
+          type: { const: "chart" },
+          kind: { enum: ["chart", "shape", "smartart", "drawing"] }
+        }
+      },
+      Footnote: {
+        type: "object",
+        required: ["id", "text"],
+        properties: {
+          id: { type: "string" },
+          text: { type: "string" }
+        }
+      },
       Table: {
         type: "object",
         required: ["id", "type", "rows"],
@@ -17370,13 +18286,13 @@ var init_schema = __esm(() => {
 // src/cli/info/locators.ts
 var exports_locators = {};
 __export(exports_locators, {
-  run: () => run16
+  run: () => run21
 });
-import { parseArgs as parseArgs14 } from "util";
-async function run16(args) {
+import { parseArgs as parseArgs18 } from "util";
+async function run21(args) {
   let parsed;
   try {
-    parsed = parseArgs14({
+    parsed = parseArgs18({
       args,
       allowPositionals: true,
       options: {
@@ -17386,10 +18302,10 @@ async function run16(args) {
     });
   } catch (parseError) {
     const message = parseError instanceof Error ? parseError.message : String(parseError);
-    return fail("USAGE", message, HELP16);
+    return fail("USAGE", message, HELP21);
   }
   if (parsed.values.help) {
-    await writeStdout(HELP16);
+    await writeStdout(HELP21);
     return EXIT.OK;
   }
   if (parsed.values.json) {
@@ -17400,7 +18316,7 @@ async function run16(args) {
   await writeStdout(REFERENCE);
   return EXIT.OK;
 }
-var HELP16 = `docx locators \u2014 print the locator grammar reference
+var HELP21 = `docx locators \u2014 print the locator grammar reference
 
 Usage:
   docx locators [options]
@@ -17426,6 +18342,7 @@ Range locators (across blocks):
 Entity locators:
   cN              Comment id (e.g., c0)
   imgN            Image id (e.g., img2)
+  linkN           Hyperlink id (e.g., link0)
   tN:rRcC         Cell at row R, column C of table tN
 
 Examples:
@@ -17434,6 +18351,7 @@ Examples:
   p3:5-p5:10      -> from char 5 of p3 to char 10 of p5
   c1              -> comment c1
   img0            -> image img0
+  link0           -> hyperlink link0
   t0:r1c2         -> cell at row 1, col 2 of table t0
   t0:r1c2:p0      -> first paragraph of that cell
   t0:r1c2:p0:5-10 -> chars 5..10 of that paragraph
@@ -17466,6 +18384,7 @@ var init_locators2 = __esm(() => {
     entityLocators: {
       comment: { syntax: "cN", example: "c1" },
       image: { syntax: "imgN", example: "img0" },
+      hyperlink: { syntax: "linkN", example: "link0" },
       cell: { syntax: "tN:rRcC", example: "t0:r1c2" },
       nestedCell: { syntax: "tN:rRcC:pK", example: "t0:r1c2:p0" }
     },
@@ -17480,22 +18399,22 @@ var init_locators2 = __esm(() => {
 // src/cli/info/index.ts
 var exports_info = {};
 __export(exports_info, {
-  run: () => run17
+  run: () => run22
 });
-async function run17(args) {
+async function run22(args) {
   const topic = args[0];
   if (!topic || topic === "--help" || topic === "-h" || topic === "help") {
-    await writeStdout(HELP17);
+    await writeStdout(HELP22);
     return topic ? 0 : 2;
   }
-  const loader = SUBCOMMANDS3[topic];
+  const loader = SUBCOMMANDS4[topic];
   if (!loader) {
     return fail("USAGE", `Unknown info topic: ${topic}`, 'Run "docx info --help".');
   }
   const module_ = await loader();
   return module_.run(args.slice(1));
 }
-var SUBCOMMANDS3, HELP17 = `docx info \u2014 print reference material about the CLI
+var SUBCOMMANDS4, HELP22 = `docx info \u2014 print reference material about the CLI
 
 Usage:
   docx info <topic> [options]
@@ -17508,7 +18427,7 @@ Run "docx info <topic> --help" for topic-specific help.
 `;
 var init_info = __esm(() => {
   init_respond();
-  SUBCOMMANDS3 = {
+  SUBCOMMANDS4 = {
     schema: () => Promise.resolve().then(() => (init_schema(), exports_schema)),
     locators: () => Promise.resolve().then(() => (init_locators2(), exports_locators))
   };
@@ -17517,13 +18436,13 @@ var init_info = __esm(() => {
 // src/cli/insert/index.tsx
 var exports_insert = {};
 __export(exports_insert, {
-  run: () => run18
+  run: () => run23
 });
-import { parseArgs as parseArgs15 } from "util";
-async function run18(args) {
+import { parseArgs as parseArgs19 } from "util";
+async function run23(args) {
   let parsed;
   try {
-    parsed = parseArgs15({
+    parsed = parseArgs19({
       args,
       allowPositionals: true,
       options: {
@@ -17536,6 +18455,7 @@ async function run18(args) {
         color: { type: "string" },
         bold: { type: "boolean" },
         italic: { type: "boolean" },
+        url: { type: "string" },
         output: { type: "string", short: "o" },
         "dry-run": { type: "boolean" },
         help: { type: "boolean", short: "h" }
@@ -17543,30 +18463,34 @@ async function run18(args) {
     });
   } catch (parseError) {
     const message = parseError instanceof Error ? parseError.message : String(parseError);
-    return fail("USAGE", message, HELP18);
+    return fail("USAGE", message, HELP23);
   }
   if (parsed.values.help) {
-    await writeStdout(HELP18);
+    await writeStdout(HELP23);
     return EXIT.OK;
   }
   const path = parsed.positionals[0];
   if (!path)
-    return fail("USAGE", "Missing FILE argument", HELP18);
+    return fail("USAGE", "Missing FILE argument", HELP23);
   const after = parsed.values.after;
   const before = parsed.values.before;
   if (!after && !before) {
-    return fail("USAGE", "Missing locator: pass --after or --before", HELP18);
+    return fail("USAGE", "Missing locator: pass --after or --before", HELP23);
   }
   if (after && before) {
-    return fail("USAGE", "Pass either --after or --before, not both", HELP18);
+    return fail("USAGE", "Pass either --after or --before, not both", HELP23);
   }
   const text = parsed.values.text;
   const runsJson = parsed.values.runs;
+  const url = parsed.values.url;
   if (!text && !runsJson) {
-    return fail("USAGE", "Missing content: pass --text or --runs", HELP18);
+    return fail("USAGE", "Missing content: pass --text or --runs", HELP23);
   }
   if (text && runsJson) {
-    return fail("USAGE", "Pass either --text or --runs, not both", HELP18);
+    return fail("USAGE", "Pass either --text or --runs, not both", HELP23);
+  }
+  if (url && !text) {
+    return fail("USAGE", "--url requires --text", HELP23);
   }
   const paragraphOptions = {};
   const styleValue = parsed.values.style;
@@ -17596,6 +18520,8 @@ async function run18(args) {
       ...parsed.values.bold ? { bold: true } : {},
       ...parsed.values.italic ? { italic: true } : {}
     }, undefined, false, undefined, this);
+    if (url)
+      wrapFirstRunInHyperlink(view, paragraphNode, url);
   } else {
     let runsValue;
     try {
@@ -17644,6 +18570,29 @@ async function run18(args) {
   });
   return EXIT.OK;
 }
+function wrapFirstRunInHyperlink(view, paragraph, url) {
+  const relationships = XmlNode2.findRoot(view.relationshipsTree, "Relationships");
+  if (!relationships) {
+    throw new Error("Missing <Relationships> root in document rels");
+  }
+  const relationshipId = addHyperlinkRelationship(relationships, url);
+  view.hyperlinksByRelationshipId.set(relationshipId, { url });
+  const newChildren = [];
+  let wrapped = false;
+  for (const child of paragraph.children) {
+    if (!wrapped && child.tag === "w:r") {
+      const wrapper = /* @__PURE__ */ jsxDEV(w.hyperlink, {
+        "r:id": relationshipId,
+        children: child
+      }, undefined, false, undefined, this);
+      newChildren.push(wrapper);
+      wrapped = true;
+      continue;
+    }
+    newChildren.push(child);
+  }
+  paragraph.children = newChildren;
+}
 function applyTrackedInsertion(paragraph, view) {
   const allocator = createRevisionAllocator(view);
   const baseMeta = { author: resolveAuthor(), date: resolveDate() };
@@ -17674,7 +18623,7 @@ function applyTrackedInsertion(paragraph, view) {
   paragraph.children = newChildren;
   markParagraphMarkAs(paragraph, "ins", mintMeta());
 }
-var HELP18 = `docx insert \u2014 insert a paragraph at a locator
+var HELP23 = `docx insert \u2014 insert a paragraph at a locator
 
 Usage:
   docx insert FILE [options]
@@ -17695,6 +18644,7 @@ Run options (only with --text):
   --color HEX       Run color, hex (e.g., 800080 for purple)
   --bold            Bold
   --italic          Italic
+  --url URL         Wrap the inserted text in a hyperlink to URL
 
   -o, --output PATH Write to PATH instead of overwriting FILE
   --dry-run         Print what would be inserted; do not write the file
@@ -17704,9 +18654,12 @@ Examples:
   docx insert doc.docx --after p3 --text "Section header" --style Heading2
   docx insert doc.docx --before p0 --text "ALERT" --color CC0000 --bold
   docx insert doc.docx --after p2 --runs '[{"type":"text","text":"X","bold":true}]'
+  docx insert doc.docx --after p3 --text "click here" --url https://example.com
 `;
 var init_insert = __esm(() => {
   init_core();
+  init_jsx();
+  init_parser();
   init_respond();
   init_emit2();
   init_jsx_dev_runtime();
@@ -17744,159 +18697,620 @@ function buildOutline(doc, options = {}) {
   }
   return root.children;
 }
-function headingLevel(style, stylePrefix) {
-  if (!style)
+function headingLevel(style, stylePrefix) {
+  if (!style)
+    return null;
+  if (!style.startsWith(stylePrefix))
+    return null;
+  const remainder = style.slice(stylePrefix.length).trim();
+  if (remainder === "")
+    return 1;
+  const parsed = Number(remainder);
+  if (!Number.isInteger(parsed) || parsed < 1)
+    return null;
+  return parsed;
+}
+function* headingParagraphs(blocks, stylePrefix) {
+  for (const block of blocks) {
+    if (block.type !== "paragraph")
+      continue;
+    if (headingLevel(block.style, stylePrefix) === null)
+      continue;
+    yield block;
+  }
+}
+var init_build = __esm(() => {
+  init_core();
+});
+
+// src/cli/outline/index.ts
+var exports_outline = {};
+__export(exports_outline, {
+  run: () => run24
+});
+import { parseArgs as parseArgs20 } from "util";
+async function run24(args) {
+  let parsed;
+  try {
+    parsed = parseArgs20({
+      args,
+      allowPositionals: true,
+      options: {
+        "style-prefix": { type: "string" },
+        help: { type: "boolean", short: "h" }
+      }
+    });
+  } catch (parseError) {
+    const message = parseError instanceof Error ? parseError.message : String(parseError);
+    return fail("USAGE", message, HELP24);
+  }
+  if (parsed.values.help) {
+    await writeStdout(HELP24);
+    return EXIT.OK;
+  }
+  const path = parsed.positionals[0];
+  if (!path)
+    return fail("USAGE", "Missing FILE argument", HELP24);
+  const stylePrefix = parsed.values["style-prefix"] ?? "Heading";
+  if (stylePrefix.length === 0) {
+    return fail("USAGE", "--style-prefix cannot be empty");
+  }
+  const view = await openOrFail(path);
+  if (typeof view === "number")
+    return view;
+  const outline = buildOutline(view.doc, { stylePrefix });
+  await respond({
+    ok: true,
+    operation: "outline",
+    path,
+    stylePrefix,
+    outline
+  });
+  return EXIT.OK;
+}
+var HELP24 = `docx outline \u2014 list headings as a hierarchical tree
+
+Usage:
+  docx outline FILE [options]
+
+Options:
+  --style-prefix S  paragraph-style prefix that marks a heading (default: "Heading")
+  -h, --help        show this help
+
+Walks top-level paragraphs whose style starts with the prefix and parses the
+trailing number as the heading level (e.g. "Heading1" \u2192 1, "Heading 2" \u2192 2).
+Paragraphs nested inside table cells are skipped \u2014 outlines reflect the
+document's structural skeleton, not embedded labels. Lower levels nest under
+higher ones; missing intermediate levels nest directly (H1 \u2192 H3 is fine).
+
+Output is JSON: an array of entries, each shaped like
+  { id, locator, level, style, text, children }.
+
+Examples:
+  docx outline doc.docx
+  docx outline doc.docx --style-prefix "Section"
+  docx outline doc.docx | jq '.outline[].text'
+`;
+var init_outline = __esm(() => {
+  init_respond();
+  init_build();
+});
+
+// src/cli/read/markdown.ts
+function renderMarkdown(doc, options = {}) {
+  const blocks = sliceBlocks(doc.blocks, options.from, options.to);
+  const commentIndex = options.showComments ? buildCommentIndex(blocks, options) : emptyCommentIndex();
+  const ctx = {
+    options,
+    commentIndex,
+    referencedFootnoteIds: new Set,
+    referencedEndnoteIds: new Set
+  };
+  const parts = [];
+  for (const block of blocks) {
+    const rendered = renderBlock(block, ctx);
+    if (rendered !== null)
+      parts.push(rendered);
+  }
+  const definitions = [];
+  if (options.showComments) {
+    const commentFootnotes = renderCommentFootnotes(commentIndex, doc.comments);
+    if (commentFootnotes.length > 0)
+      definitions.push(commentFootnotes);
+  }
+  const footnoteDefs = renderNoteDefinitions(doc.footnotes, ctx.referencedFootnoteIds);
+  if (footnoteDefs.length > 0)
+    definitions.push(footnoteDefs);
+  const endnoteDefs = renderNoteDefinitions(doc.endnotes, ctx.referencedEndnoteIds);
+  if (endnoteDefs.length > 0)
+    definitions.push(endnoteDefs);
+  if (definitions.length > 0)
+    parts.push(definitions.join(`
+`));
+  if (parts.length === 0)
+    return "";
+  return `${parts.join(`
+
+`)}
+`;
+}
+function emptyCommentIndex() {
+  return {
+    endingsByRun: new Map,
+    spanText: new Map,
+    orderedIds: []
+  };
+}
+function buildCommentIndex(blocks, options) {
+  const showChanges = options.showChanges ?? false;
+  const lastSlot = new Map;
+  const spanText = new Map;
+  const orderedIds = [];
+  for (const paragraph of flattenParagraphs(blocks)) {
+    paragraph.runs.forEach((run25, index) => {
+      if (run25.type !== "text")
+        return;
+      if (!showChanges && run25.trackedChange?.kind === "del")
+        return;
+      for (const commentId of run25.comments ?? []) {
+        if (!spanText.has(commentId))
+          orderedIds.push(commentId);
+        spanText.set(commentId, (spanText.get(commentId) ?? "") + run25.text);
+        lastSlot.set(commentId, slotKey(paragraph.id, index));
+      }
+    });
+  }
+  const endingsByRun = new Map;
+  for (const commentId of orderedIds) {
+    const slot = lastSlot.get(commentId);
+    if (!slot)
+      continue;
+    const list = endingsByRun.get(slot) ?? [];
+    list.push(commentId);
+    endingsByRun.set(slot, list);
+  }
+  return { endingsByRun, spanText, orderedIds };
+}
+function slotKey(paragraphId, runIndex) {
+  return `${paragraphId}#${runIndex}`;
+}
+function renderBlock(block, ctx) {
+  if (block.type === "paragraph")
+    return renderParagraph(block, ctx);
+  if (block.type === "table")
+    return renderTable(block, ctx);
+  if (block.type === "sectionBreak")
+    return `--- <!-- ${block.id} -->`;
+  return null;
+}
+function renderParagraph(paragraph, ctx) {
+  const body = renderRuns(paragraph.id, paragraph.runs, ctx);
+  if (body.length === 0)
+    return null;
+  const prefix = paragraphPrefix(paragraph);
+  return `${prefix}${body} <!-- ${paragraph.id} -->`;
+}
+function paragraphPrefix(paragraph) {
+  const headingLevel2 = headingLevelFor(paragraph.style);
+  if (headingLevel2 !== null)
+    return `${"#".repeat(headingLevel2)} `;
+  if (paragraph.list) {
+    const indent = "  ".repeat(paragraph.list.level);
+    return `${indent}- `;
+  }
+  return "";
+}
+function headingLevelFor(style) {
+  if (!style)
+    return null;
+  if (!style.startsWith("Heading"))
+    return null;
+  const remainder = style.slice("Heading".length).trim();
+  if (remainder === "")
+    return 1;
+  const parsed = Number(remainder);
+  if (!Number.isInteger(parsed) || parsed < 1 || parsed > 6)
+    return null;
+  return parsed;
+}
+function renderRuns(paragraphId, runs, ctx) {
+  const showChanges = ctx.options.showChanges ?? false;
+  const visibleEntries = [];
+  runs.forEach((run25, index) => {
+    if (!showChanges && run25.type === "text" && run25.trackedChange?.kind === "del") {
+      return;
+    }
+    visibleEntries.push({ run: run25, originalIndex: index });
+  });
+  let out = "";
+  let cursor = 0;
+  while (cursor < visibleEntries.length) {
+    const entry = visibleEntries[cursor];
+    if (!entry) {
+      cursor++;
+      continue;
+    }
+    const { run: run25 } = entry;
+    if (run25.type === "text") {
+      let lookahead = cursor + 1;
+      while (lookahead < visibleEntries.length) {
+        const next = visibleEntries[lookahead];
+        if (!next || next.run.type !== "text")
+          break;
+        if (!sameDecoration(run25, next.run))
+          break;
+        lookahead++;
+      }
+      const segment = visibleEntries.slice(cursor, lookahead);
+      out += renderTextSegment(segment.map((entry2) => entry2.run), showChanges);
+      out += commentEndingsFor(paragraphId, segment, ctx.commentIndex);
+      cursor = lookahead;
+      continue;
+    }
+    if (run25.type === "image") {
+      const alt = sanitizeAltText(run25.alt ?? run25.id);
+      out += `![${alt}](${run25.id})`;
+    } else if (run25.type === "break") {
+      if (run25.kind === "line")
+        out += "<br>";
+    } else if (run25.type === "tab") {
+      out += "\t";
+    } else if (run25.type === "equation") {
+      const escaped = run25.text.replace(/`/g, "\\`");
+      out += `\`equation: ${escaped}\``;
+    } else if (run25.type === "footnoteRef") {
+      if (run25.kind === "footnote")
+        ctx.referencedFootnoteIds.add(run25.id);
+      else
+        ctx.referencedEndnoteIds.add(run25.id);
+      out += `[^${run25.id}]`;
+    } else if (run25.type === "chart") {
+      out += `\`[${run25.kind}]\``;
+    }
+    cursor++;
+  }
+  return out;
+}
+function commentEndingsFor(paragraphId, segment, commentIndex) {
+  if (commentIndex.endingsByRun.size === 0)
+    return "";
+  let out = "";
+  for (const entry of segment) {
+    const ids = commentIndex.endingsByRun.get(slotKey(paragraphId, entry.originalIndex));
+    if (!ids)
+      continue;
+    for (const commentId of ids)
+      out += `[^${commentId}]`;
+  }
+  return out;
+}
+function sameDecoration(a2, b) {
+  return (a2.bold ?? false) === (b.bold ?? false) && (a2.italic ?? false) === (b.italic ?? false) && (a2.strike ?? false) === (b.strike ?? false) && (a2.underline ?? "") === (b.underline ?? "") && (a2.color ?? "") === (b.color ?? "") && (a2.highlight ?? "") === (b.highlight ?? "") && a2.hyperlink?.id === b.hyperlink?.id && a2.trackedChange?.kind === b.trackedChange?.kind && sameCommentSet(a2.comments, b.comments);
+}
+function sameCommentSet(left, right) {
+  const a2 = left ?? [];
+  const b = right ?? [];
+  if (a2.length !== b.length)
+    return false;
+  for (let i = 0;i < a2.length; i++) {
+    if (a2[i] !== b[i])
+      return false;
+  }
+  return true;
+}
+function renderTextSegment(runs, showChanges) {
+  const text = runs.map((run25) => run25.text).join("");
+  if (text.length === 0)
+    return "";
+  const first = runs[0];
+  if (!first)
+    return "";
+  let out = text;
+  if (first.bold)
+    out = `**${out}**`;
+  if (first.italic)
+    out = `*${out}*`;
+  if (first.strike)
+    out = `~~${out}~~`;
+  if (first.underline)
+    out = `<u>${out}</u>`;
+  const color = colorAttrFor(first.color);
+  if (color)
+    out = `<span style="color:${color}">${out}</span>`;
+  const highlight = highlightCssFor(first.highlight);
+  if (highlight)
+    out = `<span style="background-color:${highlight}">${out}</span>`;
+  if (first.hyperlink) {
+    const target = first.hyperlink.url ?? `#${first.hyperlink.anchor ?? ""}`;
+    out = `[${out}](${target})`;
+  }
+  if (showChanges && first.trackedChange) {
+    out = `<${first.trackedChange.kind}>${out}</${first.trackedChange.kind}>`;
+  }
+  return out;
+}
+function colorAttrFor(value) {
+  if (!value)
     return null;
-  if (!style.startsWith(stylePrefix))
+  const lowered = value.toLowerCase();
+  if (lowered === "auto")
     return null;
-  const remainder = style.slice(stylePrefix.length).trim();
-  if (remainder === "")
-    return 1;
-  const parsed = Number(remainder);
-  if (!Number.isInteger(parsed) || parsed < 1)
+  if (/^[0-9a-f]{6}$/.test(lowered))
+    return `#${lowered}`;
+  return value;
+}
+function highlightCssFor(value) {
+  if (!value)
     return null;
-  return parsed;
+  if (value === "none")
+    return null;
+  return value.replace(/[A-Z]/g, (letter) => letter.toLowerCase());
 }
-function* headingParagraphs(blocks, stylePrefix) {
-  for (const block of blocks) {
-    if (block.type !== "paragraph")
+function renderTable(table, ctx) {
+  if (table.rows.length === 0)
+    return null;
+  const colCount = Math.max(...table.rows.map((row) => row.cells.length));
+  if (colCount === 0)
+    return null;
+  const renderedRows = table.rows.map((row) => {
+    const cells = [];
+    for (let columnIndex = 0;columnIndex < colCount; columnIndex++) {
+      const cell = row.cells[columnIndex];
+      cells.push(cell ? renderCell(cell, ctx) : "");
+    }
+    return cells;
+  });
+  const lines = [];
+  const headerRow = renderedRows[0];
+  if (!headerRow)
+    return null;
+  lines.push(rowToLine(headerRow));
+  lines.push(`| ${Array(colCount).fill("---").join(" | ")} |`);
+  for (let rowIndex = 1;rowIndex < renderedRows.length; rowIndex++) {
+    const row = renderedRows[rowIndex];
+    if (row)
+      lines.push(rowToLine(row));
+  }
+  return lines.join(`
+`);
+}
+function rowToLine(cells) {
+  return `| ${cells.join(" | ")} |`;
+}
+function renderCell(cell, ctx) {
+  const parts = [];
+  for (const block of cell.blocks) {
+    if (block.type === "paragraph") {
+      const body = renderRuns(block.id, block.runs, ctx);
+      if (body.length === 0)
+        continue;
+      parts.push(`${body} <!-- ${block.id} -->`);
       continue;
-    if (headingLevel(block.style, stylePrefix) === null)
+    }
+    if (block.type === "table") {
+      parts.push(renderNestedTable(block, ctx));
+    }
+  }
+  return escapeCell(parts.join("<br>"));
+}
+function renderNestedTable(table, ctx) {
+  const rows = table.rows.map((row) => row.cells.map((cell) => renderCell(cell, ctx)).join(" / "));
+  return rows.join(" // ");
+}
+function escapeCell(text) {
+  return text.replace(/\|/g, "\\|");
+}
+function sanitizeAltText(text) {
+  return text.replace(/[\r\n]+/g, " ").replace(/\]/g, "\\]");
+}
+function renderCommentFootnotes(commentIndex, comments) {
+  if (commentIndex.orderedIds.length === 0)
+    return "";
+  const byId = new Map(comments.map((comment) => [comment.id, comment]));
+  const sorted = [...commentIndex.orderedIds].sort(commentIdCompare);
+  const lines = [];
+  for (const commentId of sorted) {
+    const comment = byId.get(commentId);
+    if (!comment)
       continue;
-    yield block;
+    const span = commentIndex.spanText.get(commentId) ?? "";
+    lines.push(formatFootnote(comment, span));
   }
+  return lines.join(`
+`);
 }
-function paragraphText(paragraph) {
-  let out = "";
-  for (const run19 of paragraph.runs) {
-    if (run19.type === "text")
-      out += run19.text;
+function renderNoteDefinitions(notes, referenced) {
+  if (referenced.size === 0)
+    return "";
+  const byId = new Map(notes.map((note) => [note.id, note]));
+  const sorted = [...referenced].sort(noteIdCompare);
+  const lines = [];
+  for (const id of sorted) {
+    const note = byId.get(id);
+    const body = (note?.text ?? "").replace(/\s+/g, " ").trim();
+    lines.push(`[^${id}]: ${body}`);
+  }
+  return lines.join(`
+`);
+}
+function noteIdCompare(left, right) {
+  return numericIdCompare(left, right, /(\d+)$/);
+}
+function commentIdCompare(left, right) {
+  return numericIdCompare(left, right, /^c(\d+)$/);
+}
+function numericIdCompare(left, right, pattern) {
+  const leftMatch = left.match(pattern);
+  const rightMatch = right.match(pattern);
+  if (leftMatch?.[1] && rightMatch?.[1]) {
+    return Number(leftMatch[1]) - Number(rightMatch[1]);
   }
-  return out;
+  return left.localeCompare(right);
 }
-
-// src/cli/outline/index.ts
-var exports_outline = {};
-__export(exports_outline, {
-  run: () => run19
-});
-import { parseArgs as parseArgs16 } from "util";
-async function run19(args) {
+function formatFootnote(comment, spanText) {
+  const quoted = quoteSpan(spanText);
+  const reply = comment.parentId ? ` \u21B3 ${comment.parentId}` : "";
+  const resolved = comment.resolved ? "\u2713 " : "";
+  const body = comment.text.replace(/\s+/g, " ").trim();
+  return `[^${comment.id}]: ${quoted} \u2014 ${resolved}${comment.author} (${comment.date})${reply}: ${body}`;
+}
+function quoteSpan(text) {
+  const collapsed = text.replace(/\s+/g, " ").trim();
+  const escaped = collapsed.replace(/"/g, "\\\"");
+  return `"${escaped}"`;
+}
+function sliceBlocks(blocks, from, to) {
+  if (!from && !to)
+    return blocks;
+  const fromId = from ? blockIdForLocator(from, "from") : null;
+  const toId = to ? blockIdForLocator(to, "to") : null;
+  const fromIndex = fromId ? blocks.findIndex((b) => b.id === fromId) : 0;
+  if (from && fromId && fromIndex === -1) {
+    throw new MarkdownLocatorError(from, `--from ${from} not found at document top level`);
+  }
+  const toIndex = toId ? blocks.findIndex((b) => b.id === toId) : blocks.length - 1;
+  if (to && toId && toIndex === -1) {
+    throw new MarkdownLocatorError(to, `--to ${to} not found at document top level`);
+  }
+  if (toIndex < fromIndex)
+    return [];
+  return blocks.slice(fromIndex, toIndex + 1);
+}
+function blockIdForLocator(input, position) {
   let parsed;
   try {
-    parsed = parseArgs16({
-      args,
-      allowPositionals: true,
-      options: {
-        "style-prefix": { type: "string" },
-        help: { type: "boolean", short: "h" }
-      }
-    });
-  } catch (parseError) {
-    const message = parseError instanceof Error ? parseError.message : String(parseError);
-    return fail("USAGE", message, HELP19);
-  }
-  if (parsed.values.help) {
-    await writeStdout(HELP19);
-    return EXIT.OK;
+    parsed = parseLocator(input);
+  } catch (err) {
+    if (err instanceof LocatorParseError) {
+      throw new MarkdownLocatorError(input, err.message);
+    }
+    throw err;
   }
-  const path = parsed.positionals[0];
-  if (!path)
-    return fail("USAGE", "Missing FILE argument", HELP19);
-  const stylePrefix = parsed.values["style-prefix"] ?? "Heading";
-  if (stylePrefix.length === 0) {
-    return fail("USAGE", "--style-prefix cannot be empty");
+  switch (parsed.kind) {
+    case "block":
+      return parsed.blockId;
+    case "blockSpan":
+      return parsed.blockId;
+    case "range":
+      return position === "from" ? parsed.start.blockId : parsed.end.blockId;
+    case "cell":
+      return parsed.tableId;
+    case "comment":
+    case "image":
+    case "hyperlink":
+      throw new MarkdownLocatorError(input, `--${position} does not accept a ${parsed.kind} locator \u2014 use a paragraph or table locator`);
   }
-  const view = await openOrFail(path);
-  if (typeof view === "number")
-    return view;
-  const outline = buildOutline(view.doc, { stylePrefix });
-  await respond({
-    ok: true,
-    operation: "outline",
-    path,
-    stylePrefix,
-    outline
-  });
-  return EXIT.OK;
 }
-var HELP19 = `docx outline \u2014 list headings as a hierarchical tree
-
-Usage:
-  docx outline FILE [options]
-
-Options:
-  --style-prefix S  paragraph-style prefix that marks a heading (default: "Heading")
-  -h, --help        show this help
-
-Walks top-level paragraphs whose style starts with the prefix and parses the
-trailing number as the heading level (e.g. "Heading1" \u2192 1, "Heading 2" \u2192 2).
-Paragraphs nested inside table cells are skipped \u2014 outlines reflect the
-document's structural skeleton, not embedded labels. Lower levels nest under
-higher ones; missing intermediate levels nest directly (H1 \u2192 H3 is fine).
-
-Output is JSON: an array of entries, each shaped like
-  { id, locator, level, style, text, children }.
-
-Examples:
-  docx outline doc.docx
-  docx outline doc.docx --style-prefix "Section"
-  docx outline doc.docx | jq '.outline[].text'
-`;
-var init_outline = __esm(() => {
-  init_respond();
+var MarkdownLocatorError;
+var init_markdown = __esm(() => {
+  init_core();
+  MarkdownLocatorError = class MarkdownLocatorError extends Error {
+    input;
+    constructor(input, message) {
+      super(message);
+      this.input = input;
+      this.name = "MarkdownLocatorError";
+    }
+  };
 });
 
 // src/cli/read/index.ts
 var exports_read = {};
 __export(exports_read, {
-  run: () => run20
+  run: () => run25
 });
-import { parseArgs as parseArgs17 } from "util";
-async function run20(args) {
+import { parseArgs as parseArgs21 } from "util";
+async function run25(args) {
   let parsed;
   try {
-    parsed = parseArgs17({
+    parsed = parseArgs21({
       args,
       allowPositionals: true,
       options: {
-        text: { type: "boolean" },
+        markdown: { type: "boolean" },
+        from: { type: "string" },
+        to: { type: "string" },
+        changes: { type: "boolean" },
+        comments: { type: "boolean" },
         help: { type: "boolean", short: "h" }
       }
     });
   } catch (e) {
-    return fail("USAGE", e instanceof Error ? e.message : String(e), HELP20);
+    return fail("USAGE", e instanceof Error ? e.message : String(e), HELP25);
   }
   if (parsed.values.help) {
-    await writeStdout(HELP20);
+    await writeStdout(HELP25);
     return EXIT.OK;
   }
   const path = parsed.positionals[0];
   if (!path)
-    return fail("USAGE", "Missing FILE argument", HELP20);
+    return fail("USAGE", "Missing FILE argument", HELP25);
+  const markdown = Boolean(parsed.values.markdown);
+  const from = parsed.values.from;
+  const to = parsed.values.to;
+  const showChanges = Boolean(parsed.values.changes);
+  const showComments = Boolean(parsed.values.comments);
+  if (!markdown && (from || to || showChanges || showComments)) {
+    return fail("USAGE", "--from, --to, --changes, and --comments require --markdown", HELP25);
+  }
   const view = await openOrFail(path);
   if (typeof view === "number")
     return view;
+  if (markdown) {
+    try {
+      const rendered = renderMarkdown(view.doc, {
+        from,
+        to,
+        showChanges,
+        showComments
+      });
+      await writeStdout(rendered);
+      return EXIT.OK;
+    } catch (err) {
+      if (err instanceof MarkdownLocatorError) {
+        return fail("INVALID_LOCATOR", err.message);
+      }
+      throw err;
+    }
+  }
   await enrichImageHashes(view);
   await respond(view.doc);
   return EXIT.OK;
 }
-var HELP20 = `docx read \u2014 print AST as JSON
+var HELP25 = `docx read \u2014 print AST as JSON, or render document body as Markdown
 
 Usage:
   docx read FILE [options]
 
 Options:
-  --text       Render as human-readable text instead of JSON (NOT YET IMPLEMENTED)
-  -h, --help   Show this help
+  --markdown        Render the body as GitHub-flavored Markdown
+                    (instead of JSON). Locators are emitted as
+                    <!-- pN --> HTML comments after each paragraph and
+                    inside cell content (invisible in rendered view,
+                    but parseable from raw markdown).
+  --from LOC        Start markdown rendering at top-level block LOC (inclusive)
+  --to LOC          End markdown rendering at top-level block LOC (inclusive)
+                    Accepts pN, tN, tN:rRcC[:pK[:S-E]], pN:S-E, pN:S-pM:E.
+                    Cell/span/range locators collapse to their enclosing
+                    top-level block (the table or paragraph).
+  --changes         With --markdown, render tracked insertions/deletions as
+                    <ins>/<del> instead of producing the accepted view.
+  --comments        With --markdown, append [^cN] after each commented span
+                    and emit a footnote definition for each comment at the
+                    end of the output (author, date, body).
+  -h, --help        Show this help
 
 Examples:
   docx read input.docx
+  docx read input.docx --markdown
+  docx read input.docx --markdown --from p3 --to p20
+  docx read input.docx --markdown --changes --comments
   docx read input.docx | jq '.blocks[] | select(.type == "paragraph")'
 `;
 var init_read2 = __esm(() => {
   init_core();
   init_respond();
+  init_markdown();
 });
 
 // src/cli/replace/replace-span.tsx
@@ -17939,7 +19353,7 @@ function collectRunSlots(paragraph) {
       offset += length;
       continue;
     }
-    if (child.tag === "w:ins" || child.tag === "w:del") {
+    if (child.tag === "w:ins" || child.tag === "w:del" || child.tag === "w:hyperlink") {
       for (const inner of child.children) {
         if (inner.tag !== "w:r")
           continue;
@@ -17964,14 +19378,14 @@ function rebuildContainer(container, baseOffset, span, replacement, runPropertie
     if (placed)
       return;
     placed = true;
-    const run21 = /* @__PURE__ */ jsxDEV(ReplacementRun, {
+    const run26 = /* @__PURE__ */ jsxDEV(ReplacementRun, {
       runProperties,
       text: replacement
     }, undefined, false, undefined, this);
     newChildren.push(tracked && isParagraph ? /* @__PURE__ */ jsxDEV(Ins, {
       meta: mintMeta(tracked),
-      children: run21
-    }, undefined, false, undefined, this) : run21);
+      children: run26
+    }, undefined, false, undefined, this) : run26);
   };
   for (const child of container.children) {
     if (child.tag === "w:r") {
@@ -18007,7 +19421,7 @@ function rebuildContainer(container, baseOffset, span, replacement, runPropertie
       }
       continue;
     }
-    if (isParagraph && (child.tag === "w:ins" || child.tag === "w:del")) {
+    if (isParagraph && (child.tag === "w:ins" || child.tag === "w:del" || child.tag === "w:hyperlink")) {
       let innerLength = 0;
       for (const inner of child.children) {
         if (inner.tag === "w:r")
@@ -18031,14 +19445,14 @@ function rebuildAcrossBoundaries(paragraph, span, replacement, runProperties, tr
     if (placed)
       return;
     placed = true;
-    const run21 = /* @__PURE__ */ jsxDEV(ReplacementRun, {
+    const run26 = /* @__PURE__ */ jsxDEV(ReplacementRun, {
       runProperties,
       text: replacement
     }, undefined, false, undefined, this);
     newChildren.push(tracked ? /* @__PURE__ */ jsxDEV(Ins, {
       meta: mintMeta(tracked),
-      children: run21
-    }, undefined, false, undefined, this) : run21);
+      children: run26
+    }, undefined, false, undefined, this) : run26);
   };
   for (const child of paragraph.children) {
     if (child.tag === "w:r") {
@@ -18075,7 +19489,7 @@ function rebuildAcrossBoundaries(paragraph, span, replacement, runProperties, tr
       continue;
     }
     if (child.tag === "w:ins" || child.tag === "w:del") {
-      const innerLength = sumInnerRunLengths(child);
+      const innerLength = sumInnerRunLengths2(child);
       const wrapperStart = offset;
       const wrapperEnd = offset + innerLength;
       offset = wrapperEnd;
@@ -18091,6 +19505,25 @@ function rebuildAcrossBoundaries(paragraph, span, replacement, runProperties, tr
       splitWrapperAcrossSpan(child, wrapperStart, span, tracked, newChildren, placeReplacement);
       continue;
     }
+    if (child.tag === "w:hyperlink") {
+      const innerLength = sumInnerRunLengths2(child);
+      const wrapperStart = offset;
+      const wrapperEnd = offset + innerLength;
+      offset = wrapperEnd;
+      if (wrapperEnd <= span.start) {
+        newChildren.push(child);
+        continue;
+      }
+      if (wrapperStart >= span.end) {
+        placeReplacement();
+        newChildren.push(child);
+        continue;
+      }
+      splitHyperlinkAcrossSpan(child, wrapperStart, span, runProperties, replacement, tracked, newChildren, placeReplacement, () => {
+        placed = true;
+      });
+      continue;
+    }
     newChildren.push(child);
   }
   if (!placed)
@@ -18151,7 +19584,62 @@ function splitWrapperAcrossSpan(wrapper, wrapperStart, span, tracked, out, place
     out.push(postWrapper);
   }
 }
-function sumInnerRunLengths(wrapper) {
+function splitHyperlinkAcrossSpan(wrapper, wrapperStart, span, runProperties, replacement, tracked, out, placeReplacement, markReplacementPlaced) {
+  const wrapperEnd = wrapperStart + wrapper.children.reduce((total, inner) => inner.tag === "w:r" ? total + runTextLength(inner) : total, 0);
+  const startsInside = span.start > wrapperStart && span.start < wrapperEnd;
+  const preInner = [];
+  const postInner = [];
+  let innerOffset = wrapperStart;
+  for (const inner of wrapper.children) {
+    if (inner.tag !== "w:r") {
+      preInner.push(inner);
+      continue;
+    }
+    const length = runTextLength(inner);
+    const runStart = innerOffset;
+    const runEnd = innerOffset + length;
+    innerOffset = runEnd;
+    if (runEnd <= span.start) {
+      preInner.push(inner);
+      continue;
+    }
+    if (runStart >= span.end) {
+      postInner.push(inner);
+      continue;
+    }
+    const sliceStartInRun = Math.max(0, span.start - runStart);
+    const sliceEndInRun = Math.min(length, span.end - runStart);
+    if (sliceStartInRun > 0)
+      preInner.push(sliceRun(inner, 0, sliceStartInRun));
+    if (sliceEndInRun < length) {
+      postInner.push(sliceRun(inner, sliceEndInRun, length));
+    }
+  }
+  if (startsInside) {
+    const innerReplacement = /* @__PURE__ */ jsxDEV(ReplacementRun, {
+      runProperties,
+      text: replacement
+    }, undefined, false, undefined, this);
+    preInner.push(tracked ? /* @__PURE__ */ jsxDEV(Ins, {
+      meta: mintMeta(tracked),
+      children: innerReplacement
+    }, undefined, false, undefined, this) : innerReplacement);
+    markReplacementPlaced();
+  }
+  if (preInner.length > 0) {
+    const preWrapper = new XmlNode2("w:hyperlink", { ...wrapper.attributes });
+    preWrapper.children = preInner;
+    out.push(preWrapper);
+  }
+  if (!startsInside)
+    placeReplacement();
+  if (postInner.length > 0) {
+    const postWrapper = new XmlNode2("w:hyperlink", { ...wrapper.attributes });
+    postWrapper.children = postInner;
+    out.push(postWrapper);
+  }
+}
+function sumInnerRunLengths2(wrapper) {
   let total = 0;
   for (const inner of wrapper.children) {
     if (inner.tag === "w:r")
@@ -18162,8 +19650,8 @@ function sumInnerRunLengths(wrapper) {
 function mintMeta(tracked) {
   return { ...tracked.meta, revisionId: tracked.allocator.next() };
 }
-function convertRunTextToDelText(run21) {
-  for (const child of run21.children) {
+function convertRunTextToDelText(run26) {
+  for (const child of run26.children) {
     if (child.tag === "w:t")
       child.tag = "w:delText";
   }
@@ -18190,15 +19678,15 @@ var init_replace_span = __esm(() => {
 });
 
 // src/cli/replace/index.ts
-var exports_replace2 = {};
-__export(exports_replace2, {
-  run: () => run21
+var exports_replace3 = {};
+__export(exports_replace3, {
+  run: () => run26
 });
-import { parseArgs as parseArgs18 } from "util";
-async function run21(args) {
+import { parseArgs as parseArgs22 } from "util";
+async function run26(args) {
   let parsed;
   try {
-    parsed = parseArgs18({
+    parsed = parseArgs22({
       args,
       allowPositionals: true,
       options: {
@@ -18213,21 +19701,21 @@ async function run21(args) {
     });
   } catch (parseError) {
     const message = parseError instanceof Error ? parseError.message : String(parseError);
-    return fail("USAGE", message, HELP21);
+    return fail("USAGE", message, HELP26);
   }
   if (parsed.values.help) {
-    await writeStdout(HELP21);
+    await writeStdout(HELP26);
     return EXIT.OK;
   }
   const path = parsed.positionals[0];
   const pattern = parsed.positionals[1];
   const replacement = parsed.positionals[2];
   if (!path)
-    return fail("USAGE", "Missing FILE argument", HELP21);
+    return fail("USAGE", "Missing FILE argument", HELP26);
   if (pattern == null)
-    return fail("USAGE", "Missing PATTERN argument", HELP21);
+    return fail("USAGE", "Missing PATTERN argument", HELP26);
   if (replacement == null) {
-    return fail("USAGE", "Missing REPLACEMENT argument", HELP21);
+    return fail("USAGE", "Missing REPLACEMENT argument", HELP26);
   }
   const ignoreCase = Boolean(parsed.values["ignore-case"]);
   const useRegex = Boolean(parsed.values.regex);
@@ -18329,7 +19817,7 @@ async function run21(args) {
   });
   return EXIT.OK;
 }
-var HELP21 = `docx replace \u2014 substitute text spans (sed for docx)
+var HELP26 = `docx replace \u2014 substitute text spans (sed for docx)
 
 Usage:
   docx replace FILE PATTERN REPLACEMENT [options]
@@ -18363,7 +19851,7 @@ Examples:
   docx replace doc.docx "(\\w+) (\\w+)" "$2 $1" --regex --all
   docx replace doc.docx "wordy phrase" "tighter phrase" --all --dry-run
 `;
-var init_replace2 = __esm(() => {
+var init_replace3 = __esm(() => {
   init_core();
   init_respond();
   init_replace_span();
@@ -18372,13 +19860,13 @@ var init_replace2 = __esm(() => {
 // src/cli/track-changes/index.tsx
 var exports_track_changes = {};
 __export(exports_track_changes, {
-  run: () => run22
+  run: () => run27
 });
-import { parseArgs as parseArgs19 } from "util";
-async function run22(args) {
+import { parseArgs as parseArgs23 } from "util";
+async function run27(args) {
   let parsed;
   try {
-    parsed = parseArgs19({
+    parsed = parseArgs23({
       args,
       allowPositionals: true,
       options: {
@@ -18389,18 +19877,18 @@ async function run22(args) {
     });
   } catch (parseError) {
     const message = parseError instanceof Error ? parseError.message : String(parseError);
-    return fail("USAGE", message, HELP22);
+    return fail("USAGE", message, HELP27);
   }
   if (parsed.values.help) {
-    await writeStdout(HELP22);
+    await writeStdout(HELP27);
     return EXIT.OK;
   }
   const path = parsed.positionals[0];
   if (!path)
-    return fail("USAGE", "Missing FILE argument", HELP22);
+    return fail("USAGE", "Missing FILE argument", HELP27);
   const mode = parsed.positionals[1];
   if (mode !== "on" && mode !== "off") {
-    return fail("USAGE", `Expected "on" or "off", got: ${mode ?? "<nothing>"}`, HELP22);
+    return fail("USAGE", `Expected "on" or "off", got: ${mode ?? "<nothing>"}`, HELP27);
   }
   const view = await openOrFail(path);
   if (typeof view === "number")
@@ -18452,7 +19940,7 @@ async function run22(args) {
   });
   return EXIT.OK;
 }
-var HELP22 = `docx track-changes \u2014 toggle the document's tracked-changes mode
+var HELP27 = `docx track-changes \u2014 toggle the document's tracked-changes mode
 
 Usage:
   docx track-changes FILE on|off [options]
@@ -18485,19 +19973,11 @@ function countWords(text) {
   const matches = text.match(/\S+/g);
   return matches?.length ?? 0;
 }
-function paragraphText2(paragraph) {
-  let out = "";
-  for (const run23 of paragraph.runs) {
-    if (run23.type === "text")
-      out += run23.text;
-  }
-  return out;
-}
 function countWordsInBlocks(blocks) {
   let total = 0;
   for (const block of blocks) {
     if (block.type === "paragraph") {
-      total += countWords(paragraphText2(block));
+      total += countWords(paragraphText(block));
     } else if (block.type === "table") {
       for (const row of block.rows) {
         for (const cell of row.cells) {
@@ -18508,24 +19988,8 @@ function countWordsInBlocks(blocks) {
   }
   return total;
 }
-function findBlockById(blocks, blockId) {
-  for (const block of blocks) {
-    if (block.id === blockId)
-      return block;
-    if (block.type === "table") {
-      for (const row of block.rows) {
-        for (const cell of row.cells) {
-          const inner = findBlockById(cell.blocks, blockId);
-          if (inner)
-            return inner;
-        }
-      }
-    }
-  }
-  return null;
-}
 function countWordsInParagraphSpan(paragraph, start, end) {
-  const text = paragraphText2(paragraph);
+  const text = paragraphText(paragraph);
   const clampedEnd = Math.min(Math.max(end, 0), text.length);
   const clampedStart = Math.min(Math.max(start, 0), clampedEnd);
   return countWords(text.slice(clampedStart, clampedEnd));
@@ -18546,46 +20010,32 @@ function countWordsInRange(paragraphsInOrder, startBlockId, startOffset, endBloc
   let total = 0;
   const first = paragraphsInOrder[startIndex];
   if (first) {
-    total += countWordsInParagraphSpan(first, startOffset, paragraphText2(first).length);
+    total += countWordsInParagraphSpan(first, startOffset, paragraphText(first).length);
   }
   for (let index = startIndex + 1;index < endIndex; index++) {
     const middle = paragraphsInOrder[index];
     if (middle)
-      total += countWords(paragraphText2(middle));
+      total += countWords(paragraphText(middle));
   }
   const last = paragraphsInOrder[endIndex];
   if (last)
     total += countWordsInParagraphSpan(last, 0, endOffset);
   return total;
 }
-function flattenParagraphs(blocks) {
-  const out = [];
-  for (const block of blocks) {
-    if (block.type === "paragraph") {
-      out.push(block);
-      continue;
-    }
-    if (block.type === "table") {
-      for (const row of block.rows) {
-        for (const cell of row.cells) {
-          out.push(...flattenParagraphs(cell.blocks));
-        }
-      }
-    }
-  }
-  return out;
-}
+var init_count = __esm(() => {
+  init_core();
+});
 
 // src/cli/wc/index.ts
 var exports_wc = {};
 __export(exports_wc, {
-  run: () => run23
+  run: () => run28
 });
-import { parseArgs as parseArgs20 } from "util";
-async function run23(args) {
+import { parseArgs as parseArgs24 } from "util";
+async function run28(args) {
   let parsed;
   try {
-    parsed = parseArgs20({
+    parsed = parseArgs24({
       args,
       allowPositionals: true,
       options: {
@@ -18594,16 +20044,16 @@ async function run23(args) {
     });
   } catch (parseError) {
     const message = parseError instanceof Error ? parseError.message : String(parseError);
-    return fail("USAGE", message, HELP23);
+    return fail("USAGE", message, HELP28);
   }
   if (parsed.values.help) {
-    await writeStdout(HELP23);
+    await writeStdout(HELP28);
     return EXIT.OK;
   }
   const path = parsed.positionals[0];
   const locatorInput = parsed.positionals[1];
   if (!path)
-    return fail("USAGE", "Missing FILE argument", HELP23);
+    return fail("USAGE", "Missing FILE argument", HELP28);
   const view = await openOrFail(path);
   if (typeof view === "number")
     return view;
@@ -18635,7 +20085,7 @@ async function run23(args) {
     if (!block) {
       return fail("BLOCK_NOT_FOUND", `Block not found: ${locator.blockId}`);
     }
-    const words = block.type === "paragraph" ? countWords(paragraphText2(block)) : block.type === "table" ? countWordsInBlocks([block]) : 0;
+    const words = block.type === "paragraph" ? countWords(paragraphText(block)) : block.type === "table" ? countWordsInBlocks([block]) : 0;
     await respond({
       ok: true,
       operation: "wc",
@@ -18707,7 +20157,7 @@ async function run23(args) {
     if (!block || block.type !== "paragraph") {
       return fail("BLOCK_NOT_FOUND", `Paragraph not found: ${composedId}`);
     }
-    const words = locator.inner.kind === "blockSpan" ? countWordsInParagraphSpan(block, locator.inner.start, locator.inner.end) : countWords(paragraphText2(block));
+    const words = locator.inner.kind === "blockSpan" ? countWordsInParagraphSpan(block, locator.inner.start, locator.inner.end) : countWords(paragraphText(block));
     await respond({
       ok: true,
       operation: "wc",
@@ -18732,7 +20182,7 @@ function findCellBlocks(blocks, locator) {
     return null;
   return cell.blocks;
 }
-var HELP23 = `docx wc \u2014 count words in a document or a locator-addressed slice
+var HELP28 = `docx wc \u2014 count words in a document or a locator-addressed slice
 
 Usage:
   docx wc FILE [LOCATOR] [options]
@@ -18765,11 +20215,12 @@ Examples:
 var init_wc = __esm(() => {
   init_core();
   init_respond();
+  init_count();
 });
 // package.json
 var package_default = {
   name: "bun-docx",
-  version: "0.4.0",
+  version: "0.6.0",
   description: "CLI for AI agents (Claude, Codex) to read, edit, and comment on .docx files with full format fidelity.",
   keywords: [
     "docx",
@@ -18848,6 +20299,7 @@ Commands:
   outline   FILE  List headings as a hierarchical tree
   comments  \u2026     Add, reply, resolve, delete, list comments
   images    \u2026     Extract, replace, list images
+  hyperlinks \u2026    List, replace hyperlinks
   track-changes FILE on|off  Toggle tracked-changes mode
   info      \u2026     Reference material (schema, locators)
 
@@ -18874,12 +20326,13 @@ var COMMANDS = {
   delete: () => Promise.resolve().then(() => (init_delete2(), exports_delete2)),
   edit: () => Promise.resolve().then(() => (init_edit(), exports_edit)),
   find: () => Promise.resolve().then(() => (init_find(), exports_find)),
+  hyperlinks: () => Promise.resolve().then(() => (init_hyperlinks(), exports_hyperlinks)),
   images: () => Promise.resolve().then(() => (init_images(), exports_images)),
   info: () => Promise.resolve().then(() => (init_info(), exports_info)),
   insert: () => Promise.resolve().then(() => (init_insert(), exports_insert)),
   outline: () => Promise.resolve().then(() => (init_outline(), exports_outline)),
   read: () => Promise.resolve().then(() => (init_read2(), exports_read)),
-  replace: () => Promise.resolve().then(() => (init_replace2(), exports_replace2)),
+  replace: () => Promise.resolve().then(() => (init_replace3(), exports_replace3)),
   "track-changes": () => Promise.resolve().then(() => (init_track_changes2(), exports_track_changes)),
   wc: () => Promise.resolve().then(() => (init_wc(), exports_wc))
 };