docxodus 12.6.4 → 13.0.0

package/dist/export-browser.bundle.js

@@ -91,10 +91,11 @@ function canonicalValue(value) {
     if (prototype !== Object.prototype && prototype !== null) {
       throw new TypeError("Canonical JSON supports only plain objects");
     }
-    const result = {};
-    for (const key of Object.keys(value).sort()) {
+    const record = value;
+    const result = /* @__PURE__ */ Object.create(null);
+    for (const key of Object.keys(record).sort()) {
       assertWellFormedUnicode(key);
-      const member = value[key];
+      const member = record[key];
       if (member !== void 0) result[key] = canonicalValue(member);
     }
     return result;
@@ -105,6 +106,548 @@ function canonicalJson(value) {
   return JSON.stringify(canonicalValue(value));
 }
 
+// src/line-metrics.ts
+var PROBE_FONT_SIZE_PX = 1e3;
+var LATIN_PROBE = "Hg";
+var MAX_PROBE_CHARACTERS = 256;
+function probeText(element) {
+  const characters = /* @__PURE__ */ new Set();
+  for (const node of Array.from(element.childNodes)) {
+    if (node.nodeType !== 3) continue;
+    for (const character of node.textContent ?? "") {
+      if (/\s/.test(character)) continue;
+      characters.add(character);
+      if (characters.size >= MAX_PROBE_CHARACTERS) break;
+    }
+  }
+  const beyondLatin = Array.from(characters).filter((character) => character.codePointAt(0) > 591);
+  return beyondLatin.length === 0 ? LATIN_PROBE : LATIN_PROBE + beyondLatin.sort().join("");
+}
+function naturalLineHeightRatios(document2) {
+  const ratios = /* @__PURE__ */ new Map();
+  return (style, text) => {
+    const key = `${style.fontStyle}|${style.fontWeight}|${style.fontStretch}|${style.fontFamily}|${text}`;
+    let ratio = ratios.get(key);
+    if (ratio === void 0) {
+      const probe = document2.createElement("span");
+      probe.setAttribute("aria-hidden", "true");
+      probe.style.cssText = "position:absolute;left:-100000px;top:0;visibility:hidden;display:inline-block;white-space:nowrap;line-height:normal;margin:0;padding:0;border:0;";
+      probe.style.fontFamily = style.fontFamily;
+      probe.style.fontStyle = style.fontStyle;
+      probe.style.fontWeight = style.fontWeight;
+      probe.style.fontStretch = style.fontStretch;
+      probe.style.fontSize = `${PROBE_FONT_SIZE_PX}px`;
+      probe.textContent = text;
+      (document2.body ?? document2.documentElement).appendChild(probe);
+      ratio = probe.getBoundingClientRect().height / PROBE_FONT_SIZE_PX;
+      probe.remove();
+      ratios.set(key, ratio);
+    }
+    return ratio;
+  };
+}
+function applyUnroundedNormalLineHeights(root) {
+  const document2 = root.ownerDocument;
+  const view = document2.defaultView;
+  if (!view) return 0;
+  const ratioFor = naturalLineHeightRatios(document2);
+  const targets = [];
+  for (const element of [root, ...Array.from(root.querySelectorAll("*"))]) {
+    if (!(element instanceof view.HTMLElement)) continue;
+    const style = view.getComputedStyle(element);
+    if (style.lineHeight !== "normal") continue;
+    const fontSize = Number.parseFloat(style.fontSize);
+    const ratio = ratioFor(style, probeText(element));
+    if (!(fontSize > 0) || !(ratio > 0)) continue;
+    targets.push({ element, lineHeight: ratio * fontSize });
+  }
+  for (const { element, lineHeight } of targets) {
+    element.style.setProperty("line-height", `${lineHeight.toFixed(4)}px`);
+  }
+  return targets.length;
+}
+var PARAGRAPH_SELECTOR = "p, h1, h2, h3, h4, h5, h6";
+function baselineOffsets(document2) {
+  const offsets = /* @__PURE__ */ new Map();
+  const host = document2.body ?? document2.documentElement;
+  return (paragraph, child) => {
+    const key = [
+      paragraph.fontStyle,
+      paragraph.fontWeight,
+      paragraph.fontStretch,
+      paragraph.fontFamily,
+      paragraph.fontSize,
+      paragraph.lineHeight,
+      child.fontStyle,
+      child.fontWeight,
+      child.fontStretch,
+      child.fontFamily,
+      child.fontSize,
+      child.lineHeight,
+      child.verticalAlign,
+      child.top
+    ].join("|");
+    let offset = offsets.get(key);
+    if (offset === void 0) {
+      const probe = document2.createElement("div");
+      probe.setAttribute("aria-hidden", "true");
+      probe.style.cssText = "position:absolute;left:-100000px;top:0;visibility:hidden;width:max-content;margin:0;padding:0;border:0;white-space:nowrap;";
+      for (const property of ["font-family", "font-style", "font-weight", "font-stretch", "font-size", "line-height"])
+        probe.style.setProperty(property, paragraph.getPropertyValue(property));
+      const span = document2.createElement("span");
+      for (const property of [
+        "font-family",
+        "font-style",
+        "font-weight",
+        "font-stretch",
+        "font-size",
+        "line-height",
+        "vertical-align",
+        "position",
+        "top"
+      ])
+        span.style.setProperty(property, child.getPropertyValue(property));
+      const marker = document2.createElement("span");
+      marker.style.cssText = "display:inline-block;width:0;height:0;vertical-align:baseline;margin:0;padding:0;border:0;";
+      span.append(marker, LATIN_PROBE);
+      probe.append(span);
+      host.appendChild(probe);
+      offset = marker.getBoundingClientRect().bottom - probe.getBoundingClientRect().top;
+      probe.remove();
+      offsets.set(key, offset);
+    }
+    return offset;
+  };
+}
+function alignExactLineBaselines(root) {
+  const view = root.ownerDocument.defaultView;
+  if (!view) return;
+  const offsetFor = baselineOffsets(root.ownerDocument);
+  for (const run of Array.from(root.querySelectorAll("[data-docx-exact-run]"))) {
+    const paragraph = run.closest(PARAGRAPH_SELECTOR);
+    if (!paragraph || !movable(run, view)) continue;
+    const style = view.getComputedStyle(paragraph);
+    if (!style.getPropertyValue("--docx-exact-line-height")) continue;
+    const height = Number.parseFloat(style.lineHeight);
+    const runStyle = view.getComputedStyle(run);
+    if (!(height > 0) || runStyle.display !== "inline" || runStyle.verticalAlign !== "top") continue;
+    const top = Number.parseFloat(runStyle.top) || 0;
+    const offset = offsetFor(style, runStyle) - top;
+    const shift = height * 0.8 - offset;
+    if (!Number.isFinite(shift)) continue;
+    run.style.position = "relative";
+    run.style.top = `${(top + shift).toFixed(4)}px`;
+  }
+}
+var EXACT_INK_ATTRIBUTE = "data-docx-exact-ink";
+function preserveExactLineInk(content, topLimit, bottomLimit, paper) {
+  const view = content.ownerDocument.defaultView;
+  if (!view) return;
+  const band = content.getBoundingClientRect();
+  const scale = band.width / content.offsetWidth || 1;
+  let above = 0;
+  let below = 0;
+  for (const paragraph of Array.from(content.querySelectorAll(PARAGRAPH_SELECTOR))) {
+    if (!view.getComputedStyle(paragraph).getPropertyValue("--docx-exact-line-height")) continue;
+    const box = paragraph.getBoundingClientRect();
+    if (box.top < band.top - 0.5 || box.bottom > band.bottom + 0.5) continue;
+    if (!paragraph.querySelector("[data-docx-exact-run]") || paragraph.querySelector("img, svg, canvas, video, object, iframe"))
+      continue;
+    if (Array.from(paragraph.querySelectorAll("*")).some((element) => {
+      const style = view.getComputedStyle(element);
+      return style.display !== "inline" || !["static", "relative"].includes(style.position);
+    })) continue;
+    const range = content.ownerDocument.createRange();
+    range.selectNodeContents(paragraph);
+    const rects = Array.from(range.getClientRects()).filter((rect) => rect.width > 0 && rect.height > 0);
+    if (rects.length === 0) continue;
+    const top = Math.min(...rects.map((rect) => rect.top));
+    const bottom = Math.max(...rects.map((rect) => rect.bottom));
+    if (top < topLimit || bottom > bottomLimit) continue;
+    const extra = Math.max(0, band.top - top, bottom - band.bottom);
+    if (extra === 0) continue;
+    paragraph.setAttribute(EXACT_INK_ATTRIBUTE, "true");
+    above = Math.max(above, band.top - top);
+    below = Math.max(below, bottom - band.bottom);
+  }
+  if (above > 0 || below > 0) {
+    const up = Math.ceil(above / scale * 64) / 64;
+    const down = Math.ceil(below / scale * 64) / 64;
+    content.style.overflowY = "visible";
+    content.style.clipPath = `inset(${-up}px ${(band.right - paper.right) / scale}px ${-down}px ${(paper.left - band.left) / scale}px)`;
+  }
+}
+function insetClipBounds(value, box, scale) {
+  const match = /^inset\(((?:-?\d+(?:\.\d+)?px\s*){1,4})\)$/.exec(value);
+  if (!match) return null;
+  const parts = match[1].trim().split(/\s+/).map(Number.parseFloat);
+  const [top, right = top, bottom = top, left = right] = parts;
+  return {
+    top: box.top + top * scale,
+    right: box.right - right * scale,
+    bottom: box.bottom - bottom * scale,
+    left: box.left + left * scale
+  };
+}
+function isPreservedExactLineInk(element, content) {
+  const paragraph = element.closest(`[${EXACT_INK_ATTRIBUTE}]`);
+  const view = content.ownerDocument.defaultView;
+  if (!paragraph || !view || element === paragraph || !content.contains(paragraph)) return false;
+  if (view.getComputedStyle(element).display !== "inline") return false;
+  const band = content.getBoundingClientRect();
+  const box = paragraph.getBoundingClientRect();
+  const clip = insetClipBounds(view.getComputedStyle(content).clipPath, band, band.width / content.offsetWidth || 1);
+  const ink = element.getBoundingClientRect();
+  return clip !== null && box.top >= band.top - 0.5 && box.bottom <= band.bottom + 0.5 && ink.top >= clip.top - 0.02 && ink.bottom <= clip.bottom + 0.02;
+}
+function alignBaselinesToWord(root) {
+  const document2 = root.ownerDocument;
+  const view = document2.defaultView;
+  if (!view) return 0;
+  const descents = /* @__PURE__ */ new Map();
+  const ratioFor = naturalLineHeightRatios(document2);
+  const chromiumOffset = baselineOffsets(document2);
+  const descentRatio = (style) => {
+    const font = `${style.fontStyle} ${style.fontWeight} ${PROBE_FONT_SIZE_PX}px ${style.fontFamily}`;
+    let ratio = descents.get(font);
+    if (ratio === void 0) {
+      const context = document2.createElement("canvas").getContext("2d");
+      ratio = Number.NaN;
+      if (context) {
+        context.font = font;
+        if (context.font.includes(`${PROBE_FONT_SIZE_PX}px`))
+          ratio = context.measureText(LATIN_PROBE).fontBoundingBoxDescent / PROBE_FONT_SIZE_PX;
+      }
+      descents.set(font, ratio);
+    }
+    return ratio;
+  };
+  const moves = [];
+  for (const paragraph of Array.from(root.querySelectorAll(PARAGRAPH_SELECTOR))) {
+    if (!(paragraph instanceof view.HTMLElement)) continue;
+    const style = view.getComputedStyle(paragraph);
+    const candidates = Array.from(paragraph.children).filter((child) => child instanceof view.HTMLElement && (child.textContent ?? "").trim() !== "" && movable(child, view) && view.getComputedStyle(child).display === "inline" && view.getComputedStyle(child).verticalAlign === "baseline");
+    const first = candidates.find((child) => view.getComputedStyle(child).fontFamily === style.fontFamily) ?? candidates[0];
+    if (!first) continue;
+    const lineHeight = Number.parseFloat(style.lineHeight);
+    const fontSize = Number.parseFloat(style.fontSize);
+    if (!(lineHeight > 0) || !(fontSize > 0) || Math.abs(lineHeight - ratioFor(style, LATIN_PROBE) * fontSize) > 0.01) continue;
+    const descent = descentRatio(style);
+    if (!(descent > 0)) continue;
+    const childStyle = view.getComputedStyle(first);
+    const shift = lineHeight - descent * fontSize - chromiumOffset(style, childStyle);
+    if (!Number.isFinite(shift) || Math.abs(shift) < 1 / 64 || Math.abs(shift) >= lineHeight / 2) continue;
+    for (const child of Array.from(paragraph.children))
+      if (child instanceof view.HTMLElement && movable(child, view)) {
+        const top = Number.parseFloat(view.getComputedStyle(child).top);
+        moves.push({ element: child, top: (Number.isFinite(top) ? top : 0) + shift });
+      }
+  }
+  for (const { element, top } of moves) {
+    element.style.setProperty("position", "relative");
+    element.style.setProperty("top", `${top.toFixed(4)}px`);
+  }
+  return moves.length;
+}
+function movable(element, view) {
+  const position = view.getComputedStyle(element).position;
+  if (position !== "static" && position !== "relative") return false;
+  if (!["inline", "inline-block"].includes(view.getComputedStyle(element).display)) return false;
+  if (element.querySelector("img, svg")) return false;
+  for (const descendant of Array.from(element.querySelectorAll("*")))
+    if (["absolute", "fixed"].includes(view.getComputedStyle(descendant).position)) return false;
+  return true;
+}
+
+// src/word-text.ts
+var PREPARED = "data-docx-word-text-prepared";
+var SVG_NS = "http://www.w3.org/2000/svg";
+var PARAGRAPHS = "p, h1, h2, h3, h4, h5, h6";
+function plainDocument(root) {
+  if (root.querySelector("table, svg, math, canvas, video, audio, iframe, object, a, ol, ul, aside, template, header, footer, [data-hf-type], section.footnotes, section.endnotes"))
+    return false;
+  if (Array.from(root.querySelectorAll("img")).some((img) => !img.closest(PARAGRAPHS))) return false;
+  return Array.from(root.querySelectorAll(PARAGRAPHS)).every((p) => {
+    const run = plainRun(p);
+    return run !== null && Number(root.ownerDocument.defaultView?.getComputedStyle(p).getPropertyValue("--docx-auto-line-spacing")) > 0;
+  });
+}
+function pictureSibling(element, view) {
+  if (!(element instanceof view.HTMLElement) || element.localName !== "span" || element.children.length !== 1)
+    return false;
+  const wrapper = element.firstElementChild;
+  if (wrapper.localName !== "span" || wrapper.children.length !== 1 || wrapper.firstElementChild?.localName !== "img")
+    return false;
+  if (wrapper.dataset.docxEdgePicture !== "true") return false;
+  const style = view.getComputedStyle(wrapper);
+  const outer = view.getComputedStyle(element);
+  const image = view.getComputedStyle(wrapper.firstElementChild);
+  return ["left", "right"].includes(style.cssFloat) && style.position === "static" && style.transform === "none" && outer.display === "inline" && ["static", "relative"].includes(outer.position) && outer.transform === "none" && image.transform === "none" && image.position === "static";
+}
+function plainRun(paragraph) {
+  const view = paragraph.ownerDocument.defaultView;
+  if (!view) return null;
+  const children = Array.from(paragraph.children);
+  const content = children.filter((child) => child.textContent !== "");
+  if (content.length !== 1) return null;
+  const run = content[0];
+  if (children.length !== 1) {
+    const runStyle = view.getComputedStyle(run);
+    for (const empty of children.filter((child) => child !== run)) {
+      if (pictureSibling(empty, view)) {
+        const pictureStyle = view.getComputedStyle(empty);
+        if (["font-size", "font-style", "font-weight", "vertical-align"].some((property) => pictureStyle.getPropertyValue(property) !== runStyle.getPropertyValue(property))) return null;
+        continue;
+      }
+      if (paragraph.dataset.columnBreakBefore !== "true") return null;
+      if (!(empty instanceof view.HTMLElement) || empty.localName !== "span" || empty.childNodes.length || Array.from(empty.attributes).some((a) => !["class", "style", "lang", "dir"].includes(a.name))) return null;
+      const emptyStyle = view.getComputedStyle(empty);
+      if ([
+        "font-family",
+        "font-size",
+        "font-style",
+        "font-weight",
+        "font-stretch",
+        "line-height",
+        "display",
+        "position",
+        "top",
+        "vertical-align"
+      ].some((property) => emptyStyle.getPropertyValue(property) !== runStyle.getPropertyValue(property))) return null;
+    }
+  }
+  if (!(run instanceof view.HTMLElement) || run.localName !== "span" || run.children.length || run.childNodes.length !== 1 || run.firstChild?.nodeType !== 3) return null;
+  const text = run.textContent ?? "";
+  if (!text.trim() || /^\s/.test(text) || !/^[\u0020-\u024f]*$/u.test(text)) return null;
+  if (Array.from(run.attributes).some((a) => !["class", "style", "lang", "dir"].includes(a.name))) return null;
+  const style = view.getComputedStyle(run);
+  const parent = view.getComputedStyle(paragraph);
+  if (["Top", "Right", "Bottom", "Left"].some((side) => parent.getPropertyValue(`padding-${side.toLowerCase()}`) !== "0px" || parent.getPropertyValue(`border-${side.toLowerCase()}-width`) !== "0px")) return null;
+  if (parent.direction !== "ltr" || parent.writingMode !== "horizontal-tb" || style.display !== "inline" || !["static", "relative"].includes(style.position) || style.textTransform !== "none" || style.fontVariantCaps !== "normal" || style.textDecorationLine !== "none" || !["normal", "0px"].includes(style.letterSpacing) || !["normal", "100%"].includes(style.fontStretch) || style.backgroundColor !== "rgba(0, 0, 0, 0)" || style.textShadow !== "none" || style.transform !== "none" || style.opacity !== "1" || style.verticalAlign !== "baseline") return null;
+  return run;
+}
+function contourRows(image, paragraph, run, lineCount, checkpoint) {
+  const view = paragraph.ownerDocument.defaultView;
+  const wrapper = image.parentElement;
+  if (wrapper.dataset.docxWrapText !== "bothSides" || image.closest(".page-content") !== paragraph.closest(".page-content")) return null;
+  const wrapStyle = view.getComputedStyle(wrapper);
+  if (wrapStyle.marginTop !== "0px" || wrapStyle.marginBottom !== "0px") return null;
+  const polygon = /^polygon\((.*)\) border-box$/.exec(wrapStyle.shapeOutside);
+  if (!polygon) return null;
+  const points = polygon[1].split(",").map((point) => {
+    const match = /^\s*([\d.+-]+)%\s+([\d.+-]+)%\s*$/.exec(point);
+    return match ? { x: Number(match[1]) / 100, y: Number(match[2]) / 100 } : null;
+  });
+  if (points.length < 3 || points.some((p) => !p || !Number.isFinite(p.x + p.y))) return null;
+  const vertices = points;
+  let orientation = 0;
+  for (let i = 0; i < vertices.length; i++) {
+    const a = vertices[i], b = vertices[(i + 1) % vertices.length], c = vertices[(i + 2) % vertices.length];
+    const cross = (b.x - a.x) * (c.y - b.y) - (b.y - a.y) * (c.x - b.x);
+    if (Math.abs(cross) < 1e-8) continue;
+    if (orientation && Math.sign(cross) !== orientation) return null;
+    orientation = Math.sign(cross);
+  }
+  if (!orientation) return null;
+  const left = Number.parseFloat(wrapStyle.getPropertyValue("--docx-wrap-distance-left")) * 4 / 3;
+  const right = Number.parseFloat(wrapStyle.getPropertyValue("--docx-wrap-distance-right")) * 4 / 3;
+  if (!Number.isFinite(left + right) || left < 0 || right < 0) return null;
+  const box = paragraph.getBoundingClientRect();
+  const picture = image.getBoundingClientRect();
+  if (box.top >= picture.bottom || box.bottom <= picture.top) return null;
+  const style = view.getComputedStyle(run);
+  if (!["start", "left"].includes(view.getComputedStyle(paragraph).textAlign)) return null;
+  const pitch = Number.parseFloat(style.lineHeight);
+  const nativeHeight = Number.parseFloat(style.getPropertyValue("--docx-word-native-height"));
+  if (!(nativeHeight > 0) || !(pitch > 0) || !(picture.width > 0) || !(picture.height > 0)) return null;
+  const context = paragraph.ownerDocument.createElement("canvas").getContext("2d");
+  if (!context) return null;
+  const measureScale = Number.parseFloat(style.fontSize) / 1e4;
+  context.font = `${style.fontStyle} ${style.fontWeight} 10000px ${style.fontFamily}`;
+  context.fontKerning = style.fontKerning;
+  if (!context.font.includes("10000px")) return null;
+  const words = Array.from(run.textContent.matchAll(/\S+\s*/gu), (match, index) => {
+    if ((index & 63) === 0) checkpoint?.();
+    return {
+      text: match[0],
+      width: context.measureText(match[0].trimEnd()).width * measureScale,
+      advance: context.measureText(match[0]).width * measureScale
+    };
+  });
+  const rows = /* @__PURE__ */ new Map();
+  let next = 0;
+  for (let line = 0; line < lineCount && next < words.length; line++) {
+    checkpoint?.();
+    const top = (box.top + line * pitch - picture.top) / picture.height;
+    const bottom = top + nativeHeight / picture.height;
+    const crossings = [];
+    for (let i = 0; i < vertices.length; i++) {
+      const a = vertices[i], b = vertices[(i + 1) % vertices.length];
+      if (a.y >= top && a.y <= bottom) crossings.push(a.x);
+      for (const y of [top, bottom])
+        if (a.y !== b.y && y >= Math.min(a.y, b.y) && y <= Math.max(a.y, b.y))
+          crossings.push(a.x + (b.x - a.x) * (y - a.y) / (b.y - a.y));
+    }
+    const slots = crossings.length ? [
+      [box.left, Math.min(box.right, picture.left + Math.min(...crossings) * picture.width - left)],
+      [Math.max(box.left, picture.left + Math.max(...crossings) * picture.width + right), box.right]
+    ] : [[box.left, box.right]];
+    const row = [];
+    for (const [start, end] of slots) {
+      let x = start;
+      while (next < words.length && x + words[next].width <= end + 1 / 64) {
+        const word = words[next++];
+        row.push({ text: word.text, x: x - box.left });
+        x += word.advance;
+      }
+    }
+    if (!row.length) return null;
+    rows.set(line, row);
+  }
+  return next === words.length && rows.size === lineCount ? rows : null;
+}
+function prepareWordText(root, checkpoint) {
+  if (!plainDocument(root)) return 0;
+  const view = root.ownerDocument.defaultView;
+  if (!view) return 0;
+  let prepared = 0;
+  for (const paragraph of Array.from(root.querySelectorAll(PARAGRAPHS))) {
+    checkpoint?.();
+    const run = plainRun(paragraph);
+    if (!run) continue;
+    const style = view.getComputedStyle(paragraph);
+    const multiple = Number(style.getPropertyValue("--docx-auto-line-spacing"));
+    const runStyle = view.getComputedStyle(run);
+    const kerning = runStyle.getPropertyValue("--docx-font-kerning").trim() || "none";
+    const height = Number.parseFloat(runStyle.lineHeight);
+    if (!(multiple > 0) || !(height > 0) || !["none", "normal"].includes(kerning)) continue;
+    const nativeTwips = Math.round(height / multiple * 15);
+    const twips = Math.floor(nativeTwips * multiple);
+    if (!(twips > 0)) continue;
+    run.style.fontKerning = kerning;
+    run.style.lineHeight = `${twips / 15}px`;
+    run.style.setProperty("--docx-word-native-height", `${nativeTwips / 15}px`);
+    for (const picture of Array.from(paragraph.children).filter((child) => pictureSibling(child, view))) {
+      picture.style.lineHeight = run.style.lineHeight;
+      picture.style.top = "0";
+    }
+    for (const empty of Array.from(paragraph.children).filter((child) => child !== run && !child.children.length)) empty.remove();
+    paragraph.style.lineHeight = run.style.lineHeight;
+    paragraph.setAttribute(PREPARED, "true");
+    prepared++;
+  }
+  return prepared;
+}
+function paintWordText(root, checkpoint) {
+  const document2 = root.ownerDocument;
+  const view = document2.defaultView;
+  if (!view) return 0;
+  const paragraphs = Array.from(root.querySelectorAll(`[${PREPARED}]`));
+  const pictures = Array.from(root.querySelectorAll("img"));
+  const hasPictures = pictures.length > 0;
+  const columnOf = (paragraph) => {
+    for (let parent = paragraph.parentElement; parent && parent !== root; parent = parent.parentElement)
+      if (Number(view.getComputedStyle(parent).columnCount) > 1) return parent;
+    return null;
+  };
+  const fragmentedColumns = /* @__PURE__ */ new Set();
+  for (const paragraph of paragraphs) {
+    checkpoint?.();
+    const column = columnOf(paragraph);
+    if (column && paragraph.getClientRects().length !== 1) fragmentedColumns.add(column);
+  }
+  const metrics = /* @__PURE__ */ new Map();
+  function fontMetrics(style) {
+    const font = `${style.fontStyle} ${style.fontWeight} 10000px ${style.fontFamily}`;
+    const cached = metrics.get(font);
+    if (cached) return cached;
+    const probe = document2.createElement("span");
+    probe.setAttribute("aria-hidden", "true");
+    probe.style.cssText = `position:absolute;left:-100000px;top:0;visibility:hidden;display:inline-block;white-space:nowrap;margin:0;padding:0;border:0;font:${font};line-height:normal`;
+    probe.textContent = "Hg";
+    document2.body.append(probe);
+    const height = probe.getBoundingClientRect().height / 1e4;
+    probe.remove();
+    const context = document2.createElement("canvas").getContext("2d");
+    if (!context) return null;
+    context.font = font;
+    if (!context.font.includes("10000px")) return null;
+    const descent = context.measureText("Hg").fontBoundingBoxDescent / 1e4;
+    if (!(height > 0) || !(descent > 0)) return null;
+    const result = { height, descent };
+    metrics.set(font, result);
+    return result;
+  }
+  const pending = [];
+  for (const paragraph of paragraphs) {
+    checkpoint?.();
+    const column = columnOf(paragraph);
+    if (column && fragmentedColumns.has(column)) {
+      paragraph.removeAttribute(PREPARED);
+      continue;
+    }
+    const run = plainRun(paragraph);
+    if (!run) continue;
+    const style = view.getComputedStyle(run);
+    const metric = fontMetrics(style);
+    const fontSize = Number.parseFloat(style.fontSize);
+    const pitch = Number.parseFloat(style.lineHeight);
+    const box = paragraph.getBoundingClientRect();
+    if (!metric || !(fontSize > 0) || !(pitch > 0) || !(box.width > 0) || !(box.height > 0)) continue;
+    const columnBand = column || hasPictures ? paragraph.closest(".page-content") : null;
+    const band = columnBand?.getBoundingClientRect() ?? box;
+    const text = run.textContent;
+    let rows = /* @__PURE__ */ new Map();
+    let wordCount = 0;
+    for (const match of text.matchAll(/\S+\s*/gu)) {
+      if ((wordCount++ & 63) === 0) checkpoint?.();
+      const range = document2.createRange();
+      range.setStart(run.firstChild, match.index);
+      range.setEnd(run.firstChild, match.index + match[0].trimEnd().length);
+      const rect = range.getBoundingClientRect();
+      const row = Math.round(rect.top * 4);
+      const words = rows.get(row) ?? [];
+      words.push({ text: match[0], x: rect.left - box.left });
+      rows.set(row, words);
+    }
+    if (!rows.size) continue;
+    if (pictures.length === 1) rows = contourRows(pictures[0], paragraph, run, rows.size, checkpoint) ?? rows;
+    const svg = document2.createElementNS(SVG_NS, "svg");
+    svg.setAttribute("width", String(band.width));
+    svg.setAttribute("height", String(band.height));
+    svg.setAttribute("viewBox", `0 0 ${band.width * 4} ${band.height * 4}`);
+    svg.setAttribute("role", "group");
+    svg.style.cssText = columnBand ? "position:absolute;left:0;top:0;display:block;overflow:visible" : "display:block;overflow:visible";
+    const baseline = (metric.height - metric.descent) * fontSize;
+    Array.from(rows.values()).forEach((words, index) => {
+      const line = document2.createElementNS(SVG_NS, "text");
+      line.setAttribute("y", String((box.top - band.top + baseline + index * pitch) * 4));
+      line.setAttribute("xml:space", "preserve");
+      for (const property of ["font-family", "font-weight", "font-style", "font-stretch", "font-kerning"])
+        line.style.setProperty(property, style.getPropertyValue(property));
+      line.style.fontSize = `${fontSize * 4}px`;
+      line.style.fill = style.color;
+      for (const word of words) {
+        const span = document2.createElementNS(SVG_NS, "tspan");
+        span.setAttribute("x", String((box.left - band.left + word.x) * 4));
+        span.textContent = word.text;
+        line.append(span);
+      }
+      svg.append(line);
+    });
+    pending.push({ paragraph, run, svg, height: box.height });
+  }
+  for (const { paragraph, run, svg, height } of pending) {
+    checkpoint?.();
+    if (Array.from(paragraph.children).some((child) => pictureSibling(child, view))) run.replaceWith(svg);
+    else paragraph.replaceChildren(svg);
+    paragraph.style.setProperty("--docx-word-text-height", `${height}px`);
+    paragraph.style.height = "var(--docx-word-text-height)";
+    paragraph.removeAttribute(PREPARED);
+  }
+  return pending.length;
+}
+
 // src/page-number-format.ts
 var ROMAN_ONES = ["", "i", "ii", "iii", "iv", "v", "vi", "vii", "viii", "ix"];
 var ROMAN_TENS = ["", "x", "xx", "xxx", "xl", "l", "lx", "lxx", "lxxx", "xc"];
@@ -235,6 +778,128 @@ function samePageBox(a, b) {
 var MAX_FOOTNOTE_AREA_RATIO = 0.6;
 var FOOTNOTE_MEASUREMENT_GUARD_PT = 2;
 var FOOTNOTE_SOURCE_POSITION_ATTR = "data-pagination-footnote-source-position";
+function collapsedBlockMarginsPx(view, element) {
+  return {
+    topPx: collapseMarginChain(view, element, "top"),
+    bottomPx: collapseMarginChain(view, element, "bottom")
+  };
+}
+function collapseMarginChain(view, element, edge) {
+  const margins = [];
+  let current = element;
+  while (current) {
+    const style = view.getComputedStyle(current);
+    margins.push(parseFloat(edge === "top" ? style.marginTop : style.marginBottom) || 0);
+    current = collapsesThroughTo(view, current, style, edge);
+  }
+  const positive = Math.max(0, ...margins);
+  const negative = Math.min(0, ...margins);
+  return positive + negative;
+}
+function collapsesThroughTo(view, parent, style, edge) {
+  const ordinaryBlock = (style.display === "block" || style.display === "list-item") && style.overflowX === "visible" && style.overflowY === "visible" && style.float === "none" && style.position !== "absolute" && style.position !== "fixed";
+  if (!ordinaryBlock) return null;
+  if (style.columnCount !== "auto" || style.columnWidth !== "auto") return null;
+  const border = parseFloat(edge === "top" ? style.borderTopWidth : style.borderBottomWidth) || 0;
+  const padding = parseFloat(edge === "top" ? style.paddingTop : style.paddingBottom) || 0;
+  if (border !== 0 || padding !== 0) return null;
+  if (edge === "bottom" && parent.style.height !== "") return null;
+  const nodes = Array.from(parent.childNodes);
+  if (edge === "bottom") nodes.reverse();
+  for (const node of nodes) {
+    if (node.nodeType === Node.TEXT_NODE) {
+      if ((node.textContent ?? "").trim() !== "") return null;
+      continue;
+    }
+    if (node.nodeType !== Node.ELEMENT_NODE) continue;
+    const child = node;
+    const childStyle = view.getComputedStyle(child);
+    if (childStyle.display === "none") continue;
+    if (childStyle.position === "absolute" || childStyle.position === "fixed" || childStyle.float !== "none") continue;
+    const blockLevel = childStyle.display === "block" || childStyle.display === "list-item" || childStyle.display === "table" || childStyle.display === "flow-root" || childStyle.display === "flex" || childStyle.display === "grid";
+    return blockLevel ? child : null;
+  }
+  return null;
+}
+var DRAWING_HOST_ATTRIBUTE = "data-docx-anchor-host";
+var HOSTS_PROMOTED_DRAWING_ATTRIBUTE = "data-docx-hosts-promoted-drawing";
+function rendersOnlyItsLine(element) {
+  return (element.textContent ?? "").replace(/[\s\u00a0]/g, "") === "" && element.querySelector("img, svg, canvas, [data-docx-drawing-anchor]") === null;
+}
+function createRenderedSourceMeasurer(clipInset, drawingHostAttribute, hostsPromotedDrawingAttribute) {
+  function visibleWithinPage(view, element, page, pageRect, rect) {
+    let left = Math.max(rect.left, pageRect.left);
+    let top = Math.max(rect.top, pageRect.top);
+    let right = Math.min(rect.right, pageRect.right);
+    let bottom = Math.min(rect.bottom, pageRect.bottom);
+    const clips = (value) => value === "hidden" || value === "clip" || value === "scroll" || value === "auto";
+    for (let ancestor = element.parentElement; ancestor && ancestor !== page; ancestor = ancestor.parentElement) {
+      const style = view.getComputedStyle(ancestor);
+      const clipsX = clips(style.overflowX);
+      const clipsY = clips(style.overflowY);
+      if (!clipsX && !clipsY && !style.clipPath.startsWith("inset(")) continue;
+      const ancestorRect = ancestor.getBoundingClientRect();
+      const scale = ancestorRect.width / ancestor.offsetWidth || 1;
+      const inset = clipInset(style.clipPath, ancestorRect, scale);
+      if (inset) {
+        left = Math.max(left, inset.left);
+        top = Math.max(top, inset.top);
+        right = Math.min(right, inset.right);
+        bottom = Math.min(bottom, inset.bottom);
+      }
+      if (clipsX) {
+        left = Math.max(left, ancestorRect.left);
+        right = Math.min(right, ancestorRect.right);
+      }
+      if (clipsY) {
+        top = Math.max(top, ancestorRect.top);
+        bottom = Math.min(bottom, ancestorRect.bottom);
+      }
+    }
+    return { left, top, right, bottom };
+  }
+  return function measureRenderedSource2(view, element, page, pageRect = page.getBoundingClientRect()) {
+    const own = element.getBoundingClientRect();
+    const ownResult = () => ({ rect: own, visible: visibleWithinPage(view, element, page, pageRect, own) });
+    const ownMeasurable = own.width > 0 && own.height > 0;
+    const hostsPromotedDrawing = element.hasAttribute(hostsPromotedDrawingAttribute);
+    if (ownMeasurable && !hostsPromotedDrawing) return ownResult();
+    const hostAnchorId = element.dataset.sourceAnchorId;
+    const promoted = hostAnchorId ? Array.from(page.querySelectorAll(`[${drawingHostAttribute}]`)).filter((drawing) => drawing.getAttribute(drawingHostAttribute) === hostAnchorId) : [];
+    if (ownMeasurable && promoted.length === 0) return ownResult();
+    const rendered = [
+      ...ownMeasurable ? [element] : Array.from(element.querySelectorAll("*")),
+      ...promoted.flatMap((drawing) => [drawing, ...Array.from(drawing.querySelectorAll("*"))])
+    ];
+    let left = Infinity;
+    let top = Infinity;
+    let right = -Infinity;
+    let bottom = -Infinity;
+    for (const child of rendered) {
+      const style = view.getComputedStyle(child);
+      if (style.display === "none" || style.visibility === "hidden") continue;
+      const childRect = child.getBoundingClientRect();
+      if (childRect.width <= 0 || childRect.height <= 0) continue;
+      const visible = visibleWithinPage(view, child, page, pageRect, childRect);
+      if (visible.right <= visible.left || visible.bottom <= visible.top) continue;
+      left = Math.min(left, visible.left);
+      top = Math.min(top, visible.top);
+      right = Math.max(right, visible.right);
+      bottom = Math.max(bottom, visible.bottom);
+    }
+    if (!(left < right && top < bottom)) return ownResult();
+    return { rect: new DOMRect(left, top, right - left, bottom - top), visible: { left, top, right, bottom } };
+  };
+}
+var measureRenderedSource = createRenderedSourceMeasurer(
+  insetClipBounds,
+  DRAWING_HOST_ATTRIBUTE,
+  HOSTS_PROMOTED_DRAWING_ATTRIBUTE
+);
+function renderedSourceMeasurerExpression() {
+  return `(${createRenderedSourceMeasurer.toString()})(${insetClipBounds.toString()},
+    ${JSON.stringify(DRAWING_HOST_ATTRIBUTE)}, ${JSON.stringify(HOSTS_PROMOTED_DRAWING_ATTRIBUTE)})`;
+}
 var PaginationEngine = class {
   /**
    * Creates a new pagination engine.
@@ -278,6 +943,7 @@ var PaginationEngine = class {
     this.pageGap = options.pageGap ?? 20;
     this.fragmentParagraphs = options.fragmentParagraphs ?? false;
     this.deferFragmentIdentities = options.deferFragmentIdentities ?? false;
+    this.bodyBudgetReductionsPt = options.bodyBudgetReductionsPt ?? {};
     this.cancellationCheckpoint = options.checkCancellation;
     this.pageCountCheckpoint = options.checkPageCount;
     this.layoutToken = options.layoutToken;
@@ -426,7 +1092,8 @@ var PaginationEngine = class {
               sectionDims,
               sectionIndex,
               columnCount,
-              Number.isFinite(gap) ? gap : 36
+              Number.isFinite(gap) ? gap : 36,
+              section.dataset.sectionType === "continuous" && section === sectionsToProcess[sectionsToProcess.length - 1]
             ));
           } else {
             blocks.push(...this.measureBlocks(section, sectionDims, sectionIndex));
@@ -533,12 +1200,11 @@ var PaginationEngine = class {
         if (!anchorId || !element.dataset.pageFragmentId || !Number.isInteger(parseInt(element.dataset.fragmentIndex || "", 10))) {
           throw new Error(`page ${page.pageNumber} contains an unqualified source anchor`);
         }
-        const rect = element.getBoundingClientRect();
         const style = this.view.getComputedStyle(element);
         const deliberatelyHidden = style.display === "none" || style.visibility === "hidden";
         if (deliberatelyHidden) continue;
+        const { rect, visible: visibleRect } = measureRenderedSource(this.view, element, page.element, pageRect);
         requiredAnchorIds.add(anchorId);
-        const visibleRect = this.intersectWithClippingAncestors(element, page.element, pageRect, rect);
         const left = visibleRect.left;
         const top = visibleRect.top;
         const right = visibleRect.right;
@@ -599,8 +1265,7 @@ var PaginationEngine = class {
         if (!anchorId) continue;
         const style = this.view.getComputedStyle(element);
         if (style.display === "none" || style.visibility === "hidden") continue;
-        const rect = element.getBoundingClientRect();
-        const visible = this.intersectWithClippingAncestors(element, page.element, pageRect, rect);
+        const { rect, visible } = measureRenderedSource(this.view, element, page.element, pageRect);
         if (rect.width <= 0 || rect.height <= 0 || visible.right <= visible.left || visible.bottom <= visible.top) continue;
         const fragmentIndex = emittedFragmentCounts.get(anchorId) ?? 0;
         emittedFragmentCounts.set(anchorId, fragmentIndex + 1);
@@ -610,34 +1275,6 @@ var PaginationEngine = class {
       }
     }
   }
-  /**
-   * Intersect an element with every ancestor that establishes an overflow clip before the page
-   * root. getBoundingClientRect() reports layout outside those clips, which is not rendered and
-   * therefore must not satisfy PageMap completeness or inflate portable geometry.
-   */
-  intersectWithClippingAncestors(element, page, pageRect, rect) {
-    let left = Math.max(rect.left, pageRect.left);
-    let top = Math.max(rect.top, pageRect.top);
-    let right = Math.min(rect.right, pageRect.right);
-    let bottom = Math.min(rect.bottom, pageRect.bottom);
-    const clips = (value) => value === "hidden" || value === "clip" || value === "scroll" || value === "auto";
-    for (let ancestor = element.parentElement; ancestor && ancestor !== page; ancestor = ancestor.parentElement) {
-      const style = this.view.getComputedStyle(ancestor);
-      const clipsX = clips(style.overflowX);
-      const clipsY = clips(style.overflowY);
-      if (!clipsX && !clipsY) continue;
-      const ancestorRect = ancestor.getBoundingClientRect();
-      if (clipsX) {
-        left = Math.max(left, ancestorRect.left);
-        right = Math.min(right, ancestorRect.right);
-      }
-      if (clipsY) {
-        top = Math.max(top, ancestorRect.top);
-        bottom = Math.min(bottom, ancestorRect.bottom);
-      }
-    }
-    return { left, top, right, bottom };
-  }
   storyForCanonicalAnchor(anchorId) {
     const first = anchorId.indexOf(":");
     const second = first < 0 ? -1 : anchorId.indexOf(":", first + 1);
@@ -829,9 +1466,7 @@ var PaginationEngine = class {
         }
       }
       const rect = child.getBoundingClientRect();
-      const style = this.view.getComputedStyle(child);
-      const marginTopPx = parseFloat(style.marginTop) || 0;
-      const marginBottomPx = parseFloat(style.marginBottom) || 0;
+      const { topPx: marginTopPx, bottomPx: marginBottomPx } = collapsedBlockMarginsPx(this.view, child);
       const heightPt = pxToPt(rect.height);
       const marginTopPt = pxToPt(marginTopPx);
       const marginBottomPt = pxToPt(marginBottomPx);
@@ -874,7 +1509,24 @@ var PaginationEngine = class {
     for (const rule of sectionChildren.filter((child) => child.tagName === "HR")) {
       this.checkpoint();
       const clonedRule = rule.cloneNode(true);
-      if (blocks.length === 0) clonedRule.style.marginTop = sectionStyle.marginTop;
+      const ruleStyle = this.view.getComputedStyle(rule);
+      for (const property of [
+        "height",
+        "width",
+        "max-width",
+        "border",
+        "background-color",
+        "color",
+        "margin-top",
+        "margin-right",
+        "margin-bottom",
+        "margin-left"
+      ]) {
+        clonedRule.style.setProperty(property, ruleStyle.getPropertyValue(property));
+      }
+      if (blocks.length === 0) {
+        clonedRule.style.marginTop = `calc(${sectionStyle.marginTop} + ${ruleStyle.marginTop})`;
+      }
       blocks.push(this.measureElement(clonedRule, dims, sectionIndex));
     }
     const listStyle = this.view.getComputedStyle(list);
@@ -908,12 +1560,14 @@ var PaginationEngine = class {
             if (clone.id && clone.id !== itemId) return null;
             clone.id = itemId;
           }
-          const value = parseInt(item.getAttribute("value") || String(itemIndex + 1), 10);
-          const marker = this.formatOrderedListMarker(
-            Number.isFinite(value) ? value : itemIndex + 1,
-            listStyle.listStyleType
-          );
-          clone.insertBefore(this.document.createTextNode(`${marker}. `), clone.firstChild);
+          if (!clone.querySelector("[data-endnote-number]")) {
+            const value = parseInt(item.getAttribute("value") || String(itemIndex + 1), 10);
+            const marker = this.formatOrderedListMarker(
+              Number.isFinite(value) ? value : itemIndex + 1,
+              listStyle.listStyleType
+            );
+            clone.insertBefore(this.document.createTextNode(`${marker}. `), clone.firstChild);
+          }
         }
         blocks.push(this.measureElement(clone, dims, sectionIndex));
       }
@@ -943,15 +1597,16 @@ var PaginationEngine = class {
   /**
    * Flows a multi-column (`w:cols`) section's children into CSS-multicol container
    * blocks. Word lays such a section out as N columns inside the same body extent;
-   * a balanced `column-count` container reproduces that geometry, and the paginator
+   * a `column-count` container reproduces that geometry, and the paginator
    * then places each container as one ordinary measured block. A container grows
-   * greedily until its balanced height would exceed the smallest page body available
-   * to the section, so a long columned section still splits across pages at block
+   * greedily until it would exceed the smallest page body available to the section.
+   * Final continuous sections fill that height sequentially; other sections retain
+   * balancing. A long columned section still splits across pages at block
    * boundaries. Each child lands in exactly one container, so anchors never
    * duplicate. An explicit page break child passes through as its own block, which
    * ends the current container and lets the normal flow logic turn the page.
    */
-  buildColumnBlocks(section, dims, sectionIndex, columnCount, columnGapPt) {
+  buildColumnBlocks(section, dims, sectionIndex, columnCount, columnGapPt, sequential = false) {
     const children = Array.from(section.children);
     const blocks = [];
     const maxFragmentHeight = this.smallestEffectiveContentHeight(dims, sectionIndex);
@@ -960,9 +1615,15 @@ var PaginationEngine = class {
       const container = this.document.createElement("div");
       container.style.columnCount = String(columnCount);
       container.style.columnGap = `${columnGapPt}pt`;
+      if (sequential) {
+        container.dataset.paginationSequentialColumns = "true";
+        container.style.columnFill = "auto";
+        container.style.maxHeight = `${maxFragmentHeight}pt`;
+      }
       for (const child of slice) {
         container.appendChild(child.cloneNode(true));
       }
+      if (sequential) this.liftColumnSpaceBefore(container, dims);
       return container;
     };
     let start = 0;
@@ -975,12 +1636,17 @@ var PaginationEngine = class {
       }
       let end = start + 1;
       let container = makeContainer(children.slice(start, end));
+      if (sequential && this.columnContainerOverflows(container, dims)) {
+        delete container.dataset.paginationSequentialColumns;
+        container.style.columnFill = "balance";
+        container.style.maxHeight = "";
+      }
       let measured = this.measureElement(container, dims, sectionIndex);
       while (end < children.length && !isBreak(children[end])) {
         this.checkpoint();
         const candidate = makeContainer(children.slice(start, end + 1));
         const candidateMeasured = this.measureElement(candidate, dims, sectionIndex);
-        if (candidateMeasured.heightPt > maxFragmentHeight) break;
+        if (candidateMeasured.heightPt > maxFragmentHeight || sequential && this.columnContainerOverflows(candidate, dims)) break;
         container = candidate;
         measured = candidateMeasured;
         end++;
@@ -1001,6 +1667,76 @@ var PaginationEngine = class {
     }
     return blocks;
   }
+  /** Keep Word's paragraph space-before in the ordinary inter-block spacing budget. */
+  liftColumnSpaceBefore(container, dims) {
+    container.style.marginTop = "";
+    const first = container.firstElementChild;
+    if (!first || !this.isWordParagraphElement(first)) return;
+    const host = this.document.createElement("div");
+    host.style.width = `${dims.contentWidth}pt`;
+    host.appendChild(container);
+    this.stagingElement.appendChild(host);
+    try {
+      const spaceBefore = first.dataset.paginationColumnSpaceBefore ?? this.view.getComputedStyle(first).marginTop;
+      first.dataset.paginationColumnSpaceBefore = spaceBefore;
+      first.style.marginTop = "0";
+      container.style.marginTop = spaceBefore;
+    } finally {
+      container.remove();
+      host.remove();
+    }
+  }
+  /** A height-constrained multicol box overflows horizontally when it needs another column. */
+  columnContainerOverflows(element, dims) {
+    const host = this.document.createElement("div");
+    host.style.width = `${dims.contentWidth}pt`;
+    const clone = element.cloneNode(true);
+    host.appendChild(clone);
+    this.stagingElement.appendChild(host);
+    try {
+      if (clone.scrollWidth > clone.clientWidth + 1) return true;
+      return Array.from(clone.querySelectorAll('[data-keep-lines="true"]')).some((paragraph) => paragraph.getClientRects().length > 1);
+    } finally {
+      host.remove();
+    }
+  }
+  /**
+   * Reflow a final continuous column section against the actual remaining body band.
+   * A preceding title, running story or note reservation can make it shorter than the
+   * fresh-page band used while collecting source blocks. Split at source-child boundaries
+   * when the narrower band would create an extra horizontal column; the tail is reconsidered
+   * normally on the following page. No source child is duplicated or discarded.
+   */
+  reflowSequentialColumns(block, dims, availableHeightPt) {
+    if (block.element.dataset.paginationSequentialColumns !== "true" || availableHeightPt <= 0) return null;
+    const maximumHeight = this.smallestEffectiveContentHeight(dims, block.sectionIndex);
+    const height = Math.min(availableHeightPt, maximumHeight);
+    if (Math.abs(parseFloat(block.element.style.maxHeight) - height) < 0.01) return null;
+    const children = Array.from(block.element.children);
+    const make = (slice, limit) => {
+      const container = block.element.cloneNode(false);
+      container.style.maxHeight = `${limit}pt`;
+      for (const child of slice) container.appendChild(child.cloneNode(true));
+      this.liftColumnSpaceBefore(container, dims);
+      return container;
+    };
+    const whole = make(children, height);
+    if (!this.columnContainerOverflows(whole, dims)) {
+      return [this.measureElement(whole, dims, block.sectionIndex)];
+    }
+    let end = 0;
+    for (let count = 1; count < children.length; count++) {
+      this.checkpoint();
+      const candidate = make(children.slice(0, count), height);
+      if (this.columnContainerOverflows(candidate, dims)) break;
+      if (children[count - 1].dataset.keepWithNext !== "true") end = count;
+    }
+    if (end === 0) return null;
+    return [
+      this.measureElement(make(children.slice(0, end), height), dims, block.sectionIndex),
+      this.measureElement(make(children.slice(end), maximumHeight), dims, block.sectionIndex)
+    ];
+  }
   /**
    * Measures one element in the same hidden staging context used for the source blocks.
    * This is intentionally DOM-based: table row heights cannot be inferred from individual
@@ -1016,13 +1752,13 @@ var PaginationEngine = class {
     measurementHost.appendChild(measuredElement);
     this.stagingElement.appendChild(measurementHost);
     const rect = measuredElement.getBoundingClientRect();
-    const style = this.view.getComputedStyle(measuredElement);
+    const margins = collapsedBlockMarginsPx(this.view, measuredElement);
     const measured = {
       element,
       sectionIndex,
       heightPt: pxToPt(rect.height),
-      marginTopPt: pxToPt(parseFloat(style.marginTop) || 0),
-      marginBottomPt: pxToPt(parseFloat(style.marginBottom) || 0),
+      marginTopPt: pxToPt(margins.topPx),
+      marginBottomPt: pxToPt(margins.bottomPx),
       keepWithNext: element.dataset.keepWithNext === "true",
       keepLines: element.dataset.keepLines === "true",
       pageBreakBefore: element.dataset.pageBreakBefore === "true",
@@ -2250,6 +2986,10 @@ var PaginationEngine = class {
    * Deterministic: it depends only on the section's page setup and the registry's pre-measured
    * story heights, never on the page's content, which is what keeps it lazy-loading compatible.
    */
+  /** The body height a physical page may fill: its body band less any caller-requested reduction. */
+  bodyBudgetPt(bodyHeightPt, physicalPageNumber) {
+    return Math.max(0, bodyHeightPt - (this.bodyBudgetReductionsPt[physicalPageNumber] ?? 0));
+  }
   getPageBands(dims, sectionIndex, pageInSection, displayedPageNumber) {
     const sectionHf = this.hfRegistry.get(sectionIndex);
     return resolvePageBands(
@@ -2334,12 +3074,12 @@ var PaginationEngine = class {
       const currentPhysicalNumber = ownerNumbering.start !== void 0 ? ownerNumbering.start + pageInSection(pageSectionIndex) - 1 : precedingDisplayedPageNumber + 1;
       return currentPhysicalNumber + physicalPage - pageNumber;
     };
-    let { bodyHeight: effectiveContentHeight } = this.getPageBands(
+    let effectiveContentHeight = this.bodyBudgetPt(this.getPageBands(
       dimensionsFor(),
       pageSectionIndex,
       pageInSection(),
       displayedPageNumber()
-    );
+    ).bodyHeight, pageNumber);
     let remainingHeight = effectiveContentHeight;
     let prevMarginBottomPt = 0;
     let currentFootnoteIds = [];
@@ -2359,7 +3099,7 @@ var PaginationEngine = class {
         pageInSection(owner),
         displayedPageNumber(owner)
       );
-      effectiveContentHeight = bands.bodyHeight;
+      effectiveContentHeight = this.bodyBudgetPt(bands.bodyHeight, pageNumber);
       remainingHeight = effectiveContentHeight;
     };
     const admitCurrentPage = () => {
@@ -2494,7 +3234,7 @@ var PaginationEngine = class {
         pageInSection(),
         displayedPageNumber()
       );
-      effectiveContentHeight = newBands.bodyHeight;
+      effectiveContentHeight = this.bodyBudgetPt(newBands.bodyHeight, pageNumber);
       remainingHeight = effectiveContentHeight;
       prevMarginBottomPt = 0;
       currentFootnoteIds = [];
@@ -2657,6 +3397,16 @@ var PaginationEngine = class {
         isFirstOnPage,
         pageInSection(block.sectionIndex)
       );
+      const columnFragments = this.reflowSequentialColumns(
+        block,
+        blockDimensions,
+        remainingHeight - currentFootnoteHeight - additionalFootnoteHeight - effectiveMarginTop
+      );
+      if (columnFragments) {
+        blocks.splice(i, 1, ...columnFragments);
+        i--;
+        continue;
+      }
       const blockSpace = effectiveMarginTop + block.heightPt + additionalFootnoteHeight;
       const effectiveRemainingHeight = remainingHeight - currentFootnoteHeight;
       const bodyContentUsed = effectiveContentHeight - remainingHeight;
@@ -2891,7 +3641,7 @@ var PaginationEngine = class {
         context
       );
       const widthPercent = this.anchorNumber(anchor, "width-percent");
-      if (widthPercent !== void 0) {
+      if (widthPercent !== void 0 && widthPercent > 0) {
         anchor.style.width = `${widthReference.size * widthPercent / 100}pt`;
       }
       const heightReference = this.verticalAnchorReference(
@@ -2901,7 +3651,7 @@ var PaginationEngine = class {
         context
       );
       const heightPercent = this.anchorNumber(anchor, "height-percent");
-      if (heightPercent !== void 0 && anchor.dataset.docxAnchorAutofit !== "true") {
+      if (heightPercent !== void 0 && heightPercent > 0 && anchor.dataset.docxAnchorAutofit !== "true") {
         anchor.style.height = `${heightReference.size * heightPercent / 100}pt`;
       }
       const sizedRect = anchor.getBoundingClientRect();
@@ -2933,7 +3683,12 @@ var PaginationEngine = class {
         this.anchorNumber(anchor, "v-offset"),
         pageNumber
       );
+      const hostElement = anchor.parentElement?.closest("[data-source-anchor-id]");
+      const hostAnchorId = hostElement?.dataset.sourceAnchorId;
+      if (hostAnchorId) anchor.setAttribute(DRAWING_HOST_ATTRIBUTE, hostAnchorId);
       pageBox.appendChild(anchor);
+      if (hostElement && rendersOnlyItsLine(hostElement))
+        hostElement.setAttribute(HOSTS_PROMOTED_DRAWING_ATTRIBUTE, "true");
       anchor.style.position = "absolute";
       anchor.style.left = `${left}pt`;
       anchor.style.top = `${top}pt`;
@@ -3171,6 +3926,20 @@ var PaginationEngine = class {
         contentArea.style.height = `${Math.max(0, contentAreaHeight - notesHeightPt)}pt`;
       }
     }
+    alignExactLineBaselines(contentArea);
+    const paper = pageBox.getBoundingClientRect();
+    const header = pageBox.querySelector(`.${this.cssPrefix}header`);
+    const footer = pageBox.querySelector(`.${this.cssPrefix}footer`);
+    preserveExactLineInk(
+      contentArea,
+      Math.max(paper.top, header?.getBoundingClientRect().bottom ?? paper.top),
+      Math.min(
+        paper.bottom,
+        footer?.getBoundingClientRect().top ?? paper.bottom,
+        notesEl?.getBoundingClientRect().top ?? paper.bottom
+      ),
+      paper
+    );
     return {
       pageNumber,
       sectionIndex,
@@ -3222,6 +3991,22 @@ var WorkerOperationError = class extends Error {
 function workerError(message, code) {
   return new WorkerOperationError(message || "Unknown error", code);
 }
+function requireField(response, field) {
+  const value = response[field];
+  if (value === void 0 || value === null) {
+    throw workerError(
+      `The worker's "${response.type ?? "unknown"}" response reported success without its ${String(field)}`,
+      "missing_result"
+    );
+  }
+  return value;
+}
+function checkTimeout(timeoutMs, name) {
+  if (timeoutMs !== void 0 && !(Number.isFinite(timeoutMs) && timeoutMs > 0)) {
+    throw new RangeError(`${name} must be a positive, finite number of milliseconds; got ${timeoutMs}`);
+  }
+  return timeoutMs;
+}
 function workerErrorCode(error) {
   return error instanceof WorkerOperationError ? error.code : void 0;
 }
@@ -3250,6 +4035,7 @@ async function createWorkerDocxodus(options) {
   if (options?.signal?.aborted) {
     throw new Error("Worker creation aborted");
   }
+  const requestTimeoutMs = checkTimeout(options?.requestTimeoutMs, "requestTimeoutMs");
   const wasmBasePath = options?.wasmBasePath ?? deriveWasmBasePath();
   const workerScriptPath = new URL("./docxodus.worker.js", import.meta.url).href;
   const worker = new Worker(workerScriptPath, { type: "module" });
@@ -3292,13 +4078,54 @@ async function createWorkerDocxodus(options) {
   worker.onerror = (error) => {
     stopWorker(`Worker error: ${error.message}`);
   };
-  function sendRequest(request, transfer) {
+  worker.onmessageerror = () => {
+    for (const pending of [...pendingRequests.values()]) {
+      pending.reject(workerError(
+        "A worker response could not be deserialized, so every request in flight was rejected",
+        "message_error"
+      ));
+    }
+  };
+  function sendRequest(request, transfer, requestOptions) {
     return new Promise((resolve, reject) => {
       if (!isWorkerActive) {
         reject(new Error("Worker has been terminated"));
         return;
       }
-      pendingRequests.set(request.id, { resolve, reject });
+      const signal = requestOptions?.signal;
+      if (signal?.aborted) {
+        reject(workerError(`The worker request "${request.type}" was aborted before it was sent`, "aborted"));
+        return;
+      }
+      const timeoutMs = requestOptions?.timeoutMs ?? requestTimeoutMs;
+      let timer;
+      let onAbort;
+      const finish = () => {
+        pendingRequests.delete(request.id);
+        if (timer !== void 0) clearTimeout(timer);
+        if (onAbort) signal?.removeEventListener("abort", onAbort);
+      };
+      pendingRequests.set(request.id, {
+        resolve: (value) => {
+          finish();
+          resolve(value);
+        },
+        reject: (error) => {
+          finish();
+          reject(error);
+        }
+      });
+      const fail2 = (error) => pendingRequests.get(request.id)?.reject(error);
+      if (timeoutMs !== void 0) {
+        timer = setTimeout(() => fail2(workerError(
+          `The worker request "${request.type}" timed out after ${timeoutMs} ms`,
+          "timeout"
+        )), timeoutMs);
+      }
+      if (signal) {
+        onAbort = () => fail2(workerError(`The worker request "${request.type}" was aborted`, "aborted"));
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
       try {
         if (transfer && transfer.length > 0) {
           worker.postMessage(request, transfer);
@@ -3306,8 +4133,7 @@ async function createWorkerDocxodus(options) {
           worker.postMessage(request);
         }
       } catch (error) {
-        pendingRequests.delete(request.id);
-        reject(error instanceof Error ? error : new Error(String(error)));
+        fail2(error instanceof Error ? error : new Error(String(error)));
       }
     });
   }
@@ -3321,391 +4147,349 @@ async function createWorkerDocxodus(options) {
     stopWorker("Worker initialization failed");
     throw error;
   }
-  return {
-    async generatePackageManifest(document2, limits) {
-      const bytes = await toBytes(document2);
-      const response = await sendRequest(
-        {
-          id: generateId(),
-          type: "generatePackageManifest",
-          documentBytes: bytes,
-          limits,
-          representation: "object"
-        },
-        [bytes.buffer]
-      );
-      return response.manifest;
-    },
-    async verifyDeliverable(document2, baseline, request) {
-      const bytes = await toBytes(document2);
-      const baselineBytes = baseline === void 0 ? void 0 : await toBytes(baseline);
-      const transfer = [bytes.buffer];
-      if (baselineBytes !== void 0) transfer.push(baselineBytes.buffer);
-      const response = await sendRequest(
-        {
-          id: generateId(),
-          type: "verifyDeliverable",
-          documentBytes: bytes,
-          baselineBytes,
-          requestJson: request === void 0 ? void 0 : serializeVerificationRequest(request)
-        },
-        transfer
-      );
-      if (!response.success || !response.verification) {
-        throw new Error(response.error ?? "verifyDeliverable failed");
-      }
-      return response.verification;
-    },
-    async proveRedlineReversibility(baseline, intendedFinal, redline) {
-      const baselineBytes = await toBytes(baseline);
-      const intendedFinalBytes = await toBytes(intendedFinal);
-      const redlineBytes = await toBytes(redline);
-      const response = await sendRequest(
-        {
-          id: generateId(),
-          type: "proveRedlineReversibility",
-          baselineBytes,
-          intendedFinalBytes,
-          redlineBytes
-        },
-        [baselineBytes.buffer, intendedFinalBytes.buffer, redlineBytes.buffer]
-      );
-      if (!response.success || !response.proof) {
-        throw new Error(response.error ?? "proveRedlineReversibility failed");
-      }
-      return response.proof;
-    },
-    async getSemanticChanges(left, right, settings) {
-      const leftBytes = await toBytes(left);
-      const rightBytes = await toBytes(right);
-      const response = await sendRequest(
-        {
-          id: generateId(),
-          type: "getSemanticChanges",
-          leftBytes,
-          rightBytes,
-          settings
-        },
-        [leftBytes.buffer, rightBytes.buffer]
-      );
-      return response.semanticChanges;
-    },
-    async createExternalAnnotationSet(document2, documentId) {
-      const bytes = await toBytes(document2);
-      const response = await sendRequest(
-        { id: generateId(), type: "createExternalAnnotationSet", documentBytes: bytes, documentId },
-        [bytes.buffer]
-      );
-      if (!response.success || !response.annotationSet) {
-        throw new Error(response.error ?? "createExternalAnnotationSet failed");
-      }
-      return response.annotationSet;
-    },
-    async validateExternalAnnotations(document2, annotationSet) {
-      const bytes = await toBytes(document2);
-      const response = await sendRequest(
-        { id: generateId(), type: "validateExternalAnnotations", documentBytes: bytes, annotationSet },
-        [bytes.buffer]
-      );
-      if (!response.success || !response.validation) {
-        throw new Error(response.error ?? "validateExternalAnnotations failed");
-      }
-      return response.validation;
-    },
-    async projectAnnotationsOntoHtml(html, annotationSet, projectionOptions) {
-      const response = await sendRequest({
-        id: generateId(),
-        type: "projectAnnotationsOntoHtml",
-        html,
-        annotationSet,
-        projectionOptions
-      });
-      if (!response.success || response.html === void 0) {
-        throw new Error(response.error ?? "projectAnnotationsOntoHtml failed");
-      }
-      return response.html;
-    },
-    async convertDocxToHtmlWithExternalAnnotations(document2, annotationSet, conversionOptions2, projectionOptions) {
-      const bytes = await toBytes(document2);
-      const response = await sendRequest(
-        {
+  const createApi = (requestOptions) => {
+    const send = (request, transfer) => sendRequest(request, transfer, requestOptions);
+    return {
+      async generatePackageManifest(document2, limits) {
+        const bytes = await toBytes(document2);
+        const response = await send(
+          {
+            id: generateId(),
+            type: "generatePackageManifest",
+            documentBytes: bytes,
+            limits,
+            representation: "object"
+          },
+          [bytes.buffer]
+        );
+        return requireField(response, "manifest");
+      },
+      async verifyDeliverable(document2, baseline, request) {
+        const bytes = await toBytes(document2);
+        const baselineBytes = baseline === void 0 ? void 0 : await toBytes(baseline);
+        const transfer = [bytes.buffer];
+        if (baselineBytes !== void 0) transfer.push(baselineBytes.buffer);
+        const response = await send(
+          {
+            id: generateId(),
+            type: "verifyDeliverable",
+            documentBytes: bytes,
+            baselineBytes,
+            requestJson: request === void 0 ? void 0 : serializeVerificationRequest(request)
+          },
+          transfer
+        );
+        return requireField(response, "verification");
+      },
+      async proveRedlineReversibility(baseline, intendedFinal, redline) {
+        const baselineBytes = await toBytes(baseline);
+        const intendedFinalBytes = await toBytes(intendedFinal);
+        const redlineBytes = await toBytes(redline);
+        const response = await send(
+          {
+            id: generateId(),
+            type: "proveRedlineReversibility",
+            baselineBytes,
+            intendedFinalBytes,
+            redlineBytes
+          },
+          [baselineBytes.buffer, intendedFinalBytes.buffer, redlineBytes.buffer]
+        );
+        return requireField(response, "proof");
+      },
+      async getSemanticChanges(left, right, settings) {
+        const leftBytes = await toBytes(left);
+        const rightBytes = await toBytes(right);
+        const response = await send(
+          {
+            id: generateId(),
+            type: "getSemanticChanges",
+            leftBytes,
+            rightBytes,
+            settings
+          },
+          [leftBytes.buffer, rightBytes.buffer]
+        );
+        return requireField(response, "semanticChanges");
+      },
+      async createExternalAnnotationSet(document2, documentId) {
+        const bytes = await toBytes(document2);
+        const response = await send(
+          { id: generateId(), type: "createExternalAnnotationSet", documentBytes: bytes, documentId },
+          [bytes.buffer]
+        );
+        return requireField(response, "annotationSet");
+      },
+      async validateExternalAnnotations(document2, annotationSet) {
+        const bytes = await toBytes(document2);
+        const response = await send(
+          { id: generateId(), type: "validateExternalAnnotations", documentBytes: bytes, annotationSet },
+          [bytes.buffer]
+        );
+        return requireField(response, "validation");
+      },
+      async projectAnnotationsOntoHtml(html, annotationSet, projectionOptions) {
+        const response = await send({
           id: generateId(),
-          type: "convertDocxToHtmlWithExternalAnnotations",
-          documentBytes: bytes,
+          type: "projectAnnotationsOntoHtml",
+          html,
           annotationSet,
-          conversionOptions: conversionOptions2,
           projectionOptions
-        },
-        [bytes.buffer]
-      );
-      if (!response.success || response.html === void 0) {
-        throw new Error(response.error ?? "convertDocxToHtmlWithExternalAnnotations failed");
-      }
-      return response.html;
-    },
-    async exportToOpenContract(document2) {
-      const bytes = await toBytes(document2);
-      const response = await sendRequest(
-        { id: generateId(), type: "exportToOpenContract", documentBytes: bytes },
-        [bytes.buffer]
-      );
-      if (!response.success || !response.export) {
-        throw new Error(response.error ?? "exportToOpenContract failed");
-      }
-      return response.export;
-    },
-    async generatePackageManifestJson(document2, limits) {
-      const bytes = await toBytes(document2);
-      const response = await sendRequest(
-        {
-          id: generateId(),
-          type: "generatePackageManifest",
-          documentBytes: bytes,
-          limits,
-          representation: "json"
-        },
-        [bytes.buffer]
-      );
-      if (response.manifestJson === void 0) {
-        throw new Error("Package manifest worker response omitted canonical JSON");
-      }
-      return response.manifestJson;
-    },
-    async projectReviewProfile(document2, profile, maximumOutputBytes) {
-      const bytes = await toBytes(document2);
-      const response = await sendRequest(
-        {
-          id: generateId(),
-          type: "projectReviewProfile",
-          documentBytes: bytes,
-          profile,
-          maximumOutputBytes
-        },
-        [bytes.buffer]
-      );
-      if (!response.documentBytes || response.documentBytes.byteLength === 0) {
-        throw new Error(`Failed to derive the ${profile} review profile`);
-      }
-      return response.documentBytes;
-    },
-    async convertDocxToHtml(document2, options2, maximumOutputBytes) {
-      const bytes = await toBytes(document2);
-      const response = await sendRequest(
-        {
-          id: generateId(),
-          type: "convertDocxToHtml",
-          documentBytes: bytes,
-          options: options2,
-          maximumOutputBytes
-        },
-        [bytes.buffer]
-      );
-      return response.html;
-    },
-    async compareDocuments(original, modified, options2) {
-      const originalBytes = await toBytes(original);
-      const modifiedBytes = await toBytes(modified);
-      const response = await sendRequest(
-        {
-          id: generateId(),
-          type: "compareDocuments",
-          originalBytes,
-          modifiedBytes,
-          options: options2
-        },
-        [originalBytes.buffer, modifiedBytes.buffer]
-      );
-      return response.documentBytes;
-    },
-    async compareDocumentsToHtml(original, modified, options2) {
-      const originalBytes = await toBytes(original);
-      const modifiedBytes = await toBytes(modified);
-      const response = await sendRequest(
-        {
-          id: generateId(),
-          type: "compareDocumentsToHtml",
-          originalBytes,
-          modifiedBytes,
-          options: options2
-        },
-        [originalBytes.buffer, modifiedBytes.buffer]
-      );
-      return response.html;
-    },
-    async getRevisions(document2) {
-      const bytes = await toBytes(document2);
-      const response = await sendRequest(
-        {
-          id: generateId(),
-          type: "getRevisions",
-          documentBytes: bytes
-        },
-        [bytes.buffer]
-      );
-      return response.revisions;
-    },
-    async getComments(document2) {
-      const bytes = await toBytes(document2);
-      const response = await sendRequest(
-        { id: generateId(), type: "getComments", documentBytes: bytes },
-        [bytes.buffer]
-      );
-      return response.comments;
-    },
-    async getDocumentMetadata(document2) {
-      const bytes = await toBytes(document2);
-      const response = await sendRequest(
-        {
-          id: generateId(),
-          type: "getDocumentMetadata",
-          documentBytes: bytes
-        },
-        [bytes.buffer]
-      );
-      return response.metadata;
-    },
-    async getVersion() {
-      const response = await sendRequest({
-        id: generateId(),
-        type: "getVersion"
-      });
-      return response.version;
-    },
-    prepare() {
-      if (preparePromise) {
-        return preparePromise;
-      }
-      preparePromise = sendRequest({
-        id: generateId(),
-        type: "prepare"
-      }).then(() => void 0);
-      preparePromise.catch(() => {
-        preparePromise = null;
-      });
-      return preparePromise;
-    },
-    async openDocxSession(document2, settings) {
-      const bytes = await toBytes(document2);
-      const settingsJson = settings ? JSON.stringify(settings) : "";
-      const openResponse = await sendRequest(
-        {
-          id: generateId(),
-          type: "sessionOpen",
-          documentBytes: bytes,
-          settingsJson
-        },
-        [bytes.buffer]
-      );
-      if (!openResponse.success || openResponse.handle === void 0) {
-        throw new Error(
-          `Failed to open worker DocxSession: ${openResponse.error ?? "unknown error"}`
-        );
-      }
-      const handle = openResponse.handle;
-      return {
-        async getPackageManifest() {
-          const res = await sendRequest({
+        });
+        return requireField(response, "html");
+      },
+      async convertDocxToHtmlWithExternalAnnotations(document2, annotationSet, conversionOptions2, projectionOptions) {
+        const bytes = await toBytes(document2);
+        const response = await send(
+          {
             id: generateId(),
-            type: "sessionGetPackageManifest",
-            handle
-          });
-          if (!res.success || !res.manifest) {
-            throw new Error(res.error ?? "sessionGetPackageManifest failed");
-          }
-          return res.manifest;
-        },
-        async getSemanticChanges() {
-          const res = await sendRequest({
+            type: "convertDocxToHtmlWithExternalAnnotations",
+            documentBytes: bytes,
+            annotationSet,
+            conversionOptions: conversionOptions2,
+            projectionOptions
+          },
+          [bytes.buffer]
+        );
+        return requireField(response, "html");
+      },
+      async exportToOpenContract(document2) {
+        const bytes = await toBytes(document2);
+        const response = await send(
+          { id: generateId(), type: "exportToOpenContract", documentBytes: bytes },
+          [bytes.buffer]
+        );
+        return requireField(response, "export");
+      },
+      async generatePackageManifestJson(document2, limits) {
+        const bytes = await toBytes(document2);
+        const response = await send(
+          {
             id: generateId(),
-            type: "sessionGetSemanticChanges",
-            handle
-          });
-          if (!res.success || !res.semanticChanges) {
-            throw new Error(res.error ?? "sessionGetSemanticChanges failed");
-          }
-          return res.semanticChanges;
-        },
-        async verifyDeliverable(request) {
-          const res = await sendRequest({
+            type: "generatePackageManifest",
+            documentBytes: bytes,
+            limits,
+            representation: "json"
+          },
+          [bytes.buffer]
+        );
+        return requireField(response, "manifestJson");
+      },
+      async projectReviewProfile(document2, profile, maximumOutputBytes) {
+        const bytes = await toBytes(document2);
+        const response = await send(
+          {
             id: generateId(),
-            type: "sessionVerifyDeliverable",
-            handle,
-            requestJson: request === void 0 ? void 0 : serializeVerificationRequest(request)
-          });
-          if (!res.success || !res.verification) {
-            throw new Error(res.error ?? "sessionVerifyDeliverable failed");
-          }
-          return res.verification;
-        },
-        async addAnnotation(anchorId, span, annotation) {
-          const res = await sendRequest({
+            type: "projectReviewProfile",
+            documentBytes: bytes,
+            profile,
+            maximumOutputBytes
+          },
+          [bytes.buffer]
+        );
+        if (!response.documentBytes || response.documentBytes.byteLength === 0) {
+          throw new Error(`Failed to derive the ${profile} review profile`);
+        }
+        return response.documentBytes;
+      },
+      async convertDocxToHtml(document2, options2, maximumOutputBytes) {
+        const bytes = await toBytes(document2);
+        const response = await send(
+          {
             id: generateId(),
-            type: "sessionAddAnnotation",
-            handle,
-            anchorId,
-            spanJson: span ? JSON.stringify(span) : "",
-            annotationJson: JSON.stringify(annotation)
-          });
-          if (!res.success) {
-            throw new Error(res.error ?? "sessionAddAnnotation failed");
-          }
-          return res.result;
-        },
-        async removeAnnotation(annotationId) {
-          const res = await sendRequest({
+            type: "convertDocxToHtml",
+            documentBytes: bytes,
+            options: options2,
+            maximumOutputBytes
+          },
+          [bytes.buffer]
+        );
+        return requireField(response, "html");
+      },
+      async compareDocuments(original, modified, options2) {
+        const originalBytes = await toBytes(original);
+        const modifiedBytes = await toBytes(modified);
+        const response = await send(
+          {
             id: generateId(),
-            type: "sessionRemoveAnnotation",
-            handle,
-            annotationId
-          });
-          if (!res.success) {
-            throw new Error(res.error ?? "sessionRemoveAnnotation failed");
-          }
-          return res.result;
-        },
-        async updateAnnotation(annotationId, update) {
-          const res = await sendRequest({
+            type: "compareDocuments",
+            originalBytes,
+            modifiedBytes,
+            options: options2
+          },
+          [originalBytes.buffer, modifiedBytes.buffer]
+        );
+        return requireField(response, "documentBytes");
+      },
+      async compareDocumentsToHtml(original, modified, options2) {
+        const originalBytes = await toBytes(original);
+        const modifiedBytes = await toBytes(modified);
+        const response = await send(
+          {
             id: generateId(),
-            type: "sessionUpdateAnnotation",
-            handle,
-            annotationId,
-            updateJson: JSON.stringify(update)
-          });
-          if (!res.success) {
-            throw new Error(res.error ?? "sessionUpdateAnnotation failed");
-          }
-          return res.result;
-        },
-        async moveAnnotation(annotationId, newAnchorId, newSpan) {
-          const res = await sendRequest({
+            type: "compareDocumentsToHtml",
+            originalBytes,
+            modifiedBytes,
+            options: options2
+          },
+          [originalBytes.buffer, modifiedBytes.buffer]
+        );
+        return requireField(response, "html");
+      },
+      async getRevisions(document2) {
+        const bytes = await toBytes(document2);
+        const response = await send(
+          {
             id: generateId(),
-            type: "sessionMoveAnnotation",
-            handle,
-            annotationId,
-            newAnchorId,
-            newSpanJson: newSpan ? JSON.stringify(newSpan) : ""
-          });
-          if (!res.success) {
-            throw new Error(res.error ?? "sessionMoveAnnotation failed");
-          }
-          return res.result;
-        },
-        async close() {
-          await sendRequest({
+            type: "getRevisions",
+            documentBytes: bytes
+          },
+          [bytes.buffer]
+        );
+        return requireField(response, "revisions");
+      },
+      async getComments(document2) {
+        const bytes = await toBytes(document2);
+        const response = await send(
+          { id: generateId(), type: "getComments", documentBytes: bytes },
+          [bytes.buffer]
+        );
+        return requireField(response, "comments");
+      },
+      async getDocumentMetadata(document2) {
+        const bytes = await toBytes(document2);
+        const response = await send(
+          {
             id: generateId(),
-            type: "sessionClose",
-            handle
-          });
+            type: "getDocumentMetadata",
+            documentBytes: bytes
+          },
+          [bytes.buffer]
+        );
+        return requireField(response, "metadata");
+      },
+      async getVersion() {
+        const response = await send({
+          id: generateId(),
+          type: "getVersion"
+        });
+        return requireField(response, "version");
+      },
+      prepare() {
+        if (preparePromise) {
+          return preparePromise;
         }
-      };
-    },
-    terminate() {
-      stopWorker("Worker terminated");
-    },
-    isActive() {
-      return isWorkerActive;
-    }
+        preparePromise = send({
+          id: generateId(),
+          type: "prepare"
+        }).then(() => void 0);
+        preparePromise.catch(() => {
+          preparePromise = null;
+        });
+        return preparePromise;
+      },
+      async openDocxSession(document2, settings) {
+        const bytes = await toBytes(document2);
+        const settingsJson = settings ? JSON.stringify(settings) : "";
+        const openResponse = await send(
+          {
+            id: generateId(),
+            type: "sessionOpen",
+            documentBytes: bytes,
+            settingsJson
+          },
+          [bytes.buffer]
+        );
+        const handle = requireField(openResponse, "handle");
+        return {
+          async getPackageManifest() {
+            const res = await send({
+              id: generateId(),
+              type: "sessionGetPackageManifest",
+              handle
+            });
+            return requireField(res, "manifest");
+          },
+          async getSemanticChanges() {
+            const res = await send({
+              id: generateId(),
+              type: "sessionGetSemanticChanges",
+              handle
+            });
+            return requireField(res, "semanticChanges");
+          },
+          async verifyDeliverable(request) {
+            const res = await send({
+              id: generateId(),
+              type: "sessionVerifyDeliverable",
+              handle,
+              requestJson: request === void 0 ? void 0 : serializeVerificationRequest(request)
+            });
+            return requireField(res, "verification");
+          },
+          async addAnnotation(anchorId, span, annotation) {
+            const res = await send({
+              id: generateId(),
+              type: "sessionAddAnnotation",
+              handle,
+              anchorId,
+              spanJson: span ? JSON.stringify(span) : "",
+              annotationJson: JSON.stringify(annotation)
+            });
+            return requireField(res, "result");
+          },
+          async removeAnnotation(annotationId) {
+            const res = await send({
+              id: generateId(),
+              type: "sessionRemoveAnnotation",
+              handle,
+              annotationId
+            });
+            return requireField(res, "result");
+          },
+          async updateAnnotation(annotationId, update) {
+            const res = await send({
+              id: generateId(),
+              type: "sessionUpdateAnnotation",
+              handle,
+              annotationId,
+              updateJson: JSON.stringify(update)
+            });
+            return requireField(res, "result");
+          },
+          async moveAnnotation(annotationId, newAnchorId, newSpan) {
+            const res = await send({
+              id: generateId(),
+              type: "sessionMoveAnnotation",
+              handle,
+              annotationId,
+              newAnchorId,
+              newSpanJson: newSpan ? JSON.stringify(newSpan) : ""
+            });
+            return requireField(res, "result");
+          },
+          async close() {
+            await sendRequest(
+              { id: generateId(), type: "sessionClose", handle },
+              void 0,
+              { timeoutMs: requestOptions?.timeoutMs }
+            );
+          }
+        };
+      },
+      terminate() {
+        stopWorker("Worker terminated");
+      },
+      withRequestOptions(more) {
+        checkTimeout(more.timeoutMs, "timeoutMs");
+        return createApi({ ...requestOptions, ...more });
+      },
+      isActive() {
+        return isWorkerActive;
+      }
+    };
   };
+  return createApi();
 }
 
 // src/font-contract.ts
@@ -4048,6 +4832,45 @@ function collectFontInventory(document2, limits) {
     }
     uses.push({ element, requestKey: key, originalStyle: element.getAttribute("style") });
   }
+  const requestsByStack = /* @__PURE__ */ new Map();
+  for (const [key, request] of requests) {
+    const stackKey = JSON.stringify([request.familyStack, request.familyKinds]);
+    const list = requestsByStack.get(stackKey) ?? [];
+    list.push({ key, request });
+    requestsByStack.set(stackKey, list);
+  }
+  const closestRequestKey = (descriptor) => {
+    const candidates = requestsByStack.get(JSON.stringify([descriptor.familyStack, descriptor.familyKinds]));
+    if (!candidates) return void 0;
+    let best;
+    for (const { key, request } of candidates) {
+      const distance = (request.style === descriptor.style ? 0 : 1e4) + Math.abs(request.weight - descriptor.weight) + Math.abs(request.stretch - descriptor.stretch);
+      if (!best || distance < best.distance || distance === best.distance && compareText(key, best.key) < 0) {
+        best = { key, distance };
+      }
+    }
+    return best?.key;
+  };
+  const used = new Set(uses.map((use) => use.element));
+  for (const element of Array.from(document2.body.querySelectorAll("*"))) {
+    if (!(element instanceof view.HTMLElement) || used.has(element)) continue;
+    if (/^(?:script|style|template|noscript)$/i.test(element.localName)) continue;
+    if (!participatesInRendering(element, view)) continue;
+    const computed = view.getComputedStyle(element);
+    const parsedFamilies = parseCssFontFamilyTokens(computed.fontFamily);
+    if (parsedFamilies.length === 0) continue;
+    const descriptor = {
+      familyStack: parsedFamilies.map(({ name }) => name),
+      familyKinds: parsedFamilies.map(({ kind }) => kind),
+      style: faceStyle(computed.fontStyle),
+      weight: faceWeight(computed.fontWeight),
+      stretch: faceStretch(computed.fontStretch)
+    };
+    const exactKey = requestKey(descriptor);
+    const key = requests.has(exactKey) ? exactKey : closestRequestKey(descriptor);
+    if (key === void 0) continue;
+    uses.push({ element, requestKey: key, originalStyle: element.getAttribute("style") });
+  }
   const ordered = Array.from(requests, ([key, request]) => ({ key, request })).sort((left, right) => compareText(left.key, right.key));
   const idByKey = /* @__PURE__ */ new Map();
   const result = Object.freeze(ordered.map(({ key, request }, index) => {
@@ -4908,6 +5731,7 @@ var REPORT_SCHEMA = "https://docxodus.dev/schemas/render/render-report/v2";
 var TEXT_ENCODER2 = new TextEncoder();
 var ALLOWED_REVIEW_PROFILES = /* @__PURE__ */ new Set(["final", "original", "markup"]);
 var ALLOWED_COMMENT_PROFILES = /* @__PURE__ */ new Set(["hidden", "inline", "endnotes", "margin"]);
+var ALLOWED_MARKUP_PRESENTATIONS = /* @__PURE__ */ new Set(["docxodus", "word"]);
 var ALLOWED_UNSUPPORTED_POLICIES = /* @__PURE__ */ new Set(["warn", "strict"]);
 var PACKAGE_LIMIT_FINDINGS = /* @__PURE__ */ new Set([
   "entry_count_limit_exceeded",
@@ -4983,6 +5807,23 @@ function normalizeOptions(options) {
       "Use unchanged source bytes for markup, or choose final/original."
     );
   }
+  const markupPresentation = options.markupPresentation ?? "docxodus";
+  if (!ALLOWED_MARKUP_PRESENTATIONS.has(markupPresentation)) {
+    fail(
+      "invalid_argument",
+      "input_validation",
+      "markupPresentation is invalid.",
+      "Use docxodus or word."
+    );
+  }
+  if (markupPresentation !== "docxodus" && options.reviewProfile !== "markup") {
+    fail(
+      "invalid_argument",
+      "input_validation",
+      "markupPresentation applies only to the markup profile.",
+      "Omit markupPresentation, or use reviewProfile markup."
+    );
+  }
   const unsupportedContent = options.unsupportedContent ?? "warn";
   if (!ALLOWED_UNSUPPORTED_POLICIES.has(unsupportedContent)) {
     fail(
@@ -5121,6 +5962,7 @@ function normalizeOptions(options) {
     expectedSourceDigest: options.expectedSourceDigest,
     reviewProfile: options.reviewProfile,
     reviewProfileAlreadyApplied,
+    markupPresentation,
     commentProfile: options.commentProfile,
     title,
     unsupportedContent,
@@ -5169,6 +6011,22 @@ async function ownedBytes(document2, maximum, signal) {
 function monotonicNow() {
   return globalThis.performance?.now() ?? Date.now();
 }
+function checkpointWordText(state) {
+  if (state.signal?.aborted)
+    fail(
+      "operation_cancelled",
+      state.phase,
+      "Export was cancelled during text layout.",
+      "Retry with a non-aborted signal."
+    );
+  if (monotonicNow() >= state.deadline)
+    fail(
+      "readiness_timeout",
+      state.phase,
+      "Export timed out during text layout.",
+      "Increase timeoutMs or reduce document complexity."
+    );
+}
 async function runPhase(state, phase, pending, operation) {
   state.phase = phase;
   const started = monotonicNow();
@@ -5382,6 +6240,26 @@ async function boundedResponseBytes(response, maximum, label) {
   }
   return bytes;
 }
+var hostVerifiedAssetManifestSha256;
+function attestHostVerifiedRuntimeAssets(manifestSha256) {
+  if (typeof manifestSha256 !== "string" || !/^[0-9a-f]{64}$/.test(manifestSha256)) {
+    fail(
+      "unsupported_runtime",
+      "wasm_initialization",
+      "The host runtime asset attestation is not a SHA-256 digest.",
+      "Use the bootstrap module @docxodus/export generates."
+    );
+  }
+  if (hostVerifiedAssetManifestSha256 !== void 0 && hostVerifiedAssetManifestSha256 !== manifestSha256) {
+    fail(
+      "unsupported_runtime",
+      "wasm_initialization",
+      "The host runtime asset attestation may be set only once.",
+      "Load one host bootstrap module per page."
+    );
+  }
+  hostVerifiedAssetManifestSha256 = manifestSha256;
+}
 async function loadRuntimeAssetIdentity(wasmBasePath, signal) {
   const manifestUrl = new URL("./export-assets.json", import.meta.url);
   const response = await globalThis.fetch(manifestUrl, {
@@ -5539,7 +6417,8 @@ async function loadRuntimeAssetIdentity(wasmBasePath, signal) {
       "Deploy the bundle and asset graph from the same Docxodus build."
     );
   }
-  const verifiedRuntimeAssets = assets.filter((entry) => entry.path === "./docxodus.worker.js" || entry.path.startsWith("./wasm/_framework/"));
+  const hostVerified = hostVerifiedAssetManifestSha256 !== void 0 && await sha2562(graphBytes) === hostVerifiedAssetManifestSha256;
+  const verifiedRuntimeAssets = hostVerified ? [] : assets.filter((entry) => entry.path === "./docxodus.worker.js" || entry.path.startsWith("./wasm/_framework/"));
   const resolvedWasmBasePath = new URL(
     wasmBasePath.endsWith("/") ? wasmBasePath : `${wasmBasePath}/`,
     import.meta.url
@@ -6181,6 +7060,7 @@ function conversionOptions(options) {
     renderFootnotesAndEndnotes: true,
     renderHeadersAndFooters: true,
     renderTrackedChanges: options.reviewProfile === "markup",
+    revisionPresentation: options.markupPresentation === "word" ? 1 /* Word */ : 0 /* Docxodus */,
     showDeletedContent: true,
     renderMoveOperations: true,
     renderUnsupportedContentPlaceholders: true,
@@ -7070,7 +7950,7 @@ function finalizePageTree(document2, pages, state, options) {
   style.textContent = standaloneStyle(pages);
   document2.head.appendChild(style);
 }
-function assertNoClippedContent(document2) {
+function findClippedContent(document2) {
   for (const footnotes of Array.from(document2.querySelectorAll(".page-footnotes"))) {
     if (footnotes.scrollHeight <= footnotes.clientHeight + 1) continue;
     const boundary = footnotes.getBoundingClientRect().bottom;
@@ -7084,24 +7964,33 @@ function assertNoClippedContent(document2) {
       );
     }
   }
+  const clipped = [];
   for (const content of Array.from(document2.querySelectorAll(".page-content"))) {
     if (content.scrollHeight > content.clientHeight + 1) {
       const pageNumber = content.closest(".page-box")?.dataset.pageNumber ?? "unknown";
       const boundary = content.getBoundingClientRect().bottom;
-      const overflow = Array.from(content.querySelectorAll("*")).map((element) => ({
+      const overflowing = Array.from(content.querySelectorAll("*")).map((element) => ({
         element,
         bottom: element.getBoundingClientRect().bottom
-      })).filter(({ bottom }) => bottom > boundary + 1).sort((left, right) => right.bottom - left.bottom).slice(0, 3).map(({ element, bottom }) => `${element.localName}${element.className ? `.${String(element.className).trim().replace(/\s+/g, ".")}` : ""} (+${(bottom - boundary).toFixed(1)}px)`);
-      if (overflow.length === 0) continue;
-      fail(
-        "pagination_failure",
-        "running_story_placement",
-        `Page ${pageNumber} body content is clipped (${content.scrollHeight}px scroll height in a ${content.clientHeight}px band; ${overflow.join(", ")}).`,
-        "Split the oversized block or reduce its dimensions before export."
-      );
+      })).filter(({ element, bottom }) => bottom > boundary + 1 && !isPreservedExactLineInk(element, content)).sort((left, right) => right.bottom - left.bottom);
+      if (overflowing.length === 0) continue;
+      const overflow = overflowing.slice(0, 3).map(({ element, bottom }) => `${element.localName}${element.className ? `.${String(element.className).trim().replace(/\s+/g, ".")}` : ""} (+${(bottom - boundary).toFixed(1)}px)`);
+      clipped.push({
+        pageNumber: Number.parseInt(pageNumber, 10),
+        overflowPx: overflowing[0].bottom - boundary,
+        message: `Page ${pageNumber} body content is clipped (${content.scrollHeight}px scroll height in a ${content.clientHeight}px band; ${overflow.join(", ")}).`
+      });
     }
   }
+  return clipped;
 }
+var MAX_BODY_REFLOW_ROUNDS = 3;
+var BodyReflowRequest = class extends Error {
+  constructor() {
+    super("body reflow requested");
+    this.name = "BodyReflowRequest";
+  }
+};
 function treeSignature(document2, pages) {
   const geometry = pages.map((page) => {
     const rect = page.getBoundingClientRect();
@@ -7241,11 +8130,16 @@ function automaticResourceCount(document2) {
   }
   return { count, bytes };
 }
+function markupPresentationField(options) {
+  return options.markupPresentation === "word" ? { markupPresentation: "word" } : {};
+}
 async function layoutDigestForOptions(options) {
   const layoutContract = {
     title: options.title,
     reviewProfile: options.reviewProfile,
     reviewProfileAlreadyApplied: options.reviewProfileAlreadyApplied,
+    // Absent for the default, so default layouts keep the digest they had before the option.
+    ...markupPresentationField(options),
     commentProfile: options.commentProfile,
     pagination: {
       mode: "paginated",
@@ -7349,28 +8243,6 @@ function storyForAnchor(anchorId) {
   if (scope === "cmt") return "comment";
   return "body";
 }
-function visibleRectWithinPage(document2, element, page) {
-  const pageRect = page.getBoundingClientRect();
-  const rect = element.getBoundingClientRect();
-  let left = Math.max(rect.left, pageRect.left);
-  let top = Math.max(rect.top, pageRect.top);
-  let right = Math.min(rect.right, pageRect.right);
-  let bottom = Math.min(rect.bottom, pageRect.bottom);
-  const clips = (value) => value === "hidden" || value === "clip" || value === "scroll" || value === "auto";
-  for (let ancestor = element.parentElement; ancestor && ancestor !== page; ancestor = ancestor.parentElement) {
-    const style = document2.defaultView.getComputedStyle(ancestor);
-    const ancestorRect = ancestor.getBoundingClientRect();
-    if (clips(style.overflowX)) {
-      left = Math.max(left, ancestorRect.left);
-      right = Math.min(right, ancestorRect.right);
-    }
-    if (clips(style.overflowY)) {
-      top = Math.max(top, ancestorRect.top);
-      bottom = Math.min(bottom, ancestorRect.bottom);
-    }
-  }
-  return { left, top, right, bottom };
-}
 function assertStandaloneResourceAudit(document2) {
   if (document2.querySelector(
     "script, iframe, object, embed, video, audio, source, track, link, base, meta[http-equiv='refresh' i]"
@@ -7475,8 +8347,7 @@ async function verifyOfflineReopen(hostDocument, html, expectedPageMap, state) {
       )) {
         const style = reopened.defaultView.getComputedStyle(element);
         if (style.display === "none" || style.visibility === "hidden") continue;
-        const rect = element.getBoundingClientRect();
-        const visible = visibleRectWithinPage(reopened, element, page);
+        const { rect, visible } = measureRenderedSource(reopened.defaultView, element, page, pageRect);
         if (rect.width <= 0 || rect.height <= 0 || visible.right <= visible.left || visible.bottom <= visible.top) continue;
         const anchorId = element.dataset.sourceAnchorId;
         actualFragments.push({
@@ -7529,6 +8400,7 @@ function reportBase(manifest, sourceBytes, derivedManifest, derivedBytes, option
     options: {
       reviewProfile: options.reviewProfile,
       reviewProfileAlreadyApplied: options.reviewProfileAlreadyApplied,
+      ...markupPresentationField(options),
       commentProfile: options.commentProfile,
       title: options.title,
       outputs: ["html"],
@@ -7779,6 +8651,8 @@ async function convertDocxToPaginatedHtml(document2, requestedOptions) {
     });
     preflightConvertedHtml(convertedHtml, options);
     const attemptCheckpoint = checkpointAttemptState(state);
+    const bodyBudgetReductionsPt = {};
+    let bodyReflowRounds = 0;
     let finalized;
     let firstAttemptSignature;
     let firstAttemptFontIdentity;
@@ -7849,6 +8723,8 @@ async function convertDocxToPaginatedHtml(document2, requestedOptions) {
             "Use the paginated converter contract and report the malformed conversion output."
           );
         }
+        applyUnroundedNormalLineHeights(renderDocument2.body);
+        prepareWordText(renderDocument2.body, () => checkpointWordText(state));
         const engine2 = new PaginationEngine(staging, container, {
           scale: 1,
           cssPrefix: "page-",
@@ -7859,6 +8735,7 @@ async function convertDocxToPaginatedHtml(document2, requestedOptions) {
           // restamps through normalizePageMapFragmentIdentities(); stamping inside paginate()
           // would be a second full forced-layout pass whose result is immediately overwritten.
           deferFragmentIdentities: true,
+          bodyBudgetReductionsPt,
           checkCancellation: () => {
             if (state.signal?.aborted) {
               fail(
@@ -7899,11 +8776,32 @@ async function convertDocxToPaginatedHtml(document2, requestedOptions) {
             "Verify that the DOCX has a renderable main document body."
           );
         }
-        await runPhase(state, "running_story_placement", ["headers, footers, and notes"], () => {
-          finalizePageTree(renderDocument2, pages2, state, options);
-          engine2.normalizePageMapFragmentIdentities();
-          assertNoClippedContent(renderDocument2);
-        });
+        const clippedPages = await runPhase(
+          state,
+          "running_story_placement",
+          ["headers, footers, and notes"],
+          () => {
+            finalizePageTree(renderDocument2, pages2, state, options);
+            engine2.normalizePageMapFragmentIdentities();
+            const clipped = findClippedContent(renderDocument2);
+            if (clipped.length > 0 && bodyReflowRounds >= MAX_BODY_REFLOW_ROUNDS) {
+              fail(
+                "pagination_failure",
+                "running_story_placement",
+                clipped[0].message,
+                "Split the oversized block or reduce its dimensions before export."
+              );
+            }
+            return clipped;
+          }
+        );
+        if (clippedPages.length > 0) {
+          bodyReflowRounds++;
+          for (const page of clippedPages) {
+            bodyBudgetReductionsPt[page.pageNumber] = (bodyBudgetReductionsPt[page.pageNumber] ?? 0) + (page.overflowPx + 1) * 72 / 96;
+          }
+          throw new BodyReflowRequest();
+        }
         countDomNodes(renderDocument2, options.limits.domNodes, "running_story_placement");
         const automaticResources = automaticResourceCount(renderDocument2);
         enforceLimit(
@@ -7936,6 +8834,12 @@ async function convertDocxToPaginatedHtml(document2, requestedOptions) {
       } catch (error) {
         frame?.remove();
         frame = void 0;
+        if (error instanceof BodyReflowRequest) {
+          restoreAttemptState(state, attemptCheckpoint);
+          firstAttemptSignature = void 0;
+          attempt = 0;
+          continue;
+        }
         if (!(error instanceof PageTreeInstabilityError) || attempt === 2) throw error;
         restoreAttemptState(state, attemptCheckpoint);
         addWarning(state, {
@@ -7957,6 +8861,11 @@ async function convertDocxToPaginatedHtml(document2, requestedOptions) {
     }
     frame = finalized.frame;
     const { document: renderDocument, engine, pages } = finalized;
+    alignBaselinesToWord(renderDocument.body);
+    await runPhase(state, "output_verification", ["Word text baselines"], () => paintWordText(
+      renderDocument.getElementById("pagination-container"),
+      () => checkpointWordText(state)
+    ));
     const renderer = await runPhase(state, "output_verification", ["renderer identity"], () => rendererIdentity(
       renderDocument,
       layoutDigest,
@@ -8112,11 +9021,13 @@ export {
   FONT_SUBSTITUTION_CONTRACT_VERSION,
   HARD_EXPORT_RESOURCE_LIMITS,
   HARD_EXPORT_TIMEOUT_MS,
+  attestHostVerifiedRuntimeAssets,
   canonicalJson,
   convertDocxToPaginatedHtml,
   fontFamilyKey,
   inventoryDocumentFontRequests,
   normalizeFontFamilyName,
   parseCssFontFamily,
-  reconstructDocxodusExportError
+  reconstructDocxodusExportError,
+  renderedSourceMeasurerExpression
 };