@extend-ai/react-docx 0.4.0 → 0.6.0

package/dist/index.cjs

@@ -109,6 +109,7 @@ __export(index_exports, {
   useDocxPagination: () => useDocxPagination,
   useDocxParagraphStyles: () => useDocxParagraphStyles,
   useDocxTrackChanges: () => useDocxTrackChanges,
+  useDocxViewerThumbnails: () => useDocxViewerThumbnails,
   withPart: () => withPart
 });
 module.exports = __toCommonJS(index_exports);
@@ -4946,6 +4947,7 @@ function parseTable(tableXml2, context) {
     const rowHeightRuleRaw = rowHeightTag ? getAttribute(rowHeightTag, "w:hRule")?.toLowerCase() : void 0;
     const rowHeightRule = rowHeightRuleRaw === "atleast" || rowHeightRuleRaw === "exact" || rowHeightRuleRaw === "auto" ? rowHeightRuleRaw === "atleast" ? "atLeast" : rowHeightRuleRaw : void 0;
     const rowCantSplit = rowPropertiesXml ? parseOnOffAttribute(rowPropertiesXml, "cantSplit") : void 0;
+    const rowIsHeader = rowPropertiesXml ? parseOnOffAttribute(rowPropertiesXml, "tblHeader") : void 0;
     const parsedCells = extractBalancedTagBlocks(rowXml, "w:tc").map(
       (cellXml) => parseTableCell(cellXml, context)
     );
@@ -5002,11 +5004,12 @@ function parseTable(tableXml2, context) {
     rows.push({
       type: "table-row",
       cells,
-      style: rowBackgroundColor !== void 0 || rowHeightTwips !== void 0 || rowHeightRule !== void 0 || rowCantSplit !== void 0 ? {
+      style: rowBackgroundColor !== void 0 || rowHeightTwips !== void 0 || rowHeightRule !== void 0 || rowCantSplit !== void 0 || rowIsHeader !== void 0 ? {
         backgroundColor: rowBackgroundColor,
         heightTwips: rowHeightTwips,
         ...rowHeightRule !== void 0 ? { heightRule: rowHeightRule } : void 0,
-        ...rowCantSplit !== void 0 ? { cantSplit: rowCantSplit } : void 0
+        ...rowCantSplit !== void 0 ? { cantSplit: rowCantSplit } : void 0,
+        ...rowIsHeader !== void 0 ? { isHeader: rowIsHeader } : void 0
       } : void 0
     });
   }
@@ -7796,6 +7799,107 @@ function parseParagraphsFromClipboard(input) {
   }
 }
 
+// src/docx-import-worker-client.ts
+var import_meta = {};
+var cachedWorker;
+var cachedWorkerUnavailable = false;
+var nextRequestId = 1;
+function resolveWorker() {
+  if (cachedWorkerUnavailable) {
+    return void 0;
+  }
+  if (cachedWorker) {
+    return cachedWorker;
+  }
+  if (typeof window === "undefined" || typeof Worker === "undefined" || typeof URL === "undefined") {
+    cachedWorkerUnavailable = true;
+    return void 0;
+  }
+  try {
+    const workerUrl = new URL(
+      "./docx-import-worker.ts",
+      import_meta.url
+    );
+    cachedWorker = new Worker(workerUrl, {
+      type: "module",
+      name: "docx-import"
+    });
+    return cachedWorker;
+  } catch {
+    cachedWorkerUnavailable = true;
+    cachedWorker = void 0;
+    return void 0;
+  }
+}
+async function importDocxOnMainThread(buffer) {
+  const pkg = await parseDocx(buffer);
+  const model = buildDocModel(pkg);
+  return { pkg, model };
+}
+async function importDocxViaWorker(buffer) {
+  const worker = resolveWorker();
+  if (!worker) {
+    return importDocxOnMainThread(buffer);
+  }
+  const requestId = nextRequestId;
+  nextRequestId += 1;
+  return new Promise((resolve, reject) => {
+    const handleMessage = (event) => {
+      const data = event.data;
+      if (!data || data.requestId !== requestId) {
+        return;
+      }
+      worker.removeEventListener("message", handleMessage);
+      worker.removeEventListener("error", handleError);
+      worker.removeEventListener("messageerror", handleMessageError);
+      if (data.type === "imported") {
+        resolve({ pkg: data.pkg, model: data.model });
+      } else {
+        reject(new Error(data.message));
+      }
+    };
+    const handleError = (event) => {
+      worker.removeEventListener("message", handleMessage);
+      worker.removeEventListener("error", handleError);
+      worker.removeEventListener("messageerror", handleMessageError);
+      const message = event instanceof ErrorEvent && event.message ? event.message : "DOCX import worker crashed";
+      try {
+        worker.terminate();
+      } catch {
+      }
+      if (cachedWorker === worker) {
+        cachedWorker = void 0;
+      }
+      reject(new Error(message));
+    };
+    const handleMessageError = () => {
+      handleError(new Event("messageerror"));
+    };
+    worker.addEventListener("message", handleMessage);
+    worker.addEventListener("error", handleError);
+    worker.addEventListener("messageerror", handleMessageError);
+    const request = {
+      type: "import",
+      requestId,
+      buffer
+    };
+    try {
+      worker.postMessage(request, [buffer]);
+    } catch (error) {
+      worker.removeEventListener("message", handleMessage);
+      worker.removeEventListener("error", handleError);
+      worker.removeEventListener("messageerror", handleMessageError);
+      if (typeof console !== "undefined") {
+        console.warn(
+          "DOCX import worker postMessage failed; falling back to main thread.",
+          error
+        );
+      }
+      importDocxOnMainThread(buffer).then(resolve, reject);
+    }
+  });
+}
+
 // ../serializer/src/index.ts
 var REL_TYPE_IMAGE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
 var REL_TYPE_HYPERLINK = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink";
@@ -9121,18 +9225,63 @@ function collectTopLevelExplicitPageBreakStartNodeIndexes(nodes) {
 }
 
 // src/page-count-reconciliation.ts
+var PAGE_COUNT_RECONCILIATION_REFINEMENT_STEPS = 10;
 function shouldAllowStoredPageCountReduction(options) {
-  const estimatedPageCount = Math.max(1, Math.round(options.estimatedPageCount));
+  const estimatedPageCount = Math.max(
+    1,
+    Math.round(options.estimatedPageCount)
+  );
   const targetPageCount = Math.max(1, Math.round(options.targetPageCount));
   if (targetPageCount >= estimatedPageCount) {
     return true;
   }
+  if (options.hasMeasuredBodyFooterOverlap === true) {
+    return false;
+  }
   if (options.hasLastRenderedPageBreakHints !== true) {
     return true;
   }
-  const renderedBreakHintPageCount = Number.isFinite(options.renderedBreakHintPageCount) ? Math.max(1, Math.round(options.renderedBreakHintPageCount)) : void 0;
+  const renderedBreakHintPageCount = Number.isFinite(
+    options.renderedBreakHintPageCount
+  ) ? Math.max(1, Math.round(options.renderedBreakHintPageCount)) : void 0;
   return renderedBreakHintPageCount !== void 0 && targetPageCount >= renderedBreakHintPageCount;
 }
+function shouldLatchMeasuredBodyFooterOverlap(options) {
+  if (options.measuredBodyFooterOverlap !== true) {
+    return false;
+  }
+  const targetPageCount = Number.isFinite(options.targetPageCount) ? Math.max(1, Math.round(options.targetPageCount)) : void 0;
+  if (targetPageCount === void 0) {
+    return false;
+  }
+  const pageCount = Math.max(1, Math.round(options.pageCount));
+  return pageCount <= targetPageCount;
+}
+function resolveMeasuredBodyFooterOverlapLatchState(options) {
+  const shouldConsiderMeasuredBodyFooterOverlap = shouldLatchMeasuredBodyFooterOverlap({
+    pageCount: options.pageCount,
+    targetPageCount: options.targetPageCount,
+    measuredBodyFooterOverlap: options.overlappingPageIndexes.length > 0
+  });
+  if (!shouldConsiderMeasuredBodyFooterOverlap) {
+    return {
+      signature: void 0,
+      consecutivePasses: 0,
+      shouldLatch: false
+    };
+  }
+  const signature = options.overlappingPageIndexes.map((pageIndex) => `${pageIndex}`).join("|");
+  const consecutivePasses = signature === options.previousSignature ? Math.max(0, Math.round(options.previousConsecutivePasses ?? 0)) + 1 : 1;
+  const stabilityThreshold = Math.max(
+    1,
+    Math.round(options.stabilityThreshold ?? 1)
+  );
+  return {
+    signature,
+    consecutivePasses,
+    shouldLatch: consecutivePasses >= stabilityThreshold
+  };
+}
 function isBetterCandidate(candidate, incumbent, targetPageCount) {
   const candidateDifference = Math.abs(candidate.pageCount - targetPageCount);
   const incumbentDifference = Math.abs(incumbent.pageCount - targetPageCount);
@@ -9146,7 +9295,7 @@ function isBetterCandidate(candidate, incumbent, targetPageCount) {
   }
   return candidate.pageCount === targetPageCount && incumbent.pageCount !== targetPageCount;
 }
-function reconcilePagesToTargetCountByScalingHeight(options) {
+function reconcilePageCountCandidateToTargetCountByScalingHeight(options) {
   const {
     initialPages,
     targetPageCount,
@@ -9158,7 +9307,11 @@ function reconcilePagesToTargetCountByScalingHeight(options) {
   const initialPageCount = initialPages.length;
   const initialDifference = Math.abs(initialPageCount - safeTargetPageCount);
   if (initialDifference === 0 || initialDifference > maxDifference) {
-    return initialPages;
+    return {
+      pageCount: initialPageCount,
+      pages: initialPages,
+      scale: 1
+    };
   }
   const bestCandidate = {
     pageCount: initialPageCount,
@@ -9208,22 +9361,71 @@ function reconcilePagesToTargetCountByScalingHeight(options) {
     0.24,
     0.22,
     0.2
-  ] : [1.02, 1.04, 1.06, 1.08, 1.1, 1.12, 1.14, 1.16, 1.18, 1.2, 1.22, 1.24, 1.26, 1.28, 1.3];
-  for (const scale of scales) {
+  ] : [
+    1.02,
+    1.04,
+    1.06,
+    1.08,
+    1.1,
+    1.12,
+    1.14,
+    1.16,
+    1.18,
+    1.2,
+    1.22,
+    1.24,
+    1.26,
+    1.28,
+    1.3
+  ];
+  const buildCandidateAtScale = (scale) => {
     const pages = buildPagesAtScale(scale);
-    const candidate = {
+    return {
       pageCount: pages.length,
       pages,
       scale
     };
+  };
+  const refineExactTargetCandidate = (lowerScale, upperScale) => {
+    let bestExactCandidate;
+    const interval = upperScale - lowerScale;
+    if (!Number.isFinite(interval) || Math.abs(interval) < 1e-4) {
+      return selectedCandidate;
+    }
+    for (let step = 1; step <= PAGE_COUNT_RECONCILIATION_REFINEMENT_STEPS; step += 1) {
+      const scale = lowerScale + interval * step / PAGE_COUNT_RECONCILIATION_REFINEMENT_STEPS;
+      const candidate = buildCandidateAtScale(scale);
+      if (isBetterCandidate(candidate, selectedCandidate, safeTargetPageCount)) {
+        selectedCandidate = candidate;
+      }
+      if (candidate.pageCount === safeTargetPageCount && (bestExactCandidate === void 0 || isBetterCandidate(
+        candidate,
+        bestExactCandidate,
+        safeTargetPageCount
+      ))) {
+        bestExactCandidate = candidate;
+      }
+    }
+    return bestExactCandidate ?? selectedCandidate;
+  };
+  let previousScale = 1;
+  let previousPageCount = initialPageCount;
+  for (const scale of scales) {
+    const candidate = buildCandidateAtScale(scale);
     if (isBetterCandidate(candidate, selectedCandidate, safeTargetPageCount)) {
       selectedCandidate = candidate;
     }
     if (candidate.pageCount === safeTargetPageCount) {
-      return candidate.pages;
+      const crossedIntoExactTarget = needMorePages ? previousPageCount < safeTargetPageCount : previousPageCount > safeTargetPageCount;
+      if (crossedIntoExactTarget) {
+        return refineExactTargetCandidate(previousScale, scale);
+      }
+      return candidate;
     }
+    previousScale = scale;
+    previousPageCount = candidate.pageCount;
   }
-  return selectedCandidate.pages;
+  return selectedCandidate;
 }
 
 // src/pretext-layout.ts
@@ -9448,6 +9650,22 @@ function prepareCached(text, font, wordBreak = "normal") {
     return void 0;
   }
 }
+function measurePretextPlainTextLineCount(text, font, containerWidthPx, options) {
+  if (!text) {
+    return 0;
+  }
+  const wordBreak = options?.wordBreak ?? "normal";
+  const prepared = prepareCached(text, font, wordBreak);
+  if (!prepared) {
+    return void 0;
+  }
+  try {
+    const safeWidth = Math.max(1, Math.round(containerWidthPx));
+    return (0, import_pretext.measureLineStats)(prepared, safeWidth).lineCount;
+  } catch {
+    return void 0;
+  }
+}
 function cloneItemCursor(cursor) {
   return {
     itemIndex: cursor.itemIndex,
@@ -10189,7 +10407,7 @@ var SCRIPT_FONT_SCALE = 0.65;
 var DEFAULT_PARAGRAPH_LINE_MULTIPLE = 1;
 var WORD_SINGLE_LINE_AUTO_SCALE = 0.88;
 var WORD_SINGLE_LINE_AUTO_SCALE_SANS = 0.9;
-var WORD_SINGLE_LINE_AUTO_SCALE_SERIF = 1.12;
+var WORD_SINGLE_LINE_AUTO_SCALE_SERIF = 1.08;
 var WORD_AUTO_LINE_SCALE_BLEND_END_MULTIPLE = 1.08;
 var MIN_AUTO_LINE_MULTIPLE = 0.1;
 var MIN_PARAGRAPH_LINE_HEIGHT_PX = 14;
@@ -10199,10 +10417,12 @@ var MEASURED_PAGE_FOOTER_CLEARANCE_BUFFER_PX = 24;
 var UNOVERLAPPED_FOOTER_MIN_CLEARANCE_PX = 16;
 var FLOATING_FOOTER_BASELINE_CLEARANCE_RESERVE_PX = 16;
 var PAGINATION_MEASUREMENT_INTERACTION_DEBOUNCE_MS = 180;
+var MEASURED_BODY_FOOTER_OVERLAP_STABILITY_THRESHOLD = 3;
 var WORD_TABLE_CELL_PARAGRAPH_AUTO_LINE_TWIPS = 240;
 var WORD_TABLE_CELL_PARAGRAPH_BEFORE_TWIPS = 0;
 var WORD_TABLE_CELL_PARAGRAPH_AFTER_TWIPS = 0;
 var TABLE_ROW_SLICE_VISUAL_BLEED_PX = 1;
+var TABLE_CELL_SLICE_FULLY_VISIBLE_BOTTOM_BUFFER_PX = 4;
 var DEFAULT_SPLIT_PARAGRAPH_LINE_TWIPS = 259;
 var DEFAULT_SPLIT_PARAGRAPH_AFTER_TWIPS = 160;
 var PAGE_CONTENT_MEASUREMENT_IGNORE_ATTRIBUTE = "data-docx-pagination-ignore";
@@ -10235,15 +10455,19 @@ var LEADING_COVER_SPACER_EXTRA_HEIGHT_PX = 2;
 var PARAGRAPH_SEGMENT_TOP_BLEED_PX = 22;
 var PARAGRAPH_SEGMENT_DESCENDER_BLEED_PX = 6;
 var PARAGRAPH_SEGMENT_VISUAL_SAFETY_PX = 24;
+var LAST_RENDERED_PAGE_BREAK_HINT_MAX_REMAINING_SPACE_RATIO = 0.18;
+var LAST_RENDERED_PAGE_BREAK_HINT_MIN_REMAINING_SPACE_PX = MIN_PARAGRAPH_LINE_HEIGHT_PX * 3;
+var LAST_RENDERED_PAGE_BREAK_HINT_MAX_REMAINING_SPACE_PX = 120;
 var PARAGRAPH_SEGMENT_FALLBACK_TOP_BLEED_MAX_PX = 4;
 var PARAGRAPH_SEGMENT_FALLBACK_BOTTOM_BLEED_MAX_PX = 0;
 var PARAGRAPH_SEGMENT_FALLBACK_VISUAL_SAFETY_PX = 4;
 var INITIAL_PAGINATION_PREMEASURE_PAGE_LIMIT = 8;
 var INITIAL_PAGINATION_PAGE_COUNT_OSCILLATION_DISTINCT_THRESHOLD = 2;
 var INITIAL_PAGINATION_PAGE_COUNT_OSCILLATION_CHANGE_THRESHOLD = 4;
+var INITIAL_PAGINATION_BACKGROUND_REFINEMENT_DELAY_MS = 96;
 var DEFAULT_PAGE_VIRTUALIZATION_OVERSCAN = 2;
 var DEFAULT_PAGE_VIRTUALIZATION_SETTLE_DELAY_MS = 350;
-var ENABLE_TABLE_ROW_SLICING = false;
+var ENABLE_TABLE_ROW_SLICING = true;
 var TOP_AND_BOTTOM_VERTICAL_DRAG_SNAP_PX = 10;
 var HEADER_FOOTER_INACTIVE_OPACITY = 0.5;
 var LETTERHEAD_INDENT_MIN_TWIPS = 900;
@@ -10548,7 +10772,11 @@ function nearestScrollableAncestor(element) {
     }
     current = current.parentElement;
   }
-  return null;
+  const scrollingElement = typeof document !== "undefined" ? document.scrollingElement : null;
+  if (scrollingElement instanceof HTMLElement) {
+    return scrollingElement;
+  }
+  return typeof document !== "undefined" ? document.documentElement : null;
 }
 function resolveEffectiveZoomScale(element) {
   let current = element;
@@ -10650,7 +10878,7 @@ function normalizeMeasuredTableRowHeightPx(heightPx) {
   }
   return Math.max(MIN_PARAGRAPH_LINE_HEIGHT_PX, Math.round(heightPx));
 }
-function reconcileMeasuredTableRowHeightsForImportPagination(table, measuredRowHeights, maxAvailableWidthPx, numberingDefinitions, docGridLinePitchPx) {
+function reconcileMeasuredTableRowHeightsForImportPagination(table, measuredRowHeights, maxAvailableWidthPx, pageContentHeightPx, numberingDefinitions, docGridLinePitchPx) {
   if (measuredRowHeights.length !== table.rows.length) {
     return void 0;
   }
@@ -10658,7 +10886,8 @@ function reconcileMeasuredTableRowHeightsForImportPagination(table, measuredRowH
     table,
     maxAvailableWidthPx,
     numberingDefinitions,
-    docGridLinePitchPx
+    docGridLinePitchPx,
+    pageContentHeightPx
   );
   if (estimatedRowHeights.length !== table.rows.length) {
     return void 0;
@@ -10666,6 +10895,7 @@ function reconcileMeasuredTableRowHeightsForImportPagination(table, measuredRowH
   return measuredRowHeights.map((heightPx, rowIndex) => {
     const row = table.rows[rowIndex];
     const normalizedMeasuredHeightPx = normalizeMeasuredTableRowHeightPx(heightPx);
+    const normalizedPageContentHeightPx = Number.isFinite(pageContentHeightPx) && pageContentHeightPx > 0 ? Math.max(120, Math.round(pageContentHeightPx)) : void 0;
     const estimatedHeightPx = Math.max(
       MIN_PARAGRAPH_LINE_HEIGHT_PX,
       Math.round(estimatedRowHeights[rowIndex] ?? MIN_PARAGRAPH_LINE_HEIGHT_PX)
@@ -10683,6 +10913,9 @@ function reconcileMeasuredTableRowHeightsForImportPagination(table, measuredRowH
     if (rowAllowsPageSplit(row) && row.style?.heightRule !== "exact") {
       return Math.max(explicitMinimumHeightPx, normalizedMeasuredHeightPx);
     }
+    if (Number.isFinite(normalizedPageContentHeightPx) && normalizedMeasuredHeightPx > normalizedPageContentHeightPx + PAGE_OVERFLOW_TOLERANCE_PX) {
+      return Math.max(explicitMinimumHeightPx, normalizedMeasuredHeightPx);
+    }
     const minimumHeightPx = Math.max(
       estimatedHeightPx,
       explicitMinimumHeightPx
@@ -10728,6 +10961,7 @@ function resolveTableMeasuredRowHeightsForPagination(nodes, tableMeasuredRowHeig
         tableNode,
         measuredRowHeights,
         options?.pageContentWidthPxByNodeIndex?.get(tableIndex),
+        options?.pageContentHeightPxByNodeIndex?.get(tableIndex),
         options?.numberingDefinitions,
         options?.docGridLinePitchPxByNodeIndex?.get(tableIndex)
       ) ?? measuredRowHeights.map(
@@ -11492,9 +11726,9 @@ function resolveFooterPaginationReservePx(footerSections, layout) {
     )
   );
   const footerBodyOverlapPx = estimatedFooterHeightPx + layout.footerDistancePx - layout.marginsPx.bottom;
-  const explicitFooterOverlapReservePx = Math.max(
+  const explicitFooterBoundaryReservePx = Math.max(
     0,
-    Math.round(footerBodyOverlapPx)
+    Math.round(footerBodyOverlapPx + UNOVERLAPPED_FOOTER_MIN_CLEARANCE_PX)
   );
   const floatingFooterBoundaryReservePx = Number.isFinite(
     floatingFooterBoundaryTopPx
@@ -11506,13 +11740,13 @@ function resolveFooterPaginationReservePx(footerSections, layout) {
   ) : 0;
   if (hasFloatingFooterBodyIntrusionRisk) {
     return Math.max(
-      explicitFooterOverlapReservePx,
+      explicitFooterBoundaryReservePx,
       floatingFooterBoundaryReservePx,
       FLOATING_FOOTER_BASELINE_CLEARANCE_RESERVE_PX
     );
   }
   return Math.max(
-    explicitFooterOverlapReservePx,
+    explicitFooterBoundaryReservePx,
     floatingFooterBoundaryReservePx
   );
 }
@@ -11732,7 +11966,7 @@ function resolvePageContentHeightPxForPageSegments(pageSegments, pageIndex, defa
   );
 }
 function resolveRenderPageContentHeightPxForPageSegments(params) {
-  return resolvePageContentHeightPxForPageSegments(
+  const resolvedHeightPx = resolvePageContentHeightPxForPageSegments(
     params.pageSegments,
     params.pageIndex,
     params.defaultPageContentHeightPx,
@@ -11741,6 +11975,13 @@ function resolveRenderPageContentHeightPxForPageSegments(params) {
     params.useMeasuredPageContentHeights === false ? void 0 : params.measuredPageContentIdentityKeysByPageIndex,
     params.pageIdentityKey
   );
+  if (params.useMeasuredPageContentHeights === false && Number.isFinite(params.pageContentHeightScale) && Math.abs(params.pageContentHeightScale - 1) >= 1e-3) {
+    return Math.max(
+      120,
+      Math.round(resolvedHeightPx * params.pageContentHeightScale)
+    );
+  }
+  return resolvedHeightPx;
 }
 function documentPageContainsOnlySplitParagraphSegments(pageSegments) {
   return pageSegments.length > 0 && pageSegments.every(
@@ -12277,28 +12518,74 @@ function nodeTreeContainsExplicitFontFamily(nodes) {
     return false;
   });
 }
+function firstExplicitFontFamilyInNodeTree(nodes) {
+  for (const node of nodes) {
+    if (node.type === "paragraph") {
+      for (const child of node.children) {
+        if (child.type !== "text" && child.type !== "form-field") {
+          continue;
+        }
+        const fontFamily = child.style?.fontFamily?.trim();
+        if (fontFamily) {
+          return fontFamily;
+        }
+      }
+      continue;
+    }
+    if (node.type === "table") {
+      for (const row of node.rows) {
+        for (const cell of row.cells) {
+          const nestedFontFamily = firstExplicitFontFamilyInNodeTree(cell.nodes);
+          if (nestedFontFamily) {
+            return nestedFontFamily;
+          }
+        }
+      }
+    }
+  }
+  return void 0;
+}
 function resolveDocumentInheritedFontFamily(model) {
   const paragraphStyles = model.metadata.paragraphStyles ?? [];
-  const styleDefinesFontFamily = paragraphStyles.some(
+  const normalizedDefaultStyleId = model.metadata.defaultParagraphStyleId?.trim().toLowerCase() ?? "";
+  const defaultParagraphStyle = paragraphStyles.find(
+    (style) => style.id.trim().toLowerCase() === normalizedDefaultStyleId
+  ) ?? paragraphStyles.find((style) => style.isDefault) ?? paragraphStyles.find((style) => style.id.trim().toLowerCase() === "normal");
+  const defaultStyleFontFamily = defaultParagraphStyle?.runStyle?.fontFamily?.trim();
+  if (defaultStyleFontFamily) {
+    return cssFontFamily(defaultStyleFontFamily);
+  }
+  const paragraphStyleFontFamily = paragraphStyles.find(
     (style) => Boolean(style.runStyle?.fontFamily?.trim())
-  );
-  if (styleDefinesFontFamily) {
-    return void 0;
+  )?.runStyle?.fontFamily;
+  if (paragraphStyleFontFamily) {
+    return cssFontFamily(paragraphStyleFontFamily);
   }
-  if (nodeTreeContainsExplicitFontFamily(model.nodes)) {
-    return void 0;
+  const explicitBodyFontFamily = firstExplicitFontFamilyInNodeTree(model.nodes);
+  if (explicitBodyFontFamily) {
+    return cssFontFamily(explicitBodyFontFamily);
   }
-  if ((model.metadata.headerSections ?? []).some(
-    (section) => nodeTreeContainsExplicitFontFamily(section.nodes)
-  )) {
-    return void 0;
+  for (const section of model.metadata.headerSections ?? []) {
+    const explicitHeaderFontFamily = firstExplicitFontFamilyInNodeTree(
+      section.nodes
+    );
+    if (explicitHeaderFontFamily) {
+      return cssFontFamily(explicitHeaderFontFamily);
+    }
   }
-  if ((model.metadata.footerSections ?? []).some(
-    (section) => nodeTreeContainsExplicitFontFamily(section.nodes)
-  )) {
-    return void 0;
+  for (const section of model.metadata.footerSections ?? []) {
+    const explicitFooterFontFamily = firstExplicitFontFamilyInNodeTree(
+      section.nodes
+    );
+    if (explicitFooterFontFamily) {
+      return cssFontFamily(explicitFooterFontFamily);
+    }
   }
-  return cssFontFamily(DEFAULT_UNSPECIFIED_DOCX_FONT_FAMILY);
+  return nodeTreeContainsExplicitFontFamily(model.nodes) || (model.metadata.headerSections ?? []).some(
+    (section) => nodeTreeContainsExplicitFontFamily(section.nodes)
+  ) || (model.metadata.footerSections ?? []).some(
+    (section) => nodeTreeContainsExplicitFontFamily(section.nodes)
+  ) ? void 0 : cssFontFamily(DEFAULT_UNSPECIFIED_DOCX_FONT_FAMILY);
 }
 function replaceTabLayoutMarkersWithTabText(root) {
   const centerLayouts = Array.from(
@@ -12666,6 +12953,11 @@ function sectionNodesNeedFullPageFooterOverlay(nodes) {
 function paragraphHasFormField2(paragraph) {
   return paragraph.children.some((child) => child.type === "form-field");
 }
+function paragraphHasCheckboxFormField(paragraph) {
+  return paragraph.children.some(
+    (child) => child.type === "form-field" && child.fieldType === "checkbox"
+  );
+}
 function paragraphHasVisibleText2(paragraph) {
   return paragraph.children.some(
     (child) => child.type === "text" && child.text.trim().length > 0 || child.type === "form-field" && formFieldDisplayValue2(child).trim().length > 0
@@ -12984,6 +13276,9 @@ function paragraphLooksLikeCheckboxChoiceRow(paragraph) {
 }
 var KEEP_ALL_SCRIPT_RE = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u;
 var MIN_DUAL_WRAPPED_INTERIOR_BAND_PX = 72;
+var paragraphPretextLayoutSourceCache = /* @__PURE__ */ new WeakMap();
+var paragraphPretextLayoutItemsBySource = /* @__PURE__ */ new WeakMap();
+var paragraphPretextUniformFontBySource = /* @__PURE__ */ new WeakMap();
 function imageWrapModeFromFloating(floating) {
   if (!floating) {
     return "inline";
@@ -13129,16 +13424,67 @@ function resolveFloatingForImageWrapMode(mode, currentFloating, seedFloating) {
       };
   }
 }
+function buildParagraphPretextTabSpacerText(widthPx, style, paragraphBaseFontPx) {
+  const safeWidthPx = Math.max(8, Math.round(widthPx));
+  const spacerCharacter = "\xA0";
+  const spacerAdvancePx = Math.max(
+    1,
+    measureTextWidthPx2(spacerCharacter, style, paragraphBaseFontPx)
+  );
+  let spacerCount = Math.max(1, Math.round(safeWidthPx / spacerAdvancePx));
+  let spacerText = spacerCharacter.repeat(spacerCount);
+  let measuredWidthPx = measureTextWidthPx2(
+    spacerText,
+    style,
+    paragraphBaseFontPx
+  );
+  while (measuredWidthPx + spacerAdvancePx * 0.5 < safeWidthPx && spacerCount < 64) {
+    spacerCount += 1;
+    spacerText = spacerCharacter.repeat(spacerCount);
+    measuredWidthPx = measureTextWidthPx2(spacerText, style, paragraphBaseFontPx);
+  }
+  while (spacerCount > 1) {
+    const nextText = spacerCharacter.repeat(spacerCount - 1);
+    const nextWidthPx = measureTextWidthPx2(nextText, style, paragraphBaseFontPx);
+    if (Math.abs(nextWidthPx - safeWidthPx) >= Math.abs(measuredWidthPx - safeWidthPx)) {
+      break;
+    }
+    spacerCount -= 1;
+    spacerText = nextText;
+    measuredWidthPx = nextWidthPx;
+  }
+  return spacerText;
+}
 function buildParagraphPretextLayoutSource(paragraph, options) {
+  const cacheKey = (options?.allowExplicitLineBreakText ? 1 : 0) | (options?.expandTabsForLayout ? 2 : 0);
+  const cachedVariants = paragraphPretextLayoutSourceCache.get(paragraph);
+  const cachedSource = cachedVariants?.get(cacheKey);
+  if (cachedSource !== void 0) {
+    return cachedSource ?? void 0;
+  }
+  const storeCachedSource = (source) => {
+    if (!cachedVariants) {
+      paragraphPretextLayoutSourceCache.set(
+        paragraph,
+        /* @__PURE__ */ new Map([[cacheKey, source ?? null]])
+      );
+    } else {
+      cachedVariants.set(cacheKey, source ?? null);
+    }
+    return source;
+  };
   if (paragraphHasFormField2(paragraph)) {
-    return void 0;
+    return storeCachedSource(void 0);
   }
   if (!options?.allowExplicitLineBreakText && paragraphContainsExplicitLineBreakText(paragraph)) {
-    return void 0;
+    return storeCachedSource(void 0);
   }
   const runs = [];
   let combinedText = "";
   const paragraphBaseFontPx = paragraphBaseFontSizePx(paragraph);
+  const tabStopPositionsPx = options?.expandTabsForLayout ? resolveParagraphTabStopsPx(paragraph) : [];
+  const fallbackTabWidthPx = paragraphLooksLikeCheckboxChoiceRow(paragraph) ? checkboxChoiceRowTabWidthPx(paragraph) : DEFAULT_TAB_STOP_PX;
+  let approximateLineWidthPx = 0;
   let lastTextStyle = firstRunStyle(paragraph);
   for (let childIndex = 0; childIndex < paragraph.children.length; childIndex += 1) {
     const child = paragraph.children[childIndex];
@@ -13168,10 +13514,63 @@ function buildParagraphPretextLayoutSource(paragraph, options) {
       continue;
     }
     if (child.type !== "text") {
-      return void 0;
-    }
-    if (child.noteReference || child.text.includes("	")) {
-      return void 0;
+      return storeCachedSource(void 0);
+    }
+    if (child.noteReference) {
+      return storeCachedSource(void 0);
+    }
+    if (child.text.includes("	")) {
+      if (!options?.expandTabsForLayout) {
+        return storeCachedSource(void 0);
+      }
+      const tabSegments = child.text.split("	");
+      tabSegments.forEach((segmentText, segmentIndex) => {
+        if (segmentText.length > 0) {
+          const startOffset3 = combinedText.length;
+          combinedText += segmentText;
+          runs.push({
+            kind: "text",
+            key: `run-${childIndex}-${segmentIndex}`,
+            text: segmentText,
+            startOffset: startOffset3,
+            endOffset: combinedText.length,
+            style: child.style,
+            link: child.link
+          });
+          approximateLineWidthPx = updateEstimatedLineWidthPxForText(
+            approximateLineWidthPx,
+            segmentText,
+            child.style
+          );
+        }
+        if (segmentIndex >= tabSegments.length - 1) {
+          return;
+        }
+        const tabWidthPx = resolveTabSpacerWidthPx(
+          tabStopPositionsPx,
+          approximateLineWidthPx,
+          fallbackTabWidthPx
+        );
+        const spacerText = buildParagraphPretextTabSpacerText(
+          tabWidthPx,
+          child.style,
+          paragraphBaseFontPx
+        );
+        const startOffset2 = combinedText.length;
+        combinedText += spacerText;
+        runs.push({
+          kind: "tab",
+          key: `run-${childIndex}-${segmentIndex}-tab`,
+          text: spacerText,
+          startOffset: startOffset2,
+          endOffset: combinedText.length,
+          style: child.style,
+          tabWidthPx
+        });
+        approximateLineWidthPx += tabWidthPx;
+      });
+      lastTextStyle = child.style ?? lastTextStyle;
+      continue;
     }
     const startOffset = combinedText.length;
     combinedText += child.text;
@@ -13184,15 +13583,142 @@ function buildParagraphPretextLayoutSource(paragraph, options) {
       style: child.style,
       link: child.link
     });
+    approximateLineWidthPx = updateEstimatedLineWidthPxForText(
+      approximateLineWidthPx,
+      child.text,
+      child.style
+    );
     lastTextStyle = child.style ?? lastTextStyle;
   }
   if (combinedText.length === 0) {
-    return void 0;
+    return storeCachedSource(void 0);
   }
-  return {
+  return storeCachedSource({
     text: combinedText,
     runs
+  });
+}
+function splitParagraphAtExplicitColumnBreaks(paragraph) {
+  if (!paragraphHasExplicitColumnBreak(paragraph)) {
+    return void 0;
+  }
+  const paragraphChildren = [];
+  let currentChildren = [];
+  let sawExplicitColumnBreak = false;
+  const appendCurrentSegment = () => {
+    paragraphChildren.push(currentChildren);
+    currentChildren = [];
   };
+  for (let childIndex = 0; childIndex < paragraph.children.length; childIndex += 1) {
+    const child = paragraph.children[childIndex];
+    if (!child) {
+      continue;
+    }
+    if (child.type === "text") {
+      if (/^[\r\n]+$/.test(child.text)) {
+        const explicitBreakCount = child.text.replace(/[^\n]/g, "").length;
+        if (explicitBreakCount > 0) {
+          for (let breakIndex = 0; breakIndex < explicitBreakCount; breakIndex += 1) {
+            sawExplicitColumnBreak = true;
+            appendCurrentSegment();
+          }
+          continue;
+        }
+      }
+      currentChildren.push(cloneTextRunWithMetadata(child));
+      continue;
+    }
+    if (child.type === "form-field") {
+      currentChildren.push(cloneFormFieldRun2(child));
+      continue;
+    }
+    return void 0;
+  }
+  if (!sawExplicitColumnBreak) {
+    return void 0;
+  }
+  appendCurrentSegment();
+  return paragraphChildren.map((children, segmentIndex) => {
+    const nextStyle = cloneParagraphStyle2(paragraph.style);
+    if (segmentIndex > 0 && nextStyle?.numbering) {
+      nextStyle.numbering = void 0;
+    }
+    return {
+      ...paragraph,
+      style: nextStyle,
+      sourceXml: void 0,
+      children: children.length > 0 ? children : [
+        {
+          type: "text",
+          text: ""
+        }
+      ]
+    };
+  });
+}
+function estimateParagraphContentHeightPx(paragraph, availableWidthPx, numberingDefinitions, docGridLinePitchPx) {
+  if (!paragraphHasImage2(paragraph) && !paragraphHasFormField2(paragraph)) {
+    const lineHeightPx = estimateParagraphLineHeightPx(
+      paragraph,
+      docGridLinePitchPx
+    );
+    const lineCount = paragraphLineCountWithinWidth(
+      paragraph,
+      availableWidthPx,
+      numberingDefinitions
+    );
+    return Math.max(1, lineHeightPx * Math.max(1, lineCount));
+  }
+  return Math.max(
+    1,
+    estimateParagraphHeightPx(
+      paragraph,
+      availableWidthPx,
+      numberingDefinitions,
+      docGridLinePitchPx
+    ) - paragraphBeforeSpacingPx(paragraph) - paragraphAfterSpacingPx(paragraph)
+  );
+}
+function projectParagraphConsumedHeightWithExplicitColumnBreaks(paragraphSegments, pageConsumedHeightPx, pageContentHeightPx, sectionFlowOriginPx, columnCount, availableWidthPx, beforeSpacingPx, afterSpacingPx, collapsedMarginPx, numberingDefinitions, docGridLinePitchPx) {
+  if (paragraphSegments.length <= 1 || columnCount <= 1) {
+    return void 0;
+  }
+  const normalizedParagraphStartPx = Math.max(
+    0,
+    Math.max(pageConsumedHeightPx, sectionFlowOriginPx)
+  );
+  const firstSegmentTopSpacingPx = pageConsumedHeightPx > 0 ? Math.max(0, beforeSpacingPx - collapsedMarginPx) : beforeSpacingPx;
+  const tallestSegmentHeightPx = paragraphSegments.reduce(
+    (tallest, segment) => {
+      return Math.max(
+        tallest,
+        estimateParagraphContentHeightPx(
+          segment,
+          availableWidthPx,
+          numberingDefinitions,
+          docGridLinePitchPx
+        )
+      );
+    },
+    0
+  );
+  const projectedConsumedHeightPx = normalizedParagraphStartPx + firstSegmentTopSpacingPx + tallestSegmentHeightPx + afterSpacingPx;
+  const sectionFlowCapacityPx = Math.max(
+    0,
+    pageContentHeightPx - sectionFlowOriginPx
+  );
+  const sectionConsumedPx = Math.max(
+    0,
+    pageConsumedHeightPx - sectionFlowOriginPx
+  );
+  const remainingColumnHeightPx = Math.max(
+    0,
+    sectionFlowCapacityPx / columnCount - sectionConsumedPx
+  );
+  if (projectedConsumedHeightPx - pageConsumedHeightPx > remainingColumnHeightPx + PAGE_OVERFLOW_TOLERANCE_PX) {
+    return void 0;
+  }
+  return projectedConsumedHeightPx;
 }
 function buildSyntheticPretextLayoutSource(text, style) {
   return {
@@ -13216,16 +13742,50 @@ function sanitizeRenderedPretextFragmentText(text) {
   return text.replace(/\r\n?|\n/g, "");
 }
 function buildParagraphPretextLayoutItems(paragraph, source) {
+  const cachedItems = paragraphPretextLayoutItemsBySource.get(source);
+  if (cachedItems) {
+    return cachedItems;
+  }
   const paragraphBaseFontPx = paragraphBaseFontSizePx(paragraph);
   const wordBreak = pretextWordBreakModeForText(source.text);
-  return source.runs.filter((run) => run.endOffset > run.startOffset).map((run) => ({
+  const items = source.runs.filter((run) => run.endOffset > run.startOffset).map((run) => ({
     text: run.text,
     font: resolveMeasureFont(run.style, paragraphBaseFontPx),
     startOffset: run.startOffset,
     endOffset: run.endOffset,
-    break: run.kind === "image" ? "never" : "normal",
+    break: run.kind === "image" || run.kind === "tab" ? "never" : "normal",
     wordBreak
   }));
+  paragraphPretextLayoutItemsBySource.set(source, items);
+  return items;
+}
+function resolveUniformPretextSourceFont(paragraph, source) {
+  const cachedUniformFont = paragraphPretextUniformFontBySource.get(source);
+  if (cachedUniformFont !== void 0) {
+    return cachedUniformFont ?? void 0;
+  }
+  const paragraphBaseFontPx = paragraphBaseFontSizePx(paragraph);
+  let uniformFont;
+  for (const run of source.runs) {
+    if (run.endOffset <= run.startOffset) {
+      continue;
+    }
+    if (run.kind !== "text") {
+      paragraphPretextUniformFontBySource.set(source, null);
+      return void 0;
+    }
+    const runFont = resolveMeasureFont(run.style, paragraphBaseFontPx);
+    if (uniformFont === void 0) {
+      uniformFont = runFont;
+      continue;
+    }
+    if (runFont !== uniformFont) {
+      paragraphPretextUniformFontBySource.set(source, null);
+      return void 0;
+    }
+  }
+  paragraphPretextUniformFontBySource.set(source, uniformFont ?? null);
+  return uniformFont;
 }
 function buildMeasureSegmentsPretextLayoutItems(segments, paragraphBaseFontPx, text) {
   const wordBreak = pretextWordBreakModeForText(text);
@@ -14012,6 +14572,31 @@ function paragraphStartsWithLastRenderedPageBreak(paragraph) {
   ).replace(/<\/?w:(?:ins|smartTag)\b[^>]*>/gi, "").replace(/\s+/g, "");
   return leadingXml.length === 0;
 }
+function shouldHonorParagraphStartLastRenderedPageBreak(params) {
+  const pageConsumedHeightPx = Math.max(
+    0,
+    Math.round(params.pageConsumedHeightPx)
+  );
+  const pageContentHeightPx = Math.max(
+    0,
+    Math.round(params.pageContentHeightPx)
+  );
+  if (pageConsumedHeightPx <= 0 || pageContentHeightPx <= 0) {
+    return false;
+  }
+  const remainingHeightPx = Math.max(
+    0,
+    pageContentHeightPx - pageConsumedHeightPx
+  );
+  const maxAllowedRemainingHeightPx = clampNumber(
+    Math.round(
+      pageContentHeightPx * LAST_RENDERED_PAGE_BREAK_HINT_MAX_REMAINING_SPACE_RATIO
+    ),
+    LAST_RENDERED_PAGE_BREAK_HINT_MIN_REMAINING_SPACE_PX,
+    LAST_RENDERED_PAGE_BREAK_HINT_MAX_REMAINING_SPACE_PX
+  );
+  return remainingHeightPx <= maxAllowedRemainingHeightPx;
+}
 function isOnOffTagEnabled2(tagXml) {
   if (!tagXml) {
     return false;
@@ -14155,7 +14740,8 @@ function sectionBreakAfterParagraphStartsNewPage(paragraph) {
   if (cached) {
     return cached.sectionBreakStartsNewPage;
   }
-  return paragraphHasExplicitPageBreak2(paragraph) ? paragraphBreakFlagsBySourceXml.get(xml)?.sectionBreakStartsNewPage ?? false : false;
+  paragraphHasExplicitPageBreak2(paragraph);
+  return paragraphBreakFlagsBySourceXml.get(xml)?.sectionBreakStartsNewPage ?? false;
 }
 function nodeAlreadyEndsAtExplicitPageBoundary(node) {
   if (!node || node.type !== "paragraph") {
@@ -14395,6 +14981,10 @@ function singleLineAutoScaleForFontFamily(fontFamily) {
   }
   return WORD_SINGLE_LINE_AUTO_SCALE;
 }
+function resolveParagraphSingleLineAutoScale(paragraph, fontFamily) {
+  const baseScale = singleLineAutoScaleForFontFamily(fontFamily);
+  return paragraphHasCheckboxFormField(paragraph) ? Math.max(1.08, baseScale) : baseScale;
+}
 function paragraphContainsExplicitLineBreakText(paragraph) {
   return paragraph.children.some(
     (child) => child.type === "text" && /[\r\n]/.test(child.text)
@@ -14483,6 +15073,23 @@ function resolveParagraphTabStopsPx(paragraph) {
   ).map((value) => Math.round(value)).sort((left, right) => left - right);
   return stopsPx;
 }
+function resolveParagraphFirstLineOriginPx(paragraph) {
+  const leftIndentPx = twipsToSignedPixels(paragraph.style?.indent?.leftTwips);
+  const firstLineIndentPx = twipsToSignedPixels(
+    paragraph.style?.indent?.firstLineTwips
+  );
+  const hangingIndentPx = twipsToSignedPixels(
+    paragraph.style?.indent?.hangingTwips
+  );
+  const textIndentPx = firstLineIndentPx ?? (Number.isFinite(hangingIndentPx) ? -hangingIndentPx : 0);
+  return (Number.isFinite(leftIndentPx) ? leftIndentPx : 0) + (Number.isFinite(textIndentPx) ? textIndentPx : 0);
+}
+function resolveParagraphFirstLineLeftTabStopsPx(paragraph) {
+  const firstLineOriginPx = resolveParagraphFirstLineOriginPx(paragraph);
+  return (paragraph.style?.tabStops ?? []).filter((tabStop) => tabStop.alignment !== "right").map((tabStop) => twipsToPixels(tabStop.positionTwips)).filter(
+    (value) => Number.isFinite(value) && value > firstLineOriginPx + 0.5
+  ).map((value) => Math.round(value - firstLineOriginPx)).sort((left, right) => left - right);
+}
 function resolveNextTabStopPx(currentLineWidthPx, tabStopsPx) {
   const nextExplicit = tabStopsPx.find(
     (stopPx) => stopPx > currentLineWidthPx + 0.5
@@ -14716,6 +15323,21 @@ function estimateWrappedLineCountForParagraph(paragraph, availableWidthPx) {
       if (!pretextSource) {
         return void 0;
       }
+      const uniformFont = resolveUniformPretextSourceFont(
+        paragraph,
+        pretextSource
+      );
+      if (uniformFont !== void 0) {
+        const fastLineCount = measurePretextPlainTextLineCount(
+          pretextSource.text,
+          uniformFont,
+          maxLineWidthPx,
+          { wordBreak: pretextWordBreakModeForText(pretextSource.text) }
+        );
+        if (fastLineCount !== void 0) {
+          return fastLineCount;
+        }
+      }
       const lineHeightPx = estimateParagraphLineHeightPx(paragraph);
       const layout = layoutParagraphPretextSource(
         paragraph,
@@ -14970,6 +15592,58 @@ function wrappedPretextParagraphBlockHeightPx(layout) {
   }
   return Math.max(1, Math.round(layout.height));
 }
+function resolvePretextLineRangeContentHeightPx(layout, startLineIndex, endLineIndex) {
+  if (layout.lines.length === 0) {
+    return 0;
+  }
+  const lineHeightPx = Math.max(1, Math.round(layout.lineHeightPx ?? 1));
+  const safeStart = Math.max(
+    0,
+    Math.min(Math.round(startLineIndex), layout.lines.length)
+  );
+  const safeEnd = Math.max(
+    safeStart,
+    Math.min(Math.round(endLineIndex), layout.lines.length)
+  );
+  if (safeEnd <= safeStart) {
+    return 0;
+  }
+  const firstLineTopPx = layout.lines[safeStart]?.y ?? safeStart * lineHeightPx;
+  const lastLineTopPx = layout.lines[safeEnd - 1]?.y ?? (safeEnd - 1) * lineHeightPx;
+  return Math.max(1, Math.round(lastLineTopPx - firstLineTopPx + lineHeightPx));
+}
+function resolveMaxPretextLineRangeEndIndexThatFits(layout, startLineIndex, maxEndLineIndex, availableHeightPx) {
+  const safeStart = Math.max(
+    0,
+    Math.min(Math.round(startLineIndex), layout.lines.length)
+  );
+  const safeMaxEnd = Math.max(
+    safeStart,
+    Math.min(Math.round(maxEndLineIndex), layout.lines.length)
+  );
+  const safeAvailableHeightPx = Math.max(0, Math.round(availableHeightPx));
+  if (safeAvailableHeightPx <= 0 || safeMaxEnd <= safeStart) {
+    return safeStart;
+  }
+  let low = safeStart;
+  let high = safeMaxEnd;
+  let bestEnd = safeStart;
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    const candidateHeightPx = resolvePretextLineRangeContentHeightPx(
+      layout,
+      safeStart,
+      mid
+    );
+    if (candidateHeightPx <= safeAvailableHeightPx) {
+      bestEnd = mid;
+      low = mid + 1;
+      continue;
+    }
+    high = mid - 1;
+  }
+  return bestEnd;
+}
 function estimateAbsoluteFloatingImageFootprintPx(paragraph, image) {
   if (!shouldRenderAbsoluteFloatingImage(image)) {
     return 0;
@@ -15009,10 +15683,7 @@ function resolveAutoLineSpacingMultiple(lineTwips, fallbackMultiple) {
 function autoLineHeightScaleForMultiple(multiple, singleLineScale) {
   const safeSingleLineScale = Math.max(
     MIN_AUTO_LINE_MULTIPLE,
-    Math.min(
-      1,
-      Number.isFinite(singleLineScale) ? singleLineScale : WORD_SINGLE_LINE_AUTO_SCALE
-    )
+    Number.isFinite(singleLineScale) ? singleLineScale : WORD_SINGLE_LINE_AUTO_SCALE
   );
   if (!Number.isFinite(multiple)) {
     return safeSingleLineScale;
@@ -15028,9 +15699,9 @@ function autoLineHeightScaleForMultiple(multiple, singleLineScale) {
     (safeSingleLineScale + (1 - safeSingleLineScale) * blendProgress).toFixed(4)
   );
 }
-function calibrateAutoLineSpacingMultiple(multiple, fontFamily) {
+function calibrateAutoLineSpacingMultiple(multiple, fontFamily, singleLineScaleOverride) {
   const normalizedMultiple = Math.max(MIN_AUTO_LINE_MULTIPLE, multiple);
-  const singleLineScale = singleLineAutoScaleForFontFamily(fontFamily);
+  const singleLineScale = singleLineScaleOverride ?? singleLineAutoScaleForFontFamily(fontFamily);
   return Math.max(
     MIN_AUTO_LINE_MULTIPLE,
     Number(
@@ -15074,13 +15745,18 @@ function estimateParagraphLineHeightPx(paragraph, docGridLinePitchPx, disableDoc
   );
   const baseFontPx = paragraphBaseFontSizePx(paragraph);
   const baseFontFamily = paragraphDominantFontFamily(paragraph);
+  const singleLineScale = resolveParagraphSingleLineAutoScale(
+    paragraph,
+    baseFontFamily
+  );
   const defaultLineMultiple = isTableOfContentsParagraph(paragraph) ? 1.05 : DEFAULT_PARAGRAPH_LINE_MULTIPLE;
   const normalLineHeightPx = Math.max(
     1,
     Math.round(
       baseFontPx * calibrateAutoLineSpacingMultiple(
         DEFAULT_PARAGRAPH_LINE_MULTIPLE,
-        baseFontFamily
+        baseFontFamily,
+        singleLineScale
       )
     )
   );
@@ -15097,7 +15773,8 @@ function estimateParagraphLineHeightPx(paragraph, docGridLinePitchPx, disableDoc
   }
   const multiple = calibrateAutoLineSpacingMultiple(
     resolveAutoLineSpacingMultiple(lineTwips, defaultLineMultiple),
-    baseFontFamily
+    baseFontFamily,
+    singleLineScale
   );
   const autoLineHeightPx = Math.max(1, Math.round(baseFontPx * multiple));
   const minimumReadableAutoLineHeightPx = paragraph.style?.numbering ? Math.ceil(baseFontPx) : 0;
@@ -15263,14 +15940,17 @@ function suppressFirstTableCellParagraphTopSpacing(paragraph) {
 }
 function estimateTableCellContentHeightPx(nodeContent, availableWidthPx, numberingDefinitions, applyWordTableDefaults = false, docGridLinePitchPx) {
   let paragraphIndex = 0;
-  return nodeContent.reduce((sum, contentNode) => {
+  let expandedWithPretextLayout = false;
+  let totalHeightPx = 0;
+  for (const contentNode of nodeContent) {
     if (!isParagraphCellContentNode(contentNode)) {
-      return sum + estimateTableHeightPx(
+      totalHeightPx += estimateTableHeightPx(
         contentNode,
         availableWidthPx,
         numberingDefinitions,
         docGridLinePitchPx
       );
+      continue;
     }
     const disableDocGridSnap = paragraphDocGridSnapState(contentNode) === "disable";
     const paragraphForLayout = wordLikeTableCellParagraph(
@@ -15284,14 +15964,55 @@ function estimateTableCellContentHeightPx(nodeContent, availableWidthPx, numberi
       docGridLinePitchPx,
       disableDocGridSnap
     );
+    const lineHeightPx = Math.max(
+      MIN_PARAGRAPH_LINE_HEIGHT_PX,
+      estimateParagraphLineHeightPx(
+        paragraphForLayout,
+        docGridLinePitchPx,
+        disableDocGridSnap
+      )
+    );
+    const pretextSource = buildParagraphPretextLayoutSource(
+      paragraphForLayout,
+      {
+        allowExplicitLineBreakText: true,
+        expandTabsForLayout: true
+      }
+    );
+    const paragraphTextWidthPx = typeof availableWidthPx === "number" && availableWidthPx > 0 ? paragraphAvailableTextWidthPx(
+      paragraphForLayout,
+      availableWidthPx,
+      numberingDefinitions
+    ) : void 0;
+    const pretextLayout = pretextSource && typeof paragraphTextWidthPx === "number" && paragraphTextWidthPx > 0 ? layoutParagraphPretextSource(
+      paragraphForLayout,
+      pretextSource,
+      paragraphTextWidthPx,
+      lineHeightPx,
+      []
+    ) : void 0;
     const suppressTopSpacing = paragraphIndex === 0 && suppressFirstTableCellParagraphTopSpacing(contentNode);
     paragraphIndex += 1;
+    const beforeSpacing = suppressTopSpacing ? 0 : twipsToPixels(paragraphForLayout.style?.spacing?.beforeTwips) ?? 0;
+    const afterSpacing = twipsToPixels(paragraphForLayout.style?.spacing?.afterTwips) ?? 0;
+    const topBorderInsetPx = paragraphBorderInsetPx(
+      paragraphForLayout.style?.borders?.top
+    );
+    const bottomBorderInsetPx = paragraphBorderInsetPx(
+      paragraphForLayout.style?.borders?.bottom
+    );
+    const pretextHeightPx = pretextLayout ? beforeSpacing + afterSpacing + topBorderInsetPx + bottomBorderInsetPx + wrappedPretextParagraphBlockHeightPx(pretextLayout) : 0;
+    const resolvedBaseHeight = pretextHeightPx > 0 ? Math.max(baseHeight, pretextHeightPx) : baseHeight;
+    if (pretextHeightPx > baseHeight) {
+      expandedWithPretextLayout = true;
+    }
     if (!suppressTopSpacing) {
-      return sum + baseHeight;
+      totalHeightPx += resolvedBaseHeight;
+      continue;
     }
-    const beforeSpacing = twipsToPixels(paragraphForLayout.style?.spacing?.beforeTwips) ?? 0;
-    return sum + Math.max(1, baseHeight - beforeSpacing);
-  }, 0);
+    totalHeightPx += Math.max(1, resolvedBaseHeight - beforeSpacing);
+  }
+  return totalHeightPx + (expandedWithPretextLayout ? Math.max(1, MIN_PARAGRAPH_LINE_HEIGHT_PX) : 0);
 }
 function rowAllowsPageSplit(row) {
   return row.style?.cantSplit !== true && row.style?.heightRule !== "exact";
@@ -15309,7 +16030,7 @@ function rowHasDeepFlowContent(row) {
   }
   return nestedTableCount > 0 || blockNodeCount >= SPLITTABLE_TABLE_ROW_DEEP_CONTENT_NODE_THRESHOLD;
 }
-function capSplitFriendlyTableRowEstimatePx(row, estimatedRowHeightPx, explicitHeightPx) {
+function capSplitFriendlyTableRowEstimatePx(row, estimatedRowHeightPx, explicitHeightPx, pageContentHeightPx) {
   if (!rowAllowsPageSplit(row)) {
     return estimatedRowHeightPx;
   }
@@ -15323,6 +16044,13 @@ function capSplitFriendlyTableRowEstimatePx(row, estimatedRowHeightPx, explicitH
     MIN_PARAGRAPH_LINE_HEIGHT_PX * 2,
     Math.round(explicitHeightPx)
   );
+  const safePageContentHeightPx = Number.isFinite(pageContentHeightPx) && pageContentHeightPx > 0 ? Math.max(
+    MIN_PARAGRAPH_LINE_HEIGHT_PX * 4,
+    Math.round(pageContentHeightPx)
+  ) : void 0;
+  if (safePageContentHeightPx !== void 0 && estimatedRowHeightPx > safePageContentHeightPx + PAGE_OVERFLOW_TOLERANCE_PX) {
+    return estimatedRowHeightPx;
+  }
   const cappedHeightPx = safeExplicitHeightPx + MIN_PARAGRAPH_LINE_HEIGHT_PX * SPLITTABLE_TABLE_ROW_ESTIMATE_EXTRA_LINE_COUNT;
   return Math.min(estimatedRowHeightPx, cappedHeightPx);
 }
@@ -15360,7 +16088,7 @@ function tableUsesWordLikeParagraphDefaults(table) {
   }
   return table.style?.layout === "fixed" && tableHasVisibleBorders(table) && tableContainsParagraphsWithoutExplicitSpacing(table);
 }
-function estimateTableRowHeightsPx(table, maxAvailableWidthPx, numberingDefinitions, docGridLinePitchPx) {
+function estimateTableRowHeightsPx(table, maxAvailableWidthPx, numberingDefinitions, docGridLinePitchPx, pageContentHeightPx) {
   const defaultCellMargin = table.style?.cellMarginTwips;
   const columnCount = tableColumnCount(table);
   const tableWidthPx = twipsToPixels(table.style?.widthTwips);
@@ -15378,7 +16106,11 @@ function estimateTableRowHeightsPx(table, maxAvailableWidthPx, numberingDefiniti
     return normalizeColumnWidthsPx(widthsPx, columnCount, tableWidthPx, 1);
   })();
   const rawResolvedTableWidthPx = tableWidthPx ?? rawTableColumnWidthsPx.reduce((sum, widthPx) => sum + widthPx, 0);
-  const maxTableWidthPx = Number.isFinite(maxAvailableWidthPx) && maxAvailableWidthPx > 0 ? Math.max(120, maxAvailableWidthPx) : void 0;
+  const collapsedHorizontalBorderBleedPx = resolveCollapsedTableHorizontalOuterBleedPx(table, columnCount);
+  const maxTableWidthPx = Number.isFinite(maxAvailableWidthPx) && maxAvailableWidthPx > 0 ? Math.max(
+    120,
+    maxAvailableWidthPx - collapsedHorizontalBorderBleedPx
+  ) : void 0;
   const resolvedTableWidthPx = clampTableWidthPx(
     rawResolvedTableWidthPx,
     maxTableWidthPx
@@ -15425,7 +16157,8 @@ function estimateTableRowHeightsPx(table, maxAvailableWidthPx, numberingDefiniti
     rowHeightPx = capSplitFriendlyTableRowEstimatePx(
       row,
       rowHeightPx,
-      explicitHeightPx
+      explicitHeightPx,
+      pageContentHeightPx
     );
     return Math.max(MIN_PARAGRAPH_LINE_HEIGHT_PX, rowHeightPx);
   });
@@ -15526,6 +16259,45 @@ function paragraphSegmentHasPartialLineRange(paragraphLineRange) {
   }
   return paragraphLineRange.startLineIndex > 0 || paragraphLineRange.endLineIndex < paragraphLineRange.totalLineCount;
 }
+function resolveLineRangeWithinVerticalSlice(lineTopOffsetsPx, lineHeightPx, sliceTopPx, sliceBottomPx) {
+  if (lineTopOffsetsPx.length === 0 || !Number.isFinite(lineHeightPx) || lineHeightPx <= 0) {
+    return void 0;
+  }
+  const safeSliceTopPx = Math.max(0, sliceTopPx);
+  const safeSliceBottomPx = Math.max(safeSliceTopPx, sliceBottomPx);
+  const sliceHasHeight = safeSliceBottomPx > safeSliceTopPx;
+  let startLineIndex;
+  let endLineIndex;
+  for (let lineIndex = 0; lineIndex < lineTopOffsetsPx.length; lineIndex += 1) {
+    const lineTopPx = lineTopOffsetsPx[lineIndex] ?? lineIndex * lineHeightPx;
+    const lineBottomPx = lineTopPx + lineHeightPx;
+    const lineBelongsToSlice = sliceHasHeight && lineBottomPx > safeSliceTopPx + PAGE_OVERFLOW_TOLERANCE_PX && lineBottomPx <= safeSliceBottomPx + PAGE_OVERFLOW_TOLERANCE_PX;
+    if (lineBelongsToSlice) {
+      if (startLineIndex === void 0) {
+        startLineIndex = lineIndex;
+      }
+      endLineIndex = lineIndex + 1;
+    }
+  }
+  if (startLineIndex === void 0 || endLineIndex === void 0 || endLineIndex <= startLineIndex) {
+    return void 0;
+  }
+  return {
+    startLineIndex,
+    endLineIndex,
+    totalLineCount: lineTopOffsetsPx.length,
+    lineHeightPx
+  };
+}
+function resolveTableCellParagraphVisualBottomPx(params) {
+  return Math.max(
+    Math.round(params.paragraphTopPx + params.paragraphHeightPx),
+    Math.round(params.textBottomPx)
+  );
+}
+function tableCellParagraphFitsFullyWithinSlice(params) {
+  return params.sliceStartPx <= params.paragraphTopPx + PAGE_OVERFLOW_TOLERANCE_PX && params.sliceBottomPx >= params.paragraphBottomPx + TABLE_CELL_SLICE_FULLY_VISIBLE_BOTTOM_BUFFER_PX - PAGE_OVERFLOW_TOLERANCE_PX;
+}
 function resolveParagraphSegmentClipBleedPx(paragraphLineRange) {
   if (!paragraphSegmentHasPartialLineRange(paragraphLineRange)) {
     return {
@@ -15535,7 +16307,7 @@ function resolveParagraphSegmentClipBleedPx(paragraphLineRange) {
   }
   return {
     topPx: paragraphLineRange && paragraphLineRange.startLineIndex > 0 ? Math.max(0, PARAGRAPH_SEGMENT_TOP_BLEED_PX) : 0,
-    bottomPx: Math.max(0, PARAGRAPH_SEGMENT_DESCENDER_BLEED_PX)
+    bottomPx: paragraphLineRange && paragraphLineRange.endLineIndex < paragraphLineRange.totalLineCount ? Math.max(0, PARAGRAPH_SEGMENT_DESCENDER_BLEED_PX) : 0
   };
 }
 function resolveFallbackParagraphSegmentClipBleedPx(paragraph, paragraphLineRange) {
@@ -15609,12 +16381,32 @@ function estimateRenderedPageSegmentHeightPx(node, segment, model, availableWidt
         false
       ) : 0;
       const afterSpacingPx = paragraphLineRange.endLineIndex >= paragraphLineRange.totalLineCount ? effectiveParagraphAfterSpacingPx(model, segment.nodeIndex, node) : 0;
+      const paragraphPretextSource = buildParagraphPretextLayoutSource(node, {
+        allowExplicitLineBreakText: true,
+        expandTabsForLayout: true
+      });
+      const paragraphPretextLayout = paragraphPretextSource ? layoutParagraphPretextSource(
+        node,
+        paragraphPretextSource,
+        paragraphAvailableTextWidthPx(
+          node,
+          availableWidthPx,
+          numberingDefinitions
+        ),
+        Math.max(1, paragraphLineRange.lineHeightPx),
+        []
+      ) : void 0;
+      const segmentContentHeightPx = paragraphPretextLayout && paragraphPretextLayout.lineCount > 0 ? resolvePretextLineRangeContentHeightPx(
+        paragraphPretextLayout,
+        paragraphLineRange.startLineIndex,
+        paragraphLineRange.endLineIndex
+      ) : Math.max(
+        1,
+        paragraphLineRange.endLineIndex - paragraphLineRange.startLineIndex
+      ) * Math.max(1, paragraphLineRange.lineHeightPx);
       return Math.max(
         1,
-        beforeSpacingPx + Math.max(
-          1,
-          paragraphLineRange.endLineIndex - paragraphLineRange.startLineIndex
-        ) * Math.max(1, paragraphLineRange.lineHeightPx) + afterSpacingPx
+        beforeSpacingPx + segmentContentHeightPx + afterSpacingPx
       );
     }
     return Math.max(
@@ -15755,6 +16547,7 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
   let pageConsumedHeightPx = 0;
   let previousParagraphAfterPx = 0;
   let currentMetricsIndex = 0;
+  let currentSectionPageFlowOriginPx = 0;
   let currentPageContentHeightPx = resolveMetricsPageContentHeightPx(
     0,
     metricsBySection[0]
@@ -15796,11 +16589,13 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
         currentPageIndex,
         nodeMetrics
       );
+      currentSectionPageFlowOriginPx = pageConsumedHeightPx;
     }
     if (hardBreakStartNodeIndexes.has(nodeIndex) && currentPageSegments.length > 0) {
       startNextPage();
       pageConsumedHeightPx = 0;
       previousParagraphAfterPx = 0;
+      currentSectionPageFlowOriginPx = 0;
       currentPageContentHeightPx = resolveMetricsPageContentHeightPx(
         currentPageIndex,
         nodeMetrics
@@ -15855,6 +16650,7 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
         startNextPage();
         pageConsumedHeightPx = 0;
         previousParagraphAfterPx = 0;
+        currentSectionPageFlowOriginPx = 0;
         currentPageContentHeightPx = resolveMetricsPageContentHeightPx(
           currentPageIndex,
           nodeMetrics
@@ -15864,15 +16660,20 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
         startNextPage();
         pageConsumedHeightPx = 0;
         previousParagraphAfterPx = 0;
+        currentSectionPageFlowOriginPx = 0;
         currentPageContentHeightPx = resolveMetricsPageContentHeightPx(
           currentPageIndex,
           nodeMetrics
         );
       }
-      if (preferLastRenderedParagraphStartBreaks && paragraphStartsWithLastRenderedPageBreak(node) && !nodeAlreadyEndsAtExplicitPageBoundary(model.nodes[nodeIndex - 1]) && currentPageSegments.length > 0) {
+      if (preferLastRenderedParagraphStartBreaks && paragraphStartsWithLastRenderedPageBreak(node) && shouldHonorParagraphStartLastRenderedPageBreak({
+        pageConsumedHeightPx,
+        pageContentHeightPx: currentPageContentHeightPx
+      }) && !nodeAlreadyEndsAtExplicitPageBoundary(model.nodes[nodeIndex - 1]) && currentPageSegments.length > 0) {
         startNextPage();
         pageConsumedHeightPx = 0;
         previousParagraphAfterPx = 0;
+        currentSectionPageFlowOriginPx = 0;
         currentPageContentHeightPx = resolveMetricsPageContentHeightPx(
           currentPageIndex,
           nodeMetrics
@@ -15892,7 +16693,36 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
         nodeIndex,
         node
       );
-      const rawNodeHeightPx = Math.max(
+      const paragraphLineHeightPx = estimateParagraphLineHeightPx(
+        node,
+        nodeMetrics.docGridLinePitchPx
+      );
+      const paragraphTextWidthPx = paragraphAvailableTextWidthPx(
+        node,
+        nodeMetrics.pageContentWidthPx,
+        numberingDefinitions
+      );
+      const paragraphPretextSourceForSegmentRendering = buildParagraphPretextLayoutSource(node, {
+        allowExplicitLineBreakText: true,
+        expandTabsForLayout: true
+      });
+      let paragraphPretextLayoutForSegmentRendering;
+      let paragraphPretextLayoutForSegmentRenderingResolved = false;
+      const resolveParagraphPretextLayoutForSegmentRendering = () => {
+        if (paragraphPretextLayoutForSegmentRenderingResolved) {
+          return paragraphPretextLayoutForSegmentRendering;
+        }
+        paragraphPretextLayoutForSegmentRenderingResolved = true;
+        paragraphPretextLayoutForSegmentRendering = paragraphPretextSourceForSegmentRendering ? layoutParagraphPretextSource(
+          node,
+          paragraphPretextSourceForSegmentRendering,
+          paragraphTextWidthPx,
+          paragraphLineHeightPx,
+          []
+        ) : void 0;
+        return paragraphPretextLayoutForSegmentRendering;
+      };
+      let rawNodeHeightPx = Math.max(
         1,
         estimateParagraphHeightPx(
           node,
@@ -15916,6 +16746,7 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
         startNextPage();
         pageConsumedHeightPx = 0;
         previousParagraphAfterPx = 0;
+        currentSectionPageFlowOriginPx = 0;
         currentPageContentHeightPx = resolveMetricsPageContentHeightPx(
           currentPageIndex,
           nodeMetrics
@@ -15926,38 +16757,33 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
         1,
         Math.max(rawNodeHeightPx, coverFootprintPx) - collapsedMarginPx
       );
-      const paragraphLineHeightPx = estimateParagraphLineHeightPx(
-        node,
-        nodeMetrics.docGridLinePitchPx
-      );
-      const paragraphPretextSourceForSegmentRendering = buildParagraphPretextLayoutSource(node, {
-        allowExplicitLineBreakText: true
-      });
       const paragraphSupportsPretextSegmentRendering = Boolean(
         paragraphPretextSourceForSegmentRendering
       );
-      const paragraphPretextLineCount = (() => {
-        if (!paragraphContainsExplicitLineBreakText(node)) {
-          return void 0;
-        }
-        const pretextSource = paragraphPretextSourceForSegmentRendering;
-        if (!pretextSource) {
-          return void 0;
+      const remainingHeightBeforeParagraphPx = Math.max(
+        0,
+        currentPageContentHeightPx - pageConsumedHeightPx
+      );
+      if (paragraphSupportsPretextSegmentRendering && remainingHeightBeforeParagraphPx <= collapsedNodeHeightPx + paragraphLineHeightPx + PAGE_OVERFLOW_TOLERANCE_PX) {
+        const pretextLayout = resolveParagraphPretextLayoutForSegmentRendering();
+        const pretextContentHeightPx = pretextLayout ? wrappedPretextParagraphBlockHeightPx(pretextLayout) : void 0;
+        if (Number.isFinite(pretextContentHeightPx)) {
+          rawNodeHeightPx = Math.max(
+            rawNodeHeightPx,
+            Math.max(
+              1,
+              Math.round(
+                beforeSpacingPx + pretextContentHeightPx + afterSpacingPx
+              )
+            )
+          );
         }
-        const paragraphTextWidthPx = paragraphAvailableTextWidthPx(
-          node,
-          nodeMetrics.pageContentWidthPx,
-          numberingDefinitions
-        );
-        const pretextLayout = layoutParagraphPretextSource(
-          node,
-          pretextSource,
-          paragraphTextWidthPx,
-          paragraphLineHeightPx,
-          []
-        );
-        return pretextLayout?.lineCount;
-      })();
+      }
+      const collapsedNodeHeightPxAdjusted = Math.max(
+        1,
+        Math.max(rawNodeHeightPx, coverFootprintPx) - collapsedMarginPx
+      );
+      const paragraphPretextLineCount = paragraphContainsExplicitLineBreakText(node) || paragraphContainsTabCharacter(node) ? resolveParagraphPretextLayoutForSegmentRendering()?.lineCount : void 0;
       const supportsImageParagraphLineSplit = paragraphHasImage2(node) && paragraphSupportsPretextSegmentRendering;
       const paragraphLineCount = paragraphLineCountWithinWidth(
         node,
@@ -15965,6 +16791,54 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
         numberingDefinitions
       );
       const resolvedParagraphLineCount = Number.isFinite(paragraphPretextLineCount) && paragraphPretextLineCount > 0 ? Math.max(1, Math.round(paragraphPretextLineCount)) : paragraphLineCount;
+      const explicitColumnBreakParagraphSegments = (nodeMetrics.pageContentHeightMultiplier ?? 1) > 1 ? splitParagraphAtExplicitColumnBreaks(node) : void 0;
+      const tryConsumeExplicitColumnBreakParagraph = () => {
+        if (!explicitColumnBreakParagraphSegments || explicitColumnBreakParagraphSegments.length <= 1) {
+          return false;
+        }
+        const projectedConsumedHeightPx = projectParagraphConsumedHeightWithExplicitColumnBreaks(
+          explicitColumnBreakParagraphSegments,
+          pageConsumedHeightPx,
+          currentPageContentHeightPx,
+          currentSectionPageFlowOriginPx,
+          Math.max(
+            1,
+            Math.round(nodeMetrics.pageContentHeightMultiplier ?? 1)
+          ),
+          nodeMetrics.pageContentWidthPx,
+          beforeSpacingPx,
+          afterSpacingPx,
+          collapsedMarginPx,
+          numberingDefinitions,
+          nodeMetrics.docGridLinePitchPx
+        );
+        if (!Number.isFinite(projectedConsumedHeightPx)) {
+          return false;
+        }
+        currentPageSegments.push({ nodeIndex });
+        pageConsumedHeightPx = Math.max(
+          pageConsumedHeightPx,
+          Math.round(projectedConsumedHeightPx)
+        );
+        previousParagraphAfterPx = afterSpacingPx;
+        return true;
+      };
+      if (tryConsumeExplicitColumnBreakParagraph()) {
+        continue;
+      }
+      if (explicitColumnBreakParagraphSegments && explicitColumnBreakParagraphSegments.length > 1 && pageConsumedHeightPx > 0 && currentPageSegments.length > 0) {
+        startNextPage();
+        pageConsumedHeightPx = 0;
+        previousParagraphAfterPx = 0;
+        currentSectionPageFlowOriginPx = 0;
+        currentPageContentHeightPx = resolveMetricsPageContentHeightPx(
+          currentPageIndex,
+          nodeMetrics
+        );
+        if (tryConsumeExplicitColumnBreakParagraph()) {
+          continue;
+        }
+      }
       const widowControlEnabled = paragraphWidowControlEnabled(node);
       const minLinesPerSegment = widowControlEnabled ? 2 : 1;
       const canSplitParagraphAcrossPages = paragraphCanSplitAcrossPages(node, resolvedParagraphLineCount, {
@@ -15973,6 +16847,7 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
         allowImageParagraphSplit: supportsImageParagraphLineSplit
       }) && (!widowControlEnabled || resolvedParagraphLineCount > 3);
       if (canSplitParagraphAcrossPages && allowParagraphLineSplitting) {
+        const pretextLayoutForSegmentSplitting = resolveParagraphPretextLayoutForSegmentRendering();
         const resolveSegmentReservePx = (startLineIndex, endLineIndex) => {
           const paragraphSegmentRange = {
             startLineIndex,
@@ -15985,6 +16860,16 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
             paragraphSegmentRange
           );
         };
+        const resolveSegmentContentHeightPx = (startLineIndex, endLineIndex) => {
+          if (pretextLayoutForSegmentSplitting && pretextLayoutForSegmentSplitting.lineCount > 0) {
+            return resolvePretextLineRangeContentHeightPx(
+              pretextLayoutForSegmentSplitting,
+              startLineIndex,
+              endLineIndex
+            );
+          }
+          return Math.max(1, endLineIndex - startLineIndex) * paragraphLineHeightPx;
+        };
         let lineCursor = 0;
         let isFirstSegment = true;
         while (lineCursor < resolvedParagraphLineCount) {
@@ -16000,7 +16885,10 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
             lineCursor,
             resolvedParagraphLineCount
           );
-          const allRemainingHeightPx = topSpacingPx + linesRemaining * paragraphLineHeightPx + bottomSpacingPx;
+          const allRemainingHeightPx = topSpacingPx + resolveSegmentContentHeightPx(
+            lineCursor,
+            resolvedParagraphLineCount
+          ) + bottomSpacingPx;
           if (allRemainingHeightPx + allRemainingSegmentReservePx <= remainingHeightPx2) {
             currentPageSegments.push({
               nodeIndex,
@@ -16032,11 +16920,27 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
             availableForLinesPx / paragraphLineHeightPx
           );
           linesThatFit = Math.min(linesThatFit, maxLinesThisPage);
+          if (pretextLayoutForSegmentSplitting && pretextLayoutForSegmentSplitting.lineCount > 0 && linesThatFit > 0) {
+            const exactSegmentEndLineIndex = resolveMaxPretextLineRangeEndIndexThatFits(
+              pretextLayoutForSegmentSplitting,
+              lineCursor,
+              Math.min(
+                resolvedParagraphLineCount,
+                lineCursor + linesThatFit
+              ),
+              availableForLinesPx
+            );
+            linesThatFit = Math.max(
+              0,
+              exactSegmentEndLineIndex - lineCursor
+            );
+          }
           if (linesThatFit < minLinesPerSegment) {
             if (currentPageSegments.length > 0) {
               startNextPage();
               pageConsumedHeightPx = 0;
               previousParagraphAfterPx = 0;
+              currentSectionPageFlowOriginPx = 0;
               currentPageContentHeightPx = resolveMetricsPageContentHeightPx(
                 currentPageIndex,
                 nodeMetrics
@@ -16066,7 +16970,10 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
               lineCursor,
               segmentEndLineIndex
             );
-            if (topSpacingPx + (segmentEndLineIndex - lineCursor) * paragraphLineHeightPx + segmentReservePx <= remainingHeightPx2) {
+            if (topSpacingPx + resolveSegmentContentHeightPx(
+              lineCursor,
+              segmentEndLineIndex
+            ) + segmentReservePx <= remainingHeightPx2) {
               break;
             }
             linesThatFit -= 1;
@@ -16088,7 +16995,7 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
               lineHeightPx: paragraphLineHeightPx
             }
           });
-          pageConsumedHeightPx += topSpacingPx + (safeSegmentEndLineIndex - lineCursor) * paragraphLineHeightPx;
+          pageConsumedHeightPx += topSpacingPx + resolveSegmentContentHeightPx(lineCursor, safeSegmentEndLineIndex);
           previousParagraphAfterPx = 0;
           lineCursor = safeSegmentEndLineIndex;
           isFirstSegment = false;
@@ -16096,6 +17003,7 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
             startNextPage();
             pageConsumedHeightPx = 0;
             previousParagraphAfterPx = 0;
+            currentSectionPageFlowOriginPx = 0;
             currentPageContentHeightPx = resolveMetricsPageContentHeightPx(
               currentPageIndex,
               nodeMetrics
@@ -16104,7 +17012,7 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
         }
         continue;
       }
-      let requiredHeightPx = collapsedNodeHeightPx;
+      let requiredHeightPx = collapsedNodeHeightPxAdjusted;
       if (node.style?.keepNext === true && paragraphHasVisibleText2(node)) {
         let chainCursor = nodeIndex;
         let chainPreviousParagraphAfterPx = afterSpacingPx;
@@ -16158,6 +17066,11 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
             1,
             nextRawHeightPx - collapsedChainMarginPx
           );
+          requiredHeightPx += keepNextPaginationReservePx(
+            currentChainNode,
+            nextChainNode,
+            chainMetrics.docGridLinePitchPx
+          );
           chainPreviousParagraphAfterPx = nextAfterSpacingPx;
         }
       }
@@ -16195,6 +17108,7 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
         startNextPage();
         pageConsumedHeightPx = 0;
         previousParagraphAfterPx = 0;
+        currentSectionPageFlowOriginPx = 0;
         currentPageContentHeightPx = resolveMetricsPageContentHeightPx(
           currentPageIndex,
           nodeMetrics
@@ -16220,7 +17134,8 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
       node,
       nodeMetrics.pageContentWidthPx,
       numberingDefinitions,
-      nodeMetrics.docGridLinePitchPx
+      nodeMetrics.docGridLinePitchPx,
+      nodeMetrics.pageContentHeightPx
     );
     if (!measuredRowHeightsPx && !estimatedRowHeightsByTableNodeIndex.has(nodeIndex)) {
       estimatedRowHeightsByTableNodeIndex.set(nodeIndex, estimatedRowHeightsPx);
@@ -16236,14 +17151,45 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
       startNextPage();
       pageConsumedHeightPx = 0;
       previousParagraphAfterPx = 0;
+      currentSectionPageFlowOriginPx = 0;
       currentPageContentHeightPx = resolveMetricsPageContentHeightPx(
         currentPageIndex,
         nodeMetrics
       );
     }
+    let headerRunLength = 0;
+    for (const row of node.rows) {
+      if (row.style?.isHeader === true) {
+        headerRunLength += 1;
+      } else {
+        break;
+      }
+    }
+    const headerRunHeightPx = headerRunLength > 0 ? sumEstimatedTableRowHeightsPx(
+      estimatedRowHeightsPx,
+      0,
+      headerRunLength
+    ) : 0;
+    const canRepeatHeader = headerRunLength > 0 && headerRunHeightPx > 0 && headerRunHeightPx + MIN_PARAGRAPH_LINE_HEIGHT_PX * 2 < currentPageContentHeightPx;
     let rowStartIndex = 0;
     let rowSliceOffsetPx = 0;
+    let repeatedHeaderHeightPxOnThisPage = 0;
     while (rowStartIndex < estimatedRowHeightsPx.length) {
+      if (currentPageSegments.length === 0) {
+        repeatedHeaderHeightPxOnThisPage = 0;
+      }
+      if (canRepeatHeader && rowStartIndex >= headerRunLength && currentPageSegments.length === 0) {
+        currentPageSegments.push({
+          nodeIndex,
+          tableRowRange: {
+            startRowIndex: 0,
+            endRowIndex: headerRunLength
+          }
+        });
+        pageConsumedHeightPx += headerRunHeightPx;
+        previousParagraphAfterPx = 0;
+        repeatedHeaderHeightPxOnThisPage = headerRunHeightPx;
+      }
       const remainingHeightPx = Math.max(
         0,
         currentPageContentHeightPx - pageConsumedHeightPx
@@ -16257,7 +17203,11 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
         0,
         currentRowTotalHeightPx - rowSliceOffsetPx
       );
-      const rowExceedsFreshPageHeightPx = currentRowTotalHeightPx > currentPageContentHeightPx + PAGE_OVERFLOW_TOLERANCE_PX;
+      const freshPageAvailableHeightPx = Math.max(
+        MIN_PARAGRAPH_LINE_HEIGHT_PX,
+        currentPageContentHeightPx - repeatedHeaderHeightPxOnThisPage
+      );
+      const rowExceedsFreshPageHeightPx = currentRowTotalHeightPx > freshPageAvailableHeightPx + PAGE_OVERFLOW_TOLERANCE_PX;
       const canSplitCurrentRow = rowSliceOffsetPx > 0 || rowAllowsPageSplit(currentRow) || rowExceedsFreshPageHeightPx;
       const shouldContinueExistingRowSlice = rowSliceOffsetPx > 0;
       const rowNeedsSliceOnThisPage = ENABLE_TABLE_ROW_SLICING && canSplitCurrentRow && currentRowRemainingHeightPx > remainingHeightPx + PAGE_OVERFLOW_TOLERANCE_PX && (shouldContinueExistingRowSlice || rowExceedsFreshPageHeightPx);
@@ -16265,6 +17215,7 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
         startNextPage();
         pageConsumedHeightPx = 0;
         previousParagraphAfterPx = 0;
+        currentSectionPageFlowOriginPx = 0;
         currentPageContentHeightPx = resolveMetricsPageContentHeightPx(
           currentPageIndex,
           nodeMetrics
@@ -16276,6 +17227,7 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
           startNextPage();
           pageConsumedHeightPx = 0;
           previousParagraphAfterPx = 0;
+          currentSectionPageFlowOriginPx = 0;
           currentPageContentHeightPx = resolveMetricsPageContentHeightPx(
             currentPageIndex,
             nodeMetrics
@@ -16317,6 +17269,7 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
           startNextPage();
           pageConsumedHeightPx = 0;
           previousParagraphAfterPx = 0;
+          currentSectionPageFlowOriginPx = 0;
           currentPageContentHeightPx = resolveMetricsPageContentHeightPx(
             currentPageIndex,
             nodeMetrics
@@ -16325,6 +17278,24 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
         continue;
       }
       if (rowSliceOffsetPx > 0) {
+        currentPageSegments.push({
+          nodeIndex,
+          tableRowRange: {
+            startRowIndex: rowStartIndex,
+            endRowIndex: Math.min(
+              estimatedRowHeightsPx.length,
+              rowStartIndex + 1
+            )
+          },
+          tableRowSlice: {
+            rowIndex: rowStartIndex,
+            startOffsetPx: rowSliceOffsetPx,
+            sliceHeightPx: currentRowRemainingHeightPx,
+            totalRowHeightPx: currentRowTotalHeightPx
+          }
+        });
+        pageConsumedHeightPx += currentRowRemainingHeightPx;
+        previousParagraphAfterPx = 0;
         rowStartIndex += 1;
         rowSliceOffsetPx = 0;
         continue;
@@ -16347,6 +17318,7 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
           startNextPage();
           pageConsumedHeightPx = 0;
           previousParagraphAfterPx = 0;
+          currentSectionPageFlowOriginPx = 0;
           currentPageContentHeightPx = resolveMetricsPageContentHeightPx(
             currentPageIndex,
             nodeMetrics
@@ -16377,6 +17349,7 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
           startNextPage();
           pageConsumedHeightPx = 0;
           previousParagraphAfterPx = 0;
+          currentSectionPageFlowOriginPx = 0;
           currentPageContentHeightPx = resolveMetricsPageContentHeightPx(
             currentPageIndex,
             nodeMetrics
@@ -16405,6 +17378,7 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
         startNextPage();
         pageConsumedHeightPx = 0;
         previousParagraphAfterPx = 0;
+        currentSectionPageFlowOriginPx = 0;
         currentPageContentHeightPx = resolveMetricsPageContentHeightPx(
           currentPageIndex,
           nodeMetrics
@@ -16876,6 +17850,10 @@ function resolveHighlightColor(value) {
 }
 function paragraphLineHeight(paragraph, docGridLinePitchPx, disableDocGridSnap = false) {
   const baseFontFamily = paragraphDominantFontFamily(paragraph);
+  const singleLineScale = resolveParagraphSingleLineAutoScale(
+    paragraph,
+    baseFontFamily
+  );
   const lineTwips = paragraph.style?.spacing?.lineTwips;
   const docGridMinimumLineHeightPx = resolveParagraphDocGridLinePitchPx(
     paragraph,
@@ -16892,7 +17870,8 @@ function paragraphLineHeight(paragraph, docGridLinePitchPx, disableDocGridSnap =
     }
     return calibrateAutoLineSpacingMultiple(
       DEFAULT_PARAGRAPH_LINE_MULTIPLE,
-      baseFontFamily
+      baseFontFamily,
+      singleLineScale
     );
   }
   const lineRule = paragraph.style?.spacing?.lineRule ?? "auto";
@@ -16909,7 +17888,8 @@ function paragraphLineHeight(paragraph, docGridLinePitchPx, disableDocGridSnap =
         lineTwips,
         DEFAULT_PARAGRAPH_LINE_MULTIPLE
       ),
-      baseFontFamily
+      baseFontFamily,
+      singleLineScale
     );
     return Number(lineMultiple.toFixed(3));
   }
@@ -16920,7 +17900,8 @@ function paragraphLineHeight(paragraph, docGridLinePitchPx, disableDocGridSnap =
       Math.round(
         paragraphBaseFontSizePx(paragraph) * calibrateAutoLineSpacingMultiple(
           DEFAULT_PARAGRAPH_LINE_MULTIPLE,
-          baseFontFamily
+          baseFontFamily,
+          singleLineScale
         )
       )
     );
@@ -16936,12 +17917,29 @@ function paragraphLineHeight(paragraph, docGridLinePitchPx, disableDocGridSnap =
   if (lineRule === "exact") {
     return calibrateAutoLineSpacingMultiple(
       DEFAULT_PARAGRAPH_LINE_MULTIPLE,
-      baseFontFamily
+      baseFontFamily,
+      singleLineScale
     );
   }
   return calibrateAutoLineSpacingMultiple(
     DEFAULT_PARAGRAPH_LINE_MULTIPLE,
-    baseFontFamily
+    baseFontFamily,
+    singleLineScale
+  );
+}
+function keepNextPaginationReservePx(paragraph, nextParagraph, docGridLinePitchPx) {
+  if (paragraph.style?.keepNext !== true || !nextParagraph || !Number.isFinite(paragraph.style?.headingLevel)) {
+    return 0;
+  }
+  const nextParagraphText = paragraphText(nextParagraph).replace(/\s+/g, " ").trim();
+  if (nextParagraph.style?.numbering === void 0 && nextParagraphText.length < 80) {
+    return 0;
+  }
+  return Math.max(
+    nextParagraph.style?.numbering ? 10 : 6,
+    Math.round(
+      estimateParagraphLineHeightPx(nextParagraph, docGridLinePitchPx) * (nextParagraph.style?.numbering ? 1 : 0.5)
+    )
   );
 }
 function paragraphBorderToCss(border) {
@@ -17515,6 +18513,17 @@ function tableOfContentsLeadingLeftTabStopPx(paragraph) {
   ).sort((left, right) => left - right);
   return leftTabStopPositionsPx[0];
 }
+function paragraphContainsTabCharacter(paragraph) {
+  return paragraph.children.some((child) => {
+    if (child.type === "text") {
+      return child.text.includes("	");
+    }
+    if (child.type === "form-field") {
+      return formFieldDisplayValue2(child).includes("	");
+    }
+    return false;
+  });
+}
 function paragraphTabCharacterCount(paragraph) {
   return paragraph.children.reduce((count, child) => {
     const text = child.type === "text" ? child.text : child.type === "form-field" ? formFieldDisplayValue2(child) : "";
@@ -18909,6 +19918,7 @@ function renderParagraphRuns(paragraph, keyPrefix, documentTheme = "light", numb
   ) ? Math.round(options?.floatingAnchorOriginCorrectionXPx) : 0;
   const checkboxChoiceRow = paragraphLooksLikeCheckboxChoiceRow(paragraph);
   const fallbackTabWidthPx = checkboxChoiceRow ? checkboxChoiceRowTabWidthPx(paragraph) : DEFAULT_TAB_STOP_PX;
+  const tabLeaderLeftTabStopPositionsPx = useTabLeaderLayout ? resolveParagraphFirstLineLeftTabStopsPx(paragraph) : [];
   const shouldTrackTabLineWidth = !useTabLeaderLayout && !useAnchoredTabLayout;
   let approximateLineWidthPx = 0;
   let trackedVisibleChildCursor = 0;
@@ -19027,6 +20037,32 @@ function renderParagraphRuns(paragraph, keyPrefix, documentTheme = "light", numb
       lineHeight: "1em"
     };
   };
+  const renderTabLeaderLeftSpacer = (target, key, style, trackedInlineChange, widthPx) => {
+    const textStyle = trackedInlineStyle(
+      runStyleToCss(style, documentTheme),
+      trackedInlineChange
+    );
+    const hasUnderline = Boolean(style?.underline);
+    target.push(
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        "span",
+        {
+          style: {
+            ...textStyle,
+            display: "inline-block",
+            width: widthPx,
+            minWidth: widthPx,
+            whiteSpace: "pre",
+            textDecoration: hasUnderline ? "none" : textStyle.textDecoration,
+            borderBottom: hasUnderline ? "1px solid currentColor" : void 0,
+            lineHeight: "1em"
+          },
+          children: "\xA0"
+        },
+        key
+      )
+    );
+  };
   const resolvePageFieldText = (value, preferredZone) => {
     if (!hasPageField || value.trim().length === 0) {
       return value;
@@ -19316,7 +20352,10 @@ function renderParagraphRuns(paragraph, keyPrefix, documentTheme = "light", numb
         (() => {
           const cropLayout = imageCropLayout(child, widthPx, heightPx);
           const imageVisualStyle = {
-            filter: appendCssFilters(child.cssFilter, options?.imageFilterSuffix),
+            filter: appendCssFilters(
+              child.cssFilter,
+              options?.imageFilterSuffix
+            ),
             opacity: child.cssOpacity
           };
           const imageTransformStyle = resolveImageRenderTransformStyle(child, {
@@ -19637,14 +20676,42 @@ function renderParagraphRuns(paragraph, keyPrefix, documentTheme = "light", numb
           return;
         }
         if (leftText.length > 0) {
-          renderRun(
-            runsLeft,
-            child,
-            `${keyPrefix}-run-${childIndex}-left`,
-            resolveFieldText(leftText, 0),
-            trackedInlineChange,
-            childIndex
-          );
+          let tabLeaderLeftLineWidthPx = 0;
+          const leftTextParts = leftText.split("	");
+          leftTextParts.forEach((part, partIndex) => {
+            if (part.length > 0) {
+              const resolvedPart = resolveFieldText(part, 0);
+              renderRun(
+                runsLeft,
+                child,
+                `${keyPrefix}-run-${childIndex}-left-${partIndex}`,
+                resolvedPart,
+                trackedInlineChange,
+                childIndex
+              );
+              tabLeaderLeftLineWidthPx = updateEstimatedLineWidthPxForText(
+                tabLeaderLeftLineWidthPx,
+                resolvedPart,
+                child.style
+              );
+            }
+            if (partIndex >= leftTextParts.length - 1) {
+              return;
+            }
+            const tabWidthPx = resolveTabSpacerWidthPx(
+              tabLeaderLeftTabStopPositionsPx,
+              tabLeaderLeftLineWidthPx,
+              fallbackTabWidthPx
+            );
+            renderTabLeaderLeftSpacer(
+              runsLeft,
+              `${keyPrefix}-run-${childIndex}-left-tab-${partIndex}`,
+              child.style,
+              trackedInlineChange,
+              tabWidthPx
+            );
+            tabLeaderLeftLineWidthPx += tabWidthPx;
+          });
         }
         renderRun(
           runsRight,
@@ -19870,10 +20937,10 @@ function renderParagraphRuns(paragraph, keyPrefix, documentTheme = "light", numb
           {
             "data-docx-tab-zone": "left",
             style: {
-              display: "inline-flex",
+              display: "block",
+              flex: "0 1 auto",
               minWidth: 0,
-              whiteSpace: "pre-wrap",
-              alignItems: "baseline"
+              whiteSpace: "pre-wrap"
             },
             children: runsLeft
           }
@@ -19901,12 +20968,13 @@ function renderParagraphRuns(paragraph, keyPrefix, documentTheme = "light", numb
           {
             "data-docx-tab-zone": "right",
             style: {
-              display: "inline-flex",
-              minWidth: 0,
-              justifyContent: "flex-end",
+              display: "block",
+              flex: "0 0 max-content",
+              minWidth: "max-content",
+              width: "max-content",
               textAlign: "right",
-              whiteSpace: "pre-wrap",
-              alignItems: "baseline"
+              whiteSpace: "nowrap",
+              textIndent: 0
             },
             children: runsRight
           }
@@ -20156,20 +21224,7 @@ function buildParagraphNumberingLabels(model) {
     ])
   );
   const countersByNumId = /* @__PURE__ */ new Map();
-  const headingCountersByAbstractNumId = /* @__PURE__ */ new Map();
-  const isHeadingLikeParagraph = (paragraph) => {
-    if (Number.isFinite(paragraph.style?.headingLevel)) {
-      return true;
-    }
-    if (isTableOfContentsParagraph(paragraph)) {
-      return true;
-    }
-    const styleId = paragraph.style?.styleId?.trim().toLowerCase();
-    if (!styleId) {
-      return false;
-    }
-    return /(?:^|[\s_-])heading(?:[\s_-]?\d+)?$/.test(styleId) || /^heading\d*$/.test(styleId);
-  };
+  const abstractCountersByAbstractNumId = /* @__PURE__ */ new Map();
   const registerParagraph = (paragraph, key) => {
     const paragraphNumbering = paragraph.style?.numbering;
     if (!paragraphNumbering || paragraphNumbering.numId <= 0) {
@@ -20180,13 +21235,12 @@ function buildParagraphNumberingLabels(model) {
     const level = findNumberingLevelDefinition(numbering, numId, ilvl);
     const numberingInstance = numberingInstanceByNumId.get(numId);
     const abstractNumId = numberingInstance?.abstractNumId;
-    const isSharedCounterParagraph = isHeadingLikeParagraph(paragraph);
     const template = level?.text ?? `%${ilvl + 1}.`;
     if (!template || template.trim().length === 0) {
       return;
     }
     const counters = countersByNumId.get(numId) ?? [];
-    const sharedAbstractCounters = isSharedCounterParagraph && Number.isFinite(abstractNumId) ? headingCountersByAbstractNumId.get(abstractNumId) ?? [] : void 0;
+    const sharedAbstractCounters = Number.isFinite(abstractNumId) ? abstractCountersByAbstractNumId.get(abstractNumId) ?? [] : void 0;
     let parentCountersChanged = false;
     for (let index = 0; index < ilvl; index += 1) {
       const abstractCounterValue = sharedAbstractCounters && Number.isFinite(sharedAbstractCounters[index]) ? Math.max(1, Math.round(sharedAbstractCounters[index])) : void 0;
@@ -20215,7 +21269,7 @@ function buildParagraphNumberingLabels(model) {
       for (let index = ilvl + 1; index < sharedAbstractCounters.length; index += 1) {
         sharedAbstractCounters[index] = void 0;
       }
-      headingCountersByAbstractNumId.set(
+      abstractCountersByAbstractNumId.set(
         abstractNumId,
         sharedAbstractCounters
       );
@@ -20961,6 +22015,14 @@ function tableBorderToCss(border) {
   const color = border?.color ?? "#000000";
   return `${widthPx}px ${cssStyle} ${color}`;
 }
+function tableBorderStrokeWidthPx(border) {
+  const type = normalizeBorderType(border?.type);
+  if (!type || type === "none" || type === "nil") {
+    return 0;
+  }
+  const sizeEighthPt = border?.sizeEighthPt;
+  return Number.isFinite(sizeEighthPt) && sizeEighthPt > 0 ? Math.max(0.5, Number((sizeEighthPt / 6).toFixed(2))) : 1;
+}
 function borderTypeVisible(type) {
   const normalizedType = normalizeBorderType(type);
   return Boolean(
@@ -21412,6 +22474,68 @@ function resolveTableCellBorderCss(tableBorders, cellBorders, rowIndex, rowCount
     ...left !== void 0 ? { borderLeft: left } : void 0
   };
 }
+function resolveCollapsedTableHorizontalOuterBleedPx(table, columnCount = tableColumnCount(table)) {
+  if (columnCount <= 0 || tableUsesSeparateBorderModel(table)) {
+    return 0;
+  }
+  const rowCount = table.rows.length;
+  const tableBorders = table.style?.borders;
+  let maxLeftBorderWidthPx = tableBorderStrokeWidthPx(tableBorders?.left);
+  let maxRightBorderWidthPx = tableBorderStrokeWidthPx(tableBorders?.right);
+  table.rows.forEach((row, rowIndex) => {
+    let columnCursor = 0;
+    row.cells.forEach((cell) => {
+      const columnSpan = cell.style?.gridSpan && cell.style.gridSpan > 1 ? cell.style.gridSpan : 1;
+      const startColumnIndex = columnCursor;
+      const endColumnIndex = Math.min(
+        columnCount - 1,
+        startColumnIndex + columnSpan - 1
+      );
+      columnCursor += columnSpan;
+      if (cell.style?.vMergeContinuation) {
+        return;
+      }
+      if (startColumnIndex === 0) {
+        maxLeftBorderWidthPx = Math.max(
+          maxLeftBorderWidthPx,
+          tableBorderStrokeWidthPx(
+            resolveTableBorder(
+              tableBorders,
+              cell.style?.borders,
+              "left",
+              rowIndex,
+              rowCount,
+              startColumnIndex,
+              endColumnIndex,
+              columnCount
+            )
+          )
+        );
+      }
+      if (endColumnIndex >= columnCount - 1) {
+        maxRightBorderWidthPx = Math.max(
+          maxRightBorderWidthPx,
+          tableBorderStrokeWidthPx(
+            resolveTableBorder(
+              tableBorders,
+              cell.style?.borders,
+              "right",
+              rowIndex,
+              rowCount,
+              startColumnIndex,
+              endColumnIndex,
+              columnCount
+            )
+          )
+        );
+      }
+    });
+  });
+  return Math.max(
+    0,
+    Math.ceil((maxLeftBorderWidthPx + maxRightBorderWidthPx) / 2)
+  );
+}
 function resolveTableCellDiagonalOverlayCss(tableBorders, cellBorders) {
   const diagonalDownBorder = cellBorders?.tl2br ?? tableBorders?.tl2br;
   const diagonalUpBorder = cellBorders?.tr2bl ?? tableBorders?.tr2bl;
@@ -23303,6 +24427,7 @@ function useDocxEditor(options = {}) {
   const [status, setStatus] = React.useState(
     options.initialStatus ?? "Ready"
   );
+  const [isImporting, setIsImporting] = React.useState(false);
   const [documentTheme, setDocumentThemeState] = React.useState(options.initialDocumentTheme ?? "light");
   const [showTrackedChanges, setShowTrackedChangesState] = React.useState(options.initialShowTrackedChanges ?? false);
   const [paginationInfo, setPaginationInfo] = React.useState({
@@ -23825,26 +24950,40 @@ function useDocxEditor(options = {}) {
         setStatus("Only .docx files are supported");
         return;
       }
+      setIsImporting(true);
+      setStatus(`Loading ${file.name}\u2026`);
+      await new Promise((resolve) => {
+        if (typeof requestAnimationFrame === "function") {
+          requestAnimationFrame(() => {
+            requestAnimationFrame(() => resolve());
+          });
+        } else {
+          setTimeout(resolve, 0);
+        }
+      });
       try {
         const buffer = await file.arrayBuffer();
-        const pkg = await parseDocx(buffer);
+        const { pkg, model: nextModel } = await importDocxViaWorker(buffer);
         await loadEmbeddedFontsFromPackage(pkg);
-        const nextModel = buildDocModel(pkg);
-        setModel(nextModel);
-        setDocumentLoadNonce((current) => current + 1);
-        setHistory({ past: [], future: [] });
-        setHistoryRestoreRequest(void 0);
-        setBasePackage(pkg);
-        setFileName(file.name);
-        setSelection({ kind: "paragraph", nodeIndex: 0 });
-        setActiveTextRangeState(void 0);
-        setPendingRunStyle(void 0);
-        setSelectedFormFieldLocation(void 0);
+        React.startTransition(() => {
+          setModel(nextModel);
+          setDocumentLoadNonce((current) => current + 1);
+          setHistory({ past: [], future: [] });
+          setHistoryRestoreRequest(void 0);
+          setBasePackage(pkg);
+          setFileName(file.name);
+          setSelection({ kind: "paragraph", nodeIndex: 0 });
+          setActiveTextRangeState(void 0);
+          setPendingRunStyle(void 0);
+          setSelectedFormFieldLocation(void 0);
+        });
         setStatus(`Loaded ${file.name}`);
       } catch (error) {
         setStatus(
           `Failed to load file: ${error instanceof Error ? error.message : "Unknown error"}`
         );
+      } finally {
+        setIsImporting(false);
       }
     },
     [loadEmbeddedFontsFromPackage]
@@ -26769,6 +27908,7 @@ function useDocxEditor(options = {}) {
     documentLoadNonce,
     fileName,
     status,
+    isImporting,
     documentTheme,
     trackedChanges,
     showTrackedChanges,
@@ -27006,8 +28146,15 @@ async function rasterizeDocxViewerPageSurfaceToCanvas(params) {
 function resolveDocxPageThumbnailResolution(options) {
   const safeSourceWidthPx = Math.max(1, Math.round(options.sourceWidthPx));
   const safeSourceHeightPx = Math.max(1, Math.round(options.sourceHeightPx));
-  const widthBoundPx = Number.isFinite(options.maxWidthPx) ? Math.max(1, Math.round(options.maxWidthPx)) : 180;
-  const heightBoundPx = Number.isFinite(options.maxHeightPx) ? Math.max(1, Math.round(options.maxHeightPx)) : Number.POSITIVE_INFINITY;
+  const resolutionBounds = typeof options.resolution === "number" && Number.isFinite(options.resolution) && options.resolution > 0 ? {
+    maxWidthPx: Number(options.resolution),
+    maxHeightPx: Number(options.resolution)
+  } : typeof options.resolution === "object" && options.resolution ? {
+    maxWidthPx: Number.isFinite(options.resolution.maxWidth) && Number(options.resolution.maxWidth) > 0 ? Number(options.resolution.maxWidth) : void 0,
+    maxHeightPx: Number.isFinite(options.resolution.maxHeight) && Number(options.resolution.maxHeight) > 0 ? Number(options.resolution.maxHeight) : void 0
+  } : void 0;
+  const widthBoundPx = Number.isFinite(options.maxWidthPx) ? Math.max(1, Math.round(options.maxWidthPx)) : Number.isFinite(resolutionBounds?.maxWidthPx) ? Math.max(1, Math.round(resolutionBounds?.maxWidthPx)) : 180;
+  const heightBoundPx = Number.isFinite(options.maxHeightPx) ? Math.max(1, Math.round(options.maxHeightPx)) : Number.isFinite(resolutionBounds?.maxHeightPx) ? Math.max(1, Math.round(resolutionBounds?.maxHeightPx)) : Number.POSITIVE_INFINITY;
   const scale = Math.min(
     1,
     widthBoundPx / safeSourceWidthPx,
@@ -27046,12 +28193,9 @@ function useDocxPageThumbnails(editor, options = {}) {
     [pageSurfaceRegistryEditor]
   );
   React.useEffect(
-    () => subscribeDocxViewerPageSurfaces(
-      pageSurfaceRegistryEditor,
-      () => {
-        setPageSurfaceEpoch((current) => current + 1);
-      }
-    ),
+    () => subscribeDocxViewerPageSurfaces(pageSurfaceRegistryEditor, () => {
+      setPageSurfaceEpoch((current) => current + 1);
+    }),
     [pageSurfaceRegistryEditor]
   );
   const mountedPageElements = React.useMemo(
@@ -27094,6 +28238,7 @@ function useDocxPageThumbnails(editor, options = {}) {
       const resolution = resolveDocxPageThumbnailResolution({
         sourceWidthPx: sourceSize.widthPx,
         sourceHeightPx: sourceSize.heightPx,
+        resolution: options.resolution,
         maxWidthPx: options.maxWidthPx,
         maxHeightPx: options.maxHeightPx,
         pixelRatio: options.pixelRatio
@@ -27124,6 +28269,7 @@ function useDocxPageThumbnails(editor, options = {}) {
       fallbackLayout.pageWidthPx,
       mountedPageElements,
       options.disabled,
+      options.resolution,
       options.maxHeightPx,
       options.maxWidthPx,
       options.pixelRatio,
@@ -27136,7 +28282,9 @@ function useDocxPageThumbnails(editor, options = {}) {
     );
     await Promise.all(tasks);
   }, [renderPageThumbnailToCanvas]);
-  const renderPageThumbnailToCanvasRef = React.useRef(renderPageThumbnailToCanvas);
+  const renderPageThumbnailToCanvasRef = React.useRef(
+    renderPageThumbnailToCanvas
+  );
   React.useEffect(() => {
     renderPageThumbnailToCanvasRef.current = renderPageThumbnailToCanvas;
   }, [renderPageThumbnailToCanvas]);
@@ -27152,6 +28300,7 @@ function useDocxPageThumbnails(editor, options = {}) {
     editor.model,
     mountedPageElements,
     options.disabled,
+    options.resolution,
     options.maxHeightPx,
     options.maxWidthPx,
     options.pixelRatio,
@@ -27169,6 +28318,7 @@ function useDocxPageThumbnails(editor, options = {}) {
       const resolution = resolveDocxPageThumbnailResolution({
         sourceWidthPx: sourceSize.widthPx,
         sourceHeightPx: sourceSize.heightPx,
+        resolution: options.resolution,
         maxWidthPx: options.maxWidthPx,
         maxHeightPx: options.maxHeightPx,
         pixelRatio: options.pixelRatio
@@ -27182,6 +28332,13 @@ function useDocxPageThumbnails(editor, options = {}) {
         isMounted: Boolean(pageElement && pageElement.isConnected),
         status: state?.status ?? (pageElement ? "idle" : "unavailable"),
         error: state?.error,
+        paint: (canvas) => {
+          if (!canvas || options.disabled) {
+            return false;
+          }
+          void renderPageThumbnailToCanvasRef.current(pageIndex, canvas);
+          return true;
+        },
         canvasRef: canvasRefCallbacksRef.current.get(pageIndex) ?? (() => {
           const nextCanvasRef = (canvas) => {
             if (canvas) {
@@ -27204,6 +28361,11 @@ function useDocxPageThumbnails(editor, options = {}) {
           );
           return nextRenderToCanvas;
         })(),
+        aspectRatio: sourceSize.widthPx / Math.max(1, sourceSize.heightPx),
+        contentWidth: sourceSize.widthPx,
+        contentHeight: sourceSize.heightPx,
+        width: resolution.widthPx,
+        height: resolution.heightPx,
         ...resolution
       };
     });
@@ -27212,19 +28374,36 @@ function useDocxPageThumbnails(editor, options = {}) {
     fallbackLayout.pageHeightPx,
     fallbackLayout.pageWidthPx,
     mountedPageElements,
+    options.disabled,
+    options.resolution,
     options.maxHeightPx,
     options.maxWidthPx,
     options.pixelRatio,
     pageThumbnailStates
   ]);
+  const paintThumbnail = React.useCallback(
+    (pageIndex, canvas) => {
+      if (!canvas || options.disabled) {
+        return false;
+      }
+      const thumbnail = thumbnails[pageIndex];
+      if (!thumbnail) {
+        return false;
+      }
+      return thumbnail.paint(canvas);
+    },
+    [options.disabled, thumbnails]
+  );
   return React.useMemo(
     () => ({
+      paintThumbnail,
       thumbnails,
       rerenderAttachedThumbnails
     }),
-    [rerenderAttachedThumbnails, thumbnails]
+    [paintThumbnail, rerenderAttachedThumbnails, thumbnails]
   );
 }
+var useDocxViewerThumbnails = useDocxPageThumbnails;
 function useDocxDocumentTheme(editor) {
   const setDocumentTheme = React.useCallback(
     (theme) => {
@@ -27740,7 +28919,11 @@ function renderHeaderNode(node, keyPrefix, documentTheme, numberingDefinitions,
     return normalizeColumnWidthsPx(widthsPx, columnCount, tableWidthPx, 1);
   })();
   const rawResolvedTableWidthPx = tableWidthPx ?? rawTableColumnWidthsPx.reduce((sum, widthPx) => sum + widthPx, 0);
-  const maxTableWidthPx = Number.isFinite(maxContentWidthPx) && maxContentWidthPx > 0 ? Math.max(120, maxContentWidthPx - tableIndentPx) : void 0;
+  const collapsedHorizontalBorderBleedPx = resolveCollapsedTableHorizontalOuterBleedPx(node, columnCount);
+  const maxTableWidthPx = Number.isFinite(maxContentWidthPx) && maxContentWidthPx > 0 ? Math.max(
+    120,
+    maxContentWidthPx - tableIndentPx - collapsedHorizontalBorderBleedPx
+  ) : void 0;
   const resolvedTableWidthPx = clampTableWidthPx(
     rawResolvedTableWidthPx,
     maxTableWidthPx
@@ -27853,6 +29036,7 @@ function renderHeaderNode(node, keyPrefix, documentTheme, numberingDefinitions,
             "span",
             {
               contentEditable: false,
+              "data-docx-pagination-ignore": "true",
               style: {
                 position: "absolute",
                 top: -TABLE_HANDLE_SAFEZONE_TOP_PX,
@@ -27870,6 +29054,7 @@ function renderHeaderNode(node, keyPrefix, documentTheme, numberingDefinitions,
             "span",
             {
               contentEditable: false,
+              "data-docx-pagination-ignore": "true",
               style: {
                 position: "absolute",
                 right: -TABLE_HANDLE_SAFEZONE_RIGHT_PX,
@@ -28481,6 +29666,11 @@ function DocxEditorViewer({
     measuredPageContentIdentityKeysByIndex,
     setMeasuredPageContentIdentityKeysByIndex
   ] = React.useState([]);
+  const [hasMeasuredBodyFooterOverlap, setHasMeasuredBodyFooterOverlap] = React.useState(false);
+  const measuredBodyFooterOverlapCandidateRef = React.useRef({
+    signature: void 0,
+    consecutivePasses: 0
+  });
   const [, setRenderableImageSourceRevision] = React.useState(0);
   const [activeEditableParagraphSegment, setActiveEditableParagraphSegment] = React.useState(void 0);
   const wrappedParagraphTextareaRef = React.useRef(
@@ -28490,6 +29680,10 @@ function DocxEditorViewer({
   const wrappedParagraphSelectionDragRef = React.useRef(void 0);
   const wrappedParagraphSurfaceRegistryRef = React.useRef(/* @__PURE__ */ new Map());
   const [isInitialPaginationSettled, setIsInitialPaginationSettled] = React.useState(!deferInitialPaginationPaint);
+  const [
+    initialPaginationBackgroundRefinementUnlocked,
+    setInitialPaginationBackgroundRefinementUnlocked
+  ] = React.useState(!deferInitialPaginationPaint);
   const [postImportPaginationUnlocked, setPostImportPaginationUnlocked] = React.useState(false);
   const [
     initialPaginationReservedLayoutState,
@@ -28531,6 +29725,11 @@ function DocxEditorViewer({
   React.useEffect(() => {
     setMeasuredPageContentHeightByIndex([]);
     setMeasuredPageContentIdentityKeysByIndex([]);
+    setHasMeasuredBodyFooterOverlap(false);
+    measuredBodyFooterOverlapCandidateRef.current = {
+      signature: void 0,
+      consecutivePasses: 0
+    };
     setTableMeasuredRowHeights({});
     setTableRowHeights({});
     setTableColumnWidths({});
@@ -28574,6 +29773,9 @@ function DocxEditorViewer({
     }
     initialPaginationRevealFrameRef.current = null;
     setIsInitialPaginationSettled(!deferInitialPaginationPaint);
+    setInitialPaginationBackgroundRefinementUnlocked(
+      !deferInitialPaginationPaint
+    );
   }, [deferInitialPaginationPaint, editor.documentLoadNonce]);
   const [activeRowResize, setActiveRowResize] = React.useState();
   const [activeEmbeddedRowResize, setActiveEmbeddedRowResize] = React.useState();
@@ -28862,6 +30064,28 @@ function DocxEditorViewer({
     }
     return widthByNodeIndex;
   }, [editor.model.nodes, paginationSectionMetrics]);
+  const pageContentHeightPxByNodeIndex = React.useMemo(() => {
+    const heightByNodeIndex = /* @__PURE__ */ new Map();
+    if (editor.model.nodes.length === 0 || paginationSectionMetrics.length === 0) {
+      return heightByNodeIndex;
+    }
+    let currentMetricsIndex = 0;
+    for (let nodeIndex = 0; nodeIndex < editor.model.nodes.length; nodeIndex += 1) {
+      currentMetricsIndex = resolvePaginationSectionMetricsIndexForNodeIndex(
+        paginationSectionMetrics,
+        nodeIndex,
+        currentMetricsIndex
+      );
+      const pageContentHeightPx = paginationSectionMetrics[currentMetricsIndex]?.pageContentHeightPx;
+      if (Number.isFinite(pageContentHeightPx) && pageContentHeightPx > 0) {
+        heightByNodeIndex.set(
+          nodeIndex,
+          Math.round(pageContentHeightPx)
+        );
+      }
+    }
+    return heightByNodeIndex;
+  }, [editor.model.nodes, paginationSectionMetrics]);
   const sectionColumnsBySectionIndex = React.useMemo(
     () => documentSections.map(
       (section) => parseSectionColumns(section.sectionPropertiesXml)
@@ -28911,6 +30135,7 @@ function DocxEditorViewer({
         activeDraftKeys,
         numberingDefinitions: editor.model.metadata.numberingDefinitions,
         pageContentWidthPxByNodeIndex,
+        pageContentHeightPxByNodeIndex,
         docGridLinePitchPxByNodeIndex
       }
     );
@@ -28920,6 +30145,7 @@ function DocxEditorViewer({
     editor.canUndo,
     editor.model.metadata.numberingDefinitions,
     editor.model.nodes,
+    pageContentHeightPxByNodeIndex,
     pageContentWidthPxByNodeIndex,
     disableMeasuredImportPagination,
     tableDraftLayoutEpoch,
@@ -28977,17 +30203,43 @@ function DocxEditorViewer({
       (count, node) => count + (node.type === "paragraph" && paragraphHasLastRenderedPageBreak(node) ? 1 : 0),
       0
     ) : void 0;
+    const hasMultiColumnRenderedPageBreakHints = editor.model.nodes.some(
+      (node, nodeIndex) => {
+        if (node.type !== "paragraph" || !paragraphStartsWithLastRenderedPageBreak(node)) {
+          return false;
+        }
+        const metricsIndex = resolvePaginationSectionMetricsIndexForNodeIndex(
+          paginationSectionMetrics,
+          nodeIndex,
+          0
+        );
+        return (paginationSectionMetrics[metricsIndex]?.pageContentHeightMultiplier ?? 1) > 1;
+      }
+    );
     const minimumPageCount = Math.max(1, hardBreakCount + 1);
     const targetPageCount = Number.isFinite(storedDocumentPageCount2) && storedDocumentPageCount2 > 0 ? Math.max(
       minimumPageCount,
       Math.round(storedDocumentPageCount2)
     ) : void 0;
+    let estimatedPages = buildEstimatedPages(
+      tableMeasuredRowHeightsForPagination
+    );
+    let estimatedPagesUseMeasuredPageContentHeightsForRender = canUseMeasuredPageContentHeights;
+    let estimatedRenderMeasuredPageContentHeightsPxByPageIndex = canUseMeasuredPageContentHeights ? measuredPageContentHeightByIndex : void 0;
+    let estimatedRenderPageContentHeightScale = void 0;
+    const deferExpensiveInitialPaginationReconciliation = deferInitialPaginationPaint && !initialPaginationBackgroundRefinementUnlocked;
+    if (deferExpensiveInitialPaginationReconciliation) {
+      return {
+        pages: estimatedPages,
+        useMeasuredPageContentHeightsForRender: estimatedPagesUseMeasuredPageContentHeightsForRender,
+        renderMeasuredPageContentHeightsPxByPageIndex: estimatedRenderMeasuredPageContentHeightsPxByPageIndex,
+        renderPageContentHeightScale: estimatedRenderPageContentHeightScale
+      };
+    }
     const pureEstimatedPages = buildEstimatedPages(
       tableMeasuredRowHeightsForPagination,
       null
     );
-    let estimatedPages = buildEstimatedPages(tableMeasuredRowHeightsForPagination);
-    let estimatedPagesUseMeasuredPageContentHeightsForRender = canUseMeasuredPageContentHeights;
     if (measuredPageContentHeightByIndex && measuredPageContentHeightByIndex.length > 0) {
       const measuredPagesAreOnlySplitParagraphs = estimatedPages.length > 0 && estimatedPages.every(
         (pageSegments) => documentPageContainsOnlySplitParagraphSegments(pageSegments)
@@ -28998,21 +30250,29 @@ function DocxEditorViewer({
       if (measuredPagesAreOnlySplitParagraphs && purePagesAreOnlySplitParagraphs && pureEstimatedPages.length < estimatedPages.length) {
         estimatedPages = pureEstimatedPages;
         estimatedPagesUseMeasuredPageContentHeightsForRender = false;
+        estimatedRenderMeasuredPageContentHeightsPxByPageIndex = void 0;
+        estimatedRenderPageContentHeightScale = void 0;
       }
     }
-    if (!editor.canUndo && !editor.canRedo && targetPageCount !== void 0 && tableMeasuredRowHeightsForPagination) {
+    if (!editor.canUndo && !editor.canRedo && targetPageCount !== void 0 && tableMeasuredRowHeightsForPagination && !hasMultiColumnRenderedPageBreakHints) {
       const candidatePages = [
         {
           pages: estimatedPages,
-          useMeasuredPageContentHeightsForRender: estimatedPagesUseMeasuredPageContentHeightsForRender
+          useMeasuredPageContentHeightsForRender: estimatedPagesUseMeasuredPageContentHeightsForRender,
+          renderMeasuredPageContentHeightsPxByPageIndex: estimatedRenderMeasuredPageContentHeightsPxByPageIndex,
+          renderPageContentHeightScale: estimatedRenderPageContentHeightScale
         },
         {
           pages: buildEstimatedPages(void 0),
-          useMeasuredPageContentHeightsForRender: canUseMeasuredPageContentHeights
+          useMeasuredPageContentHeightsForRender: canUseMeasuredPageContentHeights,
+          renderMeasuredPageContentHeightsPxByPageIndex: canUseMeasuredPageContentHeights ? measuredPageContentHeightByIndex : void 0,
+          renderPageContentHeightScale: void 0
         },
         {
           pages: buildEstimatedPages(void 0, null),
-          useMeasuredPageContentHeightsForRender: false
+          useMeasuredPageContentHeightsForRender: false,
+          renderMeasuredPageContentHeightsPxByPageIndex: void 0,
+          renderPageContentHeightScale: void 0
         }
       ];
       const bestCandidate = candidatePages.reduce((best, candidate) => {
@@ -29024,11 +30284,15 @@ function DocxEditorViewer({
       });
       estimatedPages = bestCandidate.pages;
       estimatedPagesUseMeasuredPageContentHeightsForRender = bestCandidate.useMeasuredPageContentHeightsForRender;
-    } else if (!editor.canUndo && !editor.canRedo && targetPageCount !== void 0) {
+      estimatedRenderMeasuredPageContentHeightsPxByPageIndex = bestCandidate.renderMeasuredPageContentHeightsPxByPageIndex;
+      estimatedRenderPageContentHeightScale = bestCandidate.renderPageContentHeightScale;
+    } else if (!editor.canUndo && !editor.canRedo && targetPageCount !== void 0 && !hasMultiColumnRenderedPageBreakHints) {
       const pureEstimatedPages2 = buildEstimatedPages(void 0, null);
       if (Math.abs(pureEstimatedPages2.length - targetPageCount) < Math.abs(estimatedPages.length - targetPageCount)) {
         estimatedPages = pureEstimatedPages2;
         estimatedPagesUseMeasuredPageContentHeightsForRender = false;
+        estimatedRenderMeasuredPageContentHeightsPxByPageIndex = void 0;
+        estimatedRenderPageContentHeightScale = void 0;
       }
     }
     const measuredPageHeightOverridesReduceContent = !editor.canUndo && !editor.canRedo && !floatingMovePreview && !dropCapMovePreview && estimatedPages.some((segments, pageIndex) => {
@@ -29055,7 +30319,9 @@ function DocxEditorViewer({
     if (!Number.isFinite(storedDocumentPageCount2) || storedDocumentPageCount2 <= 0) {
       return {
         pages: estimatedPages,
-        useMeasuredPageContentHeightsForRender: estimatedPagesUseMeasuredPageContentHeightsForRender
+        useMeasuredPageContentHeightsForRender: estimatedPagesUseMeasuredPageContentHeightsForRender,
+        renderMeasuredPageContentHeightsPxByPageIndex: estimatedRenderMeasuredPageContentHeightsPxByPageIndex,
+        renderPageContentHeightScale: estimatedRenderPageContentHeightScale
       };
     }
     const resolvedTargetPageCount = targetPageCount ?? minimumPageCount;
@@ -29065,22 +30331,26 @@ function DocxEditorViewer({
       )
     );
     const allowMeasuredReductionOverPaginationReconciliation = measuredPageHeightOverridesReduceContent && estimatedPages.length > resolvedTargetPageCount;
-    const allowStoredPageCountReconciliation = !editor.canUndo && !editor.canRedo && !hasPageAnchoredFloatingFooterContent && shouldAllowStoredPageCountReduction({
+    const allowStoredPageCountReconciliation = !editor.canUndo && !editor.canRedo && !hasPageAnchoredFloatingFooterContent && !hasMultiColumnRenderedPageBreakHints && shouldAllowStoredPageCountReduction({
       estimatedPageCount: estimatedPages.length,
       targetPageCount: resolvedTargetPageCount,
       hasLastRenderedPageBreakHints,
-      renderedBreakHintPageCount
+      renderedBreakHintPageCount,
+      hasMeasuredBodyFooterOverlap
     }) && (!measuredPageHeightOverridesReduceContent || allowMeasuredReductionOverPaginationReconciliation);
     if (!allowStoredPageCountReconciliation) {
       return {
         pages: estimatedPages,
-        useMeasuredPageContentHeightsForRender: estimatedPagesUseMeasuredPageContentHeightsForRender
+        useMeasuredPageContentHeightsForRender: estimatedPagesUseMeasuredPageContentHeightsForRender,
+        renderMeasuredPageContentHeightsPxByPageIndex: estimatedRenderMeasuredPageContentHeightsPxByPageIndex,
+        renderPageContentHeightScale: estimatedRenderPageContentHeightScale
       };
     }
     if (estimatedPages.length === resolvedTargetPageCount) {
       return {
         pages: estimatedPages,
-        useMeasuredPageContentHeightsForRender: estimatedPagesUseMeasuredPageContentHeightsForRender
+        useMeasuredPageContentHeightsForRender: estimatedPagesUseMeasuredPageContentHeightsForRender,
+        renderMeasuredPageContentHeightsPxByPageIndex: estimatedRenderMeasuredPageContentHeightsPxByPageIndex
       };
     }
     const reconciliationScales = allowMeasuredReductionOverPaginationReconciliation ? [
@@ -29100,7 +30370,7 @@ function DocxEditorViewer({
       1.28,
       1.3
     ] : void 0;
-    const reconcileCandidatePages = (initialPages, measuredTableRowHeightsByNodeIndex, measuredPageContentHeightsOverride) => reconcilePagesToTargetCountByScalingHeight({
+    const reconcileCandidatePages = (initialPages, measuredTableRowHeightsByNodeIndex, measuredPageContentHeightsOverride) => reconcilePageCountCandidateToTargetCountByScalingHeight({
       initialPages,
       targetPageCount: resolvedTargetPageCount,
       maxDifference: hasTableInternalPageBreaks ? 2 : 3,
@@ -29126,27 +30396,38 @@ function DocxEditorViewer({
         }
       )
     });
-    let reconciledPages = reconcileCandidatePages(
+    let reconciledCandidate = reconcileCandidatePages(
       estimatedPages,
       tableMeasuredRowHeightsForPagination,
       estimatedPagesUseMeasuredPageContentHeightsForRender ? measuredPageContentHeightByIndex : null
     );
+    let reconciledPages = reconciledCandidate.pages;
     let reconciledPagesUseMeasuredPageContentHeightsForRender = estimatedPagesUseMeasuredPageContentHeightsForRender;
+    let reconciledRenderMeasuredPageContentHeightsPxByPageIndex = reconciledPagesUseMeasuredPageContentHeightsForRender ? scaleMeasuredPageContentHeights(
+      measuredPageContentHeightByIndex,
+      reconciledCandidate.scale
+    ) : void 0;
+    let reconciledRenderPageContentHeightScale = reconciledPagesUseMeasuredPageContentHeightsForRender ? void 0 : reconciledCandidate.scale;
     if (!editor.canUndo && !editor.canRedo) {
       const pureEstimatedPages2 = buildEstimatedPages(void 0, null);
-      const pureReconciledPages = reconcileCandidatePages(
+      const pureReconciledCandidate = reconcileCandidatePages(
         pureEstimatedPages2,
         void 0,
         null
       );
+      const pureReconciledPages = pureReconciledCandidate.pages;
       if (Math.abs(pureReconciledPages.length - resolvedTargetPageCount) < Math.abs(reconciledPages.length - resolvedTargetPageCount)) {
         reconciledPages = pureReconciledPages;
         reconciledPagesUseMeasuredPageContentHeightsForRender = false;
+        reconciledRenderMeasuredPageContentHeightsPxByPageIndex = void 0;
+        reconciledRenderPageContentHeightScale = pureReconciledCandidate.scale;
       }
     }
     return {
       pages: reconciledPages,
-      useMeasuredPageContentHeightsForRender: reconciledPagesUseMeasuredPageContentHeightsForRender
+      useMeasuredPageContentHeightsForRender: reconciledPagesUseMeasuredPageContentHeightsForRender,
+      renderMeasuredPageContentHeightsPxByPageIndex: reconciledRenderMeasuredPageContentHeightsPxByPageIndex,
+      renderPageContentHeightScale: reconciledRenderPageContentHeightScale
     };
   }, [
     editor.canRedo,
@@ -29165,12 +30446,17 @@ function DocxEditorViewer({
     isReadOnly,
     floatingMovePreview,
     dropCapMovePreview,
+    deferInitialPaginationPaint,
     disableMeasuredImportPagination,
+    hasMeasuredBodyFooterOverlap,
+    initialPaginationBackgroundRefinementUnlocked,
     measuredPageContentHeightByIndex,
     tableMeasuredRowHeightsForPagination
   ]);
   const pageNodeSegmentsByPage = pageSegmentationPlan.pages;
   const useMeasuredPageContentHeightsForRender = pageSegmentationPlan.useMeasuredPageContentHeightsForRender;
+  const renderMeasuredPageContentHeightsPxByPageIndex = pageSegmentationPlan.renderMeasuredPageContentHeightsPxByPageIndex;
+  const renderPageContentHeightScale = pageSegmentationPlan.renderPageContentHeightScale;
   const pageNodeSegmentIdentityKeysByPage = React.useMemo(
     () => pageNodeSegmentsByPage.map(
       (pageSegments) => documentPageNodeSegmentsIdentityKey(pageSegments)
@@ -29386,6 +30672,32 @@ function DocxEditorViewer({
     };
   }, [editor.model.nodes, pageNodeSegmentsByPage]);
   const pageCount = pageNodeSegmentsByPage.length;
+  const hasLargeTableLayoutSurface = React.useMemo(() => {
+    let tableParagraphCount = 0;
+    let tableCellCount = 0;
+    let largestRowParagraphCount = 0;
+    for (const node of editor.model.nodes) {
+      if (node.type !== "table") {
+        continue;
+      }
+      for (const row of node.rows) {
+        let rowParagraphCount = 0;
+        tableCellCount += row.cells.length;
+        for (const cell of row.cells) {
+          const paragraphCount = tableCellParagraphsRecursively(
+            cell.nodes
+          ).length;
+          tableParagraphCount += paragraphCount;
+          rowParagraphCount += paragraphCount;
+        }
+        largestRowParagraphCount = Math.max(
+          largestRowParagraphCount,
+          rowParagraphCount
+        );
+      }
+    }
+    return tableParagraphCount >= 1e3 || tableCellCount >= 240 || largestRowParagraphCount >= 100;
+  }, [editor.model.nodes]);
   const hideDocumentUntilPaginationSettled = deferInitialPaginationPaint && !isInitialPaginationSettled;
   const estimateDocumentStackHeightPx = React.useCallback(
     (count) => {
@@ -29457,28 +30769,34 @@ function DocxEditorViewer({
   const hasExternalVisiblePageRange = Number.isFinite(Number(visiblePageRange?.startPageIndex)) || Number.isFinite(Number(visiblePageRange?.endPageIndex));
   const [deferInternalPageVirtualization, setDeferInternalPageVirtualization] = React.useState(false);
   const [internalVirtualScrollElement, setInternalVirtualScrollElement] = React.useState(null);
+  const [observedVisiblePageRange, setObservedVisiblePageRange] = React.useState(void 0);
   const pageVirtualizationSettleDelayMs = Math.max(
     0,
     Math.round(
       Number.isFinite(pageVirtualization?.settleDelayMs) ? pageVirtualization?.settleDelayMs : DEFAULT_PAGE_VIRTUALIZATION_SETTLE_DELAY_MS
     )
   );
-  const pageVirtualizationOverscan = Math.max(
+  const rawPageVirtualizationOverscan = Math.max(
     0,
     Math.round(
       Number.isFinite(pageVirtualization?.overscan) ? pageVirtualization?.overscan : DEFAULT_PAGE_VIRTUALIZATION_OVERSCAN
     )
   );
+  const pageVirtualizationOverscan = hasLargeTableLayoutSurface && !Number.isFinite(pageVirtualization?.overscan) ? 0 : rawPageVirtualizationOverscan;
   const webdriverActive = typeof navigator !== "undefined" && navigator.webdriver === true;
   const internalPageVirtualizationRequested = pageVirtualization?.enabled !== false && !hasExternalVisiblePageRange && !hideDocumentUntilPaginationSettled && isInitialPaginationSettled && !deferInternalPageVirtualization && !webdriverActive && pageCount > 1;
   React.useEffect(() => {
-    setDeferInternalPageVirtualization(true);
-  }, [editor.documentLoadNonce]);
+    setDeferInternalPageVirtualization(!hasLargeTableLayoutSurface);
+  }, [editor.documentLoadNonce, hasLargeTableLayoutSurface]);
   React.useEffect(() => {
     if (typeof window === "undefined" || webdriverActive || pageCount <= 1) {
       setDeferInternalPageVirtualization(true);
       return;
     }
+    if (hasLargeTableLayoutSurface) {
+      setDeferInternalPageVirtualization(false);
+      return;
+    }
     const timeoutId = window.setTimeout(() => {
       setDeferInternalPageVirtualization(false);
     }, pageVirtualizationSettleDelayMs);
@@ -29487,6 +30805,7 @@ function DocxEditorViewer({
     };
   }, [
     editor.documentLoadNonce,
+    hasLargeTableLayoutSurface,
     pageCount,
     pageVirtualizationSettleDelayMs,
     webdriverActive
@@ -29500,15 +30819,30 @@ function DocxEditorViewer({
     );
   }, [editor.documentLoadNonce, pageCount, trackedChangesEnabled]);
   const internalPageVirtualizationEnabled = internalPageVirtualizationRequested && internalVirtualScrollElement !== null;
-  const internalPageVirtualizer = (0, import_react_virtual.useVirtualizer)({
-    count: Math.max(1, pageCount),
-    getScrollElement: () => internalPageVirtualizationEnabled ? internalVirtualScrollElement : null,
-    estimateSize: (pageIndex) => {
+  const internalPageVirtualizationPending = typeof window !== "undefined" && internalPageVirtualizationRequested && internalVirtualScrollElement === null;
+  const internalVirtualScrollUsesWindow = typeof document !== "undefined" && internalVirtualScrollElement !== null && (internalVirtualScrollElement === document.scrollingElement || internalVirtualScrollElement === document.documentElement || internalVirtualScrollElement === document.body);
+  const internalElementPageVirtualizationEnabled = internalPageVirtualizationEnabled && !internalVirtualScrollUsesWindow;
+  const internalWindowPageVirtualizationEnabled = internalPageVirtualizationEnabled && internalVirtualScrollUsesWindow;
+  const estimateVirtualPageSize = React.useCallback(
+    (pageIndex) => {
       const pageLayout = pageSectionInfoByIndex[pageIndex]?.layout ?? documentLayout;
       return Math.max(1, pageLayout.pageHeightPx + DOC_PAGE_BREAK_GAP);
     },
+    [documentLayout, pageSectionInfoByIndex]
+  );
+  const internalElementPageVirtualizer = (0, import_react_virtual.useVirtualizer)({
+    count: Math.max(1, pageCount),
+    getScrollElement: () => internalElementPageVirtualizationEnabled ? internalVirtualScrollElement : null,
+    estimateSize: estimateVirtualPageSize,
+    overscan: pageVirtualizationOverscan
+  });
+  const internalWindowPageVirtualizer = (0, import_react_virtual.useWindowVirtualizer)({
+    count: Math.max(1, pageCount),
+    getScrollElement: () => internalWindowPageVirtualizationEnabled && typeof window !== "undefined" ? window : null,
+    estimateSize: estimateVirtualPageSize,
     overscan: pageVirtualizationOverscan
   });
+  const internalPageVirtualizer = internalVirtualScrollUsesWindow ? internalWindowPageVirtualizer : internalElementPageVirtualizer;
   const internalVirtualItems = internalPageVirtualizer.getVirtualItems();
   const internalVisiblePageRange = React.useMemo(() => {
     if (!internalPageVirtualizationEnabled) {
@@ -29543,7 +30877,134 @@ function DocxEditorViewer({
       endPageIndex
     };
   }, [internalPageVirtualizationEnabled, internalVirtualItems, pageCount]);
-  const effectiveVisiblePageRange = visiblePageRange ?? internalVisiblePageRange;
+  React.useLayoutEffect(() => {
+    if (!internalPageVirtualizationEnabled || !internalVirtualScrollElement || typeof window === "undefined") {
+      setObservedVisiblePageRange(
+        (current) => current === void 0 ? current : void 0
+      );
+      return;
+    }
+    const rootElement = viewerRootRef.current;
+    if (!rootElement) {
+      setObservedVisiblePageRange(
+        (current) => current === void 0 ? current : void 0
+      );
+      return;
+    }
+    let frameId = null;
+    const syncVisiblePageRange = () => {
+      frameId = null;
+      const viewportRect = internalVirtualScrollUsesWindow ? {
+        top: 0,
+        bottom: window.innerHeight
+      } : internalVirtualScrollElement.getBoundingClientRect();
+      const pageWrappers = rootElement.querySelectorAll(
+        '[data-docx-page-wrapper="true"][data-index]'
+      );
+      let firstVisiblePageIndex;
+      let lastVisiblePageIndex;
+      for (const pageWrapper of pageWrappers) {
+        const rawPageIndex = pageWrapper.getAttribute("data-index");
+        const pageIndex = Number.parseInt(rawPageIndex ?? "", 10);
+        if (!Number.isFinite(pageIndex)) {
+          continue;
+        }
+        const pageRect = pageWrapper.getBoundingClientRect();
+        if (pageRect.bottom <= viewportRect.top) {
+          continue;
+        }
+        if (pageRect.top >= viewportRect.bottom) {
+          if (firstVisiblePageIndex !== void 0) {
+            break;
+          }
+          continue;
+        }
+        if (firstVisiblePageIndex === void 0) {
+          firstVisiblePageIndex = pageIndex;
+        }
+        lastVisiblePageIndex = pageIndex;
+      }
+      if (firstVisiblePageIndex === void 0 || lastVisiblePageIndex === void 0) {
+        setObservedVisiblePageRange(
+          (current) => current === void 0 ? current : void 0
+        );
+        return;
+      }
+      const startPageIndex = clampNumber(
+        firstVisiblePageIndex - pageVirtualizationOverscan,
+        0,
+        pageCount - 1
+      );
+      const endPageIndex = clampNumber(
+        lastVisiblePageIndex + pageVirtualizationOverscan,
+        startPageIndex,
+        pageCount - 1
+      );
+      setObservedVisiblePageRange((current) => {
+        if (current?.startPageIndex === startPageIndex && current?.endPageIndex === endPageIndex) {
+          return current;
+        }
+        return {
+          startPageIndex,
+          endPageIndex
+        };
+      });
+    };
+    const scheduleVisiblePageRangeSync = () => {
+      if (frameId !== null) {
+        return;
+      }
+      frameId = window.requestAnimationFrame(syncVisiblePageRange);
+    };
+    const resizeObserver = typeof ResizeObserver === "function" ? new ResizeObserver(() => {
+      scheduleVisiblePageRangeSync();
+    }) : void 0;
+    if (!internalVirtualScrollUsesWindow) {
+      resizeObserver?.observe(internalVirtualScrollElement);
+    }
+    resizeObserver?.observe(rootElement);
+    if (internalVirtualScrollUsesWindow) {
+      window.addEventListener("scroll", scheduleVisiblePageRangeSync, {
+        passive: true
+      });
+    } else {
+      internalVirtualScrollElement.addEventListener(
+        "scroll",
+        scheduleVisiblePageRangeSync,
+        { passive: true }
+      );
+    }
+    window.addEventListener("resize", scheduleVisiblePageRangeSync);
+    scheduleVisiblePageRangeSync();
+    return () => {
+      if (internalVirtualScrollUsesWindow) {
+        window.removeEventListener("scroll", scheduleVisiblePageRangeSync);
+      } else {
+        internalVirtualScrollElement.removeEventListener(
+          "scroll",
+          scheduleVisiblePageRangeSync
+        );
+      }
+      window.removeEventListener("resize", scheduleVisiblePageRangeSync);
+      resizeObserver?.disconnect();
+      if (frameId !== null) {
+        window.cancelAnimationFrame(frameId);
+      }
+    };
+  }, [
+    internalPageVirtualizationEnabled,
+    internalVirtualScrollElement,
+    internalVirtualScrollUsesWindow,
+    pageCount,
+    pageVirtualizationOverscan
+  ]);
+  const effectiveVisiblePageRange = visiblePageRange ?? observedVisiblePageRange ?? internalVisiblePageRange ?? (internalPageVirtualizationPending ? {
+    startPageIndex: 0,
+    endPageIndex: Math.min(
+      pageCount - 1,
+      Math.max(0, pageVirtualizationOverscan)
+    )
+  } : void 0);
   const normalizedVisiblePageRange = React.useMemo(() => {
     if (pageCount <= 0) {
       return {
@@ -29571,7 +31032,8 @@ function DocxEditorViewer({
     pageCount
   ]);
   const initialPremeasureStartPageIndex = hasExternalVisiblePageRange ? normalizedVisiblePageRange.startPageIndex : 0;
-  const initialPremeasureEndPageIndex = hasExternalVisiblePageRange ? normalizedVisiblePageRange.endPageIndex : Math.min(pageCount - 1, INITIAL_PAGINATION_PREMEASURE_PAGE_LIMIT - 1);
+  const initialPremeasurePageLimit = hasLargeTableLayoutSurface ? Math.min(2, INITIAL_PAGINATION_PREMEASURE_PAGE_LIMIT) : INITIAL_PAGINATION_PREMEASURE_PAGE_LIMIT;
+  const initialPremeasureEndPageIndex = hasExternalVisiblePageRange ? normalizedVisiblePageRange.endPageIndex : Math.min(pageCount - 1, initialPremeasurePageLimit - 1);
   const measureAllPagesBeforeInitialReveal = hideDocumentUntilPaginationSettled && pageCount > 0 && initialPremeasureStartPageIndex === 0 && initialPremeasureEndPageIndex >= pageCount - 1;
   const visiblePageStartIndex = measureAllPagesBeforeInitialReveal ? 0 : hideDocumentUntilPaginationSettled ? initialPremeasureStartPageIndex : normalizedVisiblePageRange.startPageIndex;
   const visiblePageEndIndex = measureAllPagesBeforeInitialReveal ? pageCount - 1 : hideDocumentUntilPaginationSettled ? initialPremeasureEndPageIndex : normalizedVisiblePageRange.endPageIndex;
@@ -29585,20 +31047,64 @@ function DocxEditorViewer({
     }
     return indexes;
   }, [pageCount, visiblePageEndIndex, visiblePageStartIndex]);
+  const visibleTableRowIndexesByNodeIndex = React.useMemo(() => {
+    const rowsByNodeIndex = /* @__PURE__ */ new Map();
+    const addRowIndex = (nodeIndex, rowIndex) => {
+      const tableNode = editor.model.nodes[nodeIndex];
+      if (!tableNode || tableNode.type !== "table" || rowIndex < 0 || rowIndex >= tableNode.rows.length) {
+        return;
+      }
+      const existing = rowsByNodeIndex.get(nodeIndex);
+      if (existing) {
+        existing.add(rowIndex);
+      } else {
+        rowsByNodeIndex.set(nodeIndex, /* @__PURE__ */ new Set([rowIndex]));
+      }
+    };
+    for (const pageIndex of visiblePageIndexes) {
+      for (const segment of pageNodeSegmentsByPage[pageIndex] ?? []) {
+        const tableNode = editor.model.nodes[segment.nodeIndex];
+        if (!tableNode || tableNode.type !== "table") {
+          continue;
+        }
+        if (segment.tableRowSlice) {
+          addRowIndex(segment.nodeIndex, segment.tableRowSlice.rowIndex);
+          continue;
+        }
+        if (segment.tableRowRange) {
+          for (let rowIndex = segment.tableRowRange.startRowIndex; rowIndex < segment.tableRowRange.endRowIndex; rowIndex += 1) {
+            addRowIndex(segment.nodeIndex, rowIndex);
+          }
+          continue;
+        }
+        for (let rowIndex = 0; rowIndex < tableNode.rows.length; rowIndex += 1) {
+          addRowIndex(segment.nodeIndex, rowIndex);
+        }
+      }
+    }
+    return rowsByNodeIndex;
+  }, [editor.model.nodes, pageNodeSegmentsByPage, visiblePageIndexes]);
   const paginationMeasurementEnabled = hideDocumentUntilPaginationSettled || postImportPaginationUnlocked;
   const visiblePagesHavePendingPaginationMeasurements = React.useMemo(() => {
     if (pageCount === 0) {
       return false;
     }
     for (const pageIndex of visiblePageIndexes) {
-      if (!Number.isFinite(measuredPageContentHeightByIndex[pageIndex])) {
+      const pageSegments = pageNodeSegmentsByPage[pageIndex] ?? [];
+      const pageContainsTableRowSlice = pageSegments.some(
+        (segment) => Boolean(segment.tableRowSlice)
+      );
+      if (!Number.isFinite(measuredPageContentHeightByIndex[pageIndex]) && !(hasLargeTableLayoutSurface && pageContainsTableRowSlice)) {
         return true;
       }
-      for (const segment of pageNodeSegmentsByPage[pageIndex] ?? []) {
+      for (const segment of pageSegments) {
         const tableNode = editor.model.nodes[segment.nodeIndex];
         if (!tableNode || tableNode.type !== "table") {
           continue;
         }
+        if (segment.tableRowSlice) {
+          continue;
+        }
         const measuredHeights = tableMeasuredRowHeights[segment.nodeIndex];
         if (!measuredHeights || measuredHeights.length !== tableNode.rows.length) {
           return true;
@@ -29608,6 +31114,7 @@ function DocxEditorViewer({
     return false;
   }, [
     editor.model.nodes,
+    hasLargeTableLayoutSurface,
     measuredPageContentHeightByIndex,
     pageCount,
     pageNodeSegmentsByPage,
@@ -30244,7 +31751,9 @@ function DocxEditorViewer({
         const footerElement = pageFooterElementsRef.current.get(pageIndex);
         const headerHeightPx = headerElement ? Math.max(
           0,
-          Math.round(headerElement.getBoundingClientRect().height / zoomScale)
+          Math.round(
+            headerElement.getBoundingClientRect().height / zoomScale
+          )
         ) : 0;
         const docxFooterTopPx = resolveFooterNodesFloatingBoundaryTopPx(
           pageHeaderAndFooterNodes[pageIndex]?.footerNodes ?? [],
@@ -30310,7 +31819,9 @@ function DocxEditorViewer({
                 bottomPx: rect.bottom,
                 widthPx: rect.width,
                 heightPx: rect.height,
-                ignore: !element.isConnected || Boolean(element.closest("[data-docx-image-location]")) || Boolean(
+                ignore: !element.isConnected || Boolean(
+                  element.closest("[data-docx-image-location]")
+                ) || Boolean(
                   element.closest(
                     `[${PAGE_CONTENT_MEASUREMENT_IGNORE_ATTRIBUTE}="true"]`
                   )
@@ -30340,7 +31851,31 @@ function DocxEditorViewer({
     const nextMeasuredHeights = nextMeasuredPageDiagnostics.map(
       (diagnostics) => diagnostics.heightPx
     );
+    const overlappingPageIndexes = nextMeasuredPageDiagnostics.reduce(
+      (indexes, diagnostics, pageIndex) => {
+        if (diagnostics.bodyOverrunsFooter) {
+          indexes.push(pageIndex);
+        }
+        return indexes;
+      },
+      []
+    );
+    const nextMeasuredBodyFooterOverlapLatchState = resolveMeasuredBodyFooterOverlapLatchState({
+      pageCount,
+      targetPageCount: editor.model.metadata.documentPageCount,
+      overlappingPageIndexes,
+      previousSignature: measuredBodyFooterOverlapCandidateRef.current.signature,
+      previousConsecutivePasses: measuredBodyFooterOverlapCandidateRef.current.consecutivePasses,
+      stabilityThreshold: MEASURED_BODY_FOOTER_OVERLAP_STABILITY_THRESHOLD
+    });
+    measuredBodyFooterOverlapCandidateRef.current = {
+      signature: nextMeasuredBodyFooterOverlapLatchState.signature,
+      consecutivePasses: nextMeasuredBodyFooterOverlapLatchState.consecutivePasses
+    };
     const frameId = window.requestAnimationFrame(() => {
+      if (nextMeasuredBodyFooterOverlapLatchState.shouldLatch) {
+        setHasMeasuredBodyFooterOverlap(true);
+      }
       setMeasuredPageContentHeightByIndex((current) => {
         const stabilizedHeights = stabilizeMeasuredPageContentHeights(
           current,
@@ -30393,6 +31928,7 @@ function DocxEditorViewer({
     paginationMeasurementEnabled,
     paginationMeasurementEpoch,
     pageCount,
+    editor.model.metadata.documentPageCount,
     pageNodeSegmentsByPage,
     pageNodeSegmentIdentityKeysByPage,
     pageSectionInfoByIndex,
@@ -30425,6 +31961,27 @@ function DocxEditorViewer({
     isInitialPaginationSettled,
     pageCount
   ]);
+  React.useEffect(() => {
+    if (!deferInitialPaginationPaint || !isInitialPaginationSettled || initialPaginationBackgroundRefinementUnlocked) {
+      return;
+    }
+    if (typeof window === "undefined") {
+      setInitialPaginationBackgroundRefinementUnlocked(true);
+      return;
+    }
+    const timeoutId = window.setTimeout(() => {
+      React.startTransition(() => {
+        setInitialPaginationBackgroundRefinementUnlocked(true);
+      });
+    }, INITIAL_PAGINATION_BACKGROUND_REFINEMENT_DELAY_MS);
+    return () => {
+      window.clearTimeout(timeoutId);
+    };
+  }, [
+    deferInitialPaginationPaint,
+    initialPaginationBackgroundRefinementUnlocked,
+    isInitialPaginationSettled
+  ]);
   React.useEffect(() => {
     if (!deferInitialPaginationPaint || isInitialPaginationSettled) {
       return;
@@ -34643,10 +36200,14 @@ function DocxEditorViewer({
       if (node.type !== "table") {
         return;
       }
+      const visibleRowIndexes = visibleTableRowIndexesByNodeIndex.get(nodeIndex);
+      if (!visibleRowIndexes || visibleRowIndexes.size === 0) {
+        return;
+      }
       const measuredByRowIndex = /* @__PURE__ */ new Map();
       const recordMeasuredRow = (rowIndex, rowHeightPx) => {
         const normalizedRowIndex = Math.max(0, Math.round(rowIndex));
-        if (normalizedRowIndex >= node.rows.length) {
+        if (normalizedRowIndex >= node.rows.length || !visibleRowIndexes.has(normalizedRowIndex)) {
           return;
         }
         const normalizedHeight = normalizeMeasuredTableRowHeightPx(rowHeightPx);
@@ -34679,7 +36240,8 @@ function DocxEditorViewer({
           );
         });
       }
-      const rowCells = document.querySelectorAll(
+      const measurementRoot = viewerRootRef.current ?? document;
+      const rowCells = measurementRoot.querySelectorAll(
         `[data-docx-table-cell='true'][data-docx-table-index='${nodeIndex}'][data-docx-row-index]`
       );
       rowCells.forEach((cellElement) => {
@@ -34710,7 +36272,8 @@ function DocxEditorViewer({
         node,
         pageContentWidthPxByNodeIndex.get(nodeIndex),
         editor.model.metadata.numberingDefinitions,
-        docGridLinePitchPxByNodeIndex.get(nodeIndex)
+        docGridLinePitchPxByNodeIndex.get(nodeIndex),
+        pageContentHeightPxByNodeIndex.get(nodeIndex)
       );
       const previousMeasuredRowHeights = tableMeasuredRowHeights[nodeIndex];
       const measuredHeights = node.rows.map((_, rowIndex) => {
@@ -34776,8 +36339,7 @@ function DocxEditorViewer({
     tableColumnWidths,
     tableRowHeights,
     tableDraftLayoutEpoch,
-    visiblePageEndIndex,
-    visiblePageStartIndex
+    visibleTableRowIndexesByNodeIndex
   ]);
   const normalizeResizableHeights = React.useCallback(
     (rowHeights) => {
@@ -36237,6 +37799,29 @@ function DocxEditorViewer({
             `${keyPrefix}-fragment-image-${lineIndex}-${run.key}-${overlapStart}`
           );
         }
+        if (run.kind === "tab" && Number.isFinite(run.tabWidthPx)) {
+          const overlapRatio = run.endOffset > run.startOffset ? (overlapEnd - overlapStart) / (run.endOffset - run.startOffset) : 1;
+          const tabWidthPx = Math.max(
+            1,
+            Math.round(run.tabWidthPx * overlapRatio)
+          );
+          return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+            "span",
+            {
+              "data-docx-tab-char": "true",
+              style: {
+                ...runStyleToCss(run.style, documentContentTheme),
+                display: "inline-block",
+                width: tabWidthPx,
+                minWidth: tabWidthPx,
+                whiteSpace: "pre",
+                lineHeight: "1em"
+              },
+              children: "\xA0"
+            },
+            `${keyPrefix}-fragment-tab-${lineIndex}-${run.key}-${overlapStart}`
+          );
+        }
         const slice = run.text.slice(
           overlapStart - run.startOffset,
           overlapEnd - run.startOffset
@@ -39072,6 +40657,488 @@ function DocxEditorViewer({
     boxSizing: "border-box",
     overflow: floatingMovePreview || dropCapMovePreview ? "visible" : "clip"
   };
+  const tableCellParagraphSliceLayoutCacheRef = React.useRef(
+    /* @__PURE__ */ new Map()
+  );
+  const tableCellParagraphFlowLayoutCacheRef = React.useRef(
+    /* @__PURE__ */ new Map()
+  );
+  const tableCellParagraphSlicePlanCacheRef = React.useRef(
+    /* @__PURE__ */ new Map()
+  );
+  const tableCellParagraphSliceSignatureCacheRef = React.useRef(
+    /* @__PURE__ */ new WeakMap()
+  );
+  React.useEffect(() => {
+    tableCellParagraphSliceLayoutCacheRef.current.clear();
+    tableCellParagraphFlowLayoutCacheRef.current.clear();
+    tableCellParagraphSlicePlanCacheRef.current.clear();
+    tableCellParagraphSliceSignatureCacheRef.current = /* @__PURE__ */ new WeakMap();
+  }, [paragraphStructureEpoch]);
+  const resolveTableCellParagraphSliceSignature = (cell) => {
+    const cellKey = cell;
+    const cached = tableCellParagraphSliceSignatureCacheRef.current.get(cellKey);
+    if (cached) {
+      return cached;
+    }
+    const signature = [
+      JSON.stringify(cell.style ?? null),
+      ...cell.nodes.map(
+        (paragraph, paragraphIndex) => isParagraphCellContentNode(paragraph) ? `${paragraphIndex}:${paragraph.sourceXml ?? paragraphText(paragraph)}` : `${paragraphIndex}:${paragraph.type}`
+      )
+    ].join("");
+    tableCellParagraphSliceSignatureCacheRef.current.set(cellKey, signature);
+    return signature;
+  };
+  const resolveTableCellParagraphSlicePlans = (params) => {
+    const {
+      cell,
+      rowHeightPx,
+      sliceStartPx,
+      sliceHeightPx,
+      cellContentWidthPx,
+      tableCellMarginTwips,
+      applyWordTableDefaults,
+      docGridLinePitchPx
+    } = params;
+    if (!cell.nodes.every(isParagraphCellContentNode)) {
+      return void 0;
+    }
+    const numberingDefinitions = editor.model.metadata.numberingDefinitions;
+    const cellSignature = resolveTableCellParagraphSliceSignature(cell);
+    const flowLayoutCacheKey = [
+      cellContentWidthPx,
+      JSON.stringify(tableCellMarginTwips ?? null),
+      applyWordTableDefaults ? 1 : 0,
+      docGridLinePitchPx ?? 0,
+      cellSignature
+    ].join(":");
+    let flowLayout = tableCellParagraphFlowLayoutCacheRef.current.get(flowLayoutCacheKey);
+    if (!flowLayout) {
+      const contentHeightPx = estimateTableCellContentHeightPx(
+        cell.nodes,
+        cellContentWidthPx,
+        numberingDefinitions,
+        applyWordTableDefaults,
+        docGridLinePitchPx
+      );
+      const paddingPx = resolveTableSpacingPaddingPx(
+        mergeTableSpacing(tableCellMarginTwips, cell.style?.marginTwips)
+      );
+      let paragraphTopPx = paddingPx.top;
+      const entries = [];
+      for (let paragraphIndex = 0; paragraphIndex < cell.nodes.length; paragraphIndex += 1) {
+        const paragraph = cell.nodes[paragraphIndex];
+        if (!paragraph) {
+          continue;
+        }
+        const disableDocGridSnap = paragraphDocGridSnapState(paragraph) === "disable";
+        const layoutCacheKey2 = `${cellContentWidthPx}:${applyWordTableDefaults ? 1 : 0}:${docGridLinePitchPx ?? 0}:${paragraphIndex}:${paragraph.sourceXml ?? paragraphText(paragraph)}`;
+        let layoutEntry = tableCellParagraphSliceLayoutCacheRef.current.get(layoutCacheKey2);
+        if (!layoutEntry) {
+          const paragraphForLayout = wordLikeTableCellParagraph(
+            paragraph,
+            applyWordTableDefaults
+          );
+          const paragraphHeightPx2 = estimateParagraphHeightPx(
+            paragraphForLayout,
+            cellContentWidthPx,
+            numberingDefinitions,
+            docGridLinePitchPx,
+            disableDocGridSnap
+          );
+          const suppressTopSpacing = paragraphIndex === 0 && suppressFirstTableCellParagraphTopSpacing(paragraph);
+          const beforeSpacingPx = suppressTopSpacing ? 0 : twipsToPixels(paragraphForLayout.style?.spacing?.beforeTwips) ?? 0;
+          const topBorderInsetPx = paragraphBorderInsetPx(
+            paragraphForLayout.style?.borders?.top
+          );
+          const lineHeightPx = Math.max(
+            MIN_PARAGRAPH_LINE_HEIGHT_PX,
+            estimateParagraphLineHeightPx(
+              paragraphForLayout,
+              docGridLinePitchPx,
+              disableDocGridSnap
+            )
+          );
+          const pretextSource = buildParagraphPretextLayoutSource(
+            paragraphForLayout,
+            {
+              allowExplicitLineBreakText: true,
+              expandTabsForLayout: true
+            }
+          );
+          const paragraphTextWidthPx = paragraphAvailableTextWidthPx(
+            paragraphForLayout,
+            cellContentWidthPx,
+            numberingDefinitions
+          );
+          const pretextLayout = pretextSource ? layoutParagraphPretextSource(
+            paragraphForLayout,
+            pretextSource,
+            paragraphTextWidthPx,
+            lineHeightPx,
+            []
+          ) : void 0;
+          const totalLineCount = Math.max(
+            1,
+            pretextLayout?.lineCount ?? paragraphLineCountWithinWidth(
+              paragraphForLayout,
+              cellContentWidthPx,
+              numberingDefinitions
+            )
+          );
+          layoutEntry = {
+            paragraphForLayout,
+            paragraphHeightPx: paragraphHeightPx2,
+            textTopOffsetPx: beforeSpacingPx + topBorderInsetPx,
+            lineHeightPx,
+            lineTopOffsetsPx: pretextLayout ? pretextLayout.lines.map(
+              (line) => Math.max(0, Math.round(line.y))
+            ) : Array.from(
+              { length: totalLineCount },
+              (_, lineIndex) => lineIndex * lineHeightPx
+            ),
+            pretextSource: pretextSource ?? void 0,
+            pretextLayout: pretextLayout ?? void 0
+          };
+          tableCellParagraphSliceLayoutCacheRef.current.set(
+            layoutCacheKey2,
+            layoutEntry
+          );
+        }
+        const paragraphHeightPx = layoutEntry.paragraphHeightPx;
+        const textTopPx = paragraphTopPx + layoutEntry.textTopOffsetPx;
+        const textBottomPx = textTopPx + (layoutEntry.pretextLayout ? wrappedPretextParagraphBlockHeightPx(layoutEntry.pretextLayout) : layoutEntry.lineHeightPx * layoutEntry.lineTopOffsetsPx.length);
+        const paragraphBottomPx = resolveTableCellParagraphVisualBottomPx({
+          paragraphTopPx,
+          paragraphHeightPx,
+          textBottomPx
+        });
+        entries.push({
+          paragraph,
+          paragraphIndex,
+          paragraphTopPx,
+          textTopPx,
+          paragraphBottomPx,
+          layoutEntry
+        });
+        paragraphTopPx = paragraphBottomPx;
+      }
+      flowLayout = {
+        contentHeightPx,
+        paddingPx,
+        entries
+      };
+      tableCellParagraphFlowLayoutCacheRef.current.set(
+        flowLayoutCacheKey,
+        flowLayout
+      );
+    }
+    const availableContentHeightPx = Math.max(
+      0,
+      rowHeightPx - flowLayout.paddingPx.top - flowLayout.paddingPx.bottom
+    );
+    const extraVerticalSpacePx = Math.max(
+      0,
+      availableContentHeightPx - flowLayout.contentHeightPx
+    );
+    const verticalOffsetPx = cell.style?.verticalAlign === "center" ? Math.round(extraVerticalSpacePx / 2) : cell.style?.verticalAlign === "bottom" ? extraVerticalSpacePx : 0;
+    const sliceBottomPx = sliceStartPx + sliceHeightPx;
+    const slicePlanCacheKey = [
+      flowLayoutCacheKey,
+      rowHeightPx,
+      sliceStartPx,
+      sliceHeightPx
+    ].join(":");
+    const cachedPlans = tableCellParagraphSlicePlanCacheRef.current.get(slicePlanCacheKey);
+    if (cachedPlans) {
+      return cachedPlans;
+    }
+    const plans = [];
+    let firstCandidateIndex = 0;
+    let low = 0;
+    let high = flowLayout.entries.length;
+    while (low < high) {
+      const mid = Math.floor((low + high) / 2);
+      const entryBottomPx = (flowLayout.entries[mid]?.paragraphBottomPx ?? 0) + verticalOffsetPx;
+      if (entryBottomPx <= sliceStartPx + PAGE_OVERFLOW_TOLERANCE_PX) {
+        low = mid + 1;
+      } else {
+        high = mid;
+      }
+    }
+    firstCandidateIndex = low;
+    for (let entryIndex = firstCandidateIndex; entryIndex < flowLayout.entries.length; entryIndex += 1) {
+      const entry = flowLayout.entries[entryIndex];
+      if (!entry) {
+        continue;
+      }
+      const paragraphTopPx = entry.paragraphTopPx + verticalOffsetPx;
+      const textTopPx = entry.textTopPx + verticalOffsetPx;
+      const paragraphBottomPx = entry.paragraphBottomPx + verticalOffsetPx;
+      if (paragraphTopPx >= sliceBottomPx - PAGE_OVERFLOW_TOLERANCE_PX) {
+        break;
+      }
+      const intersectsParagraph = sliceBottomPx > paragraphTopPx + PAGE_OVERFLOW_TOLERANCE_PX && sliceStartPx < paragraphBottomPx - PAGE_OVERFLOW_TOLERANCE_PX;
+      if (!intersectsParagraph) {
+        continue;
+      }
+      const fullyVisible = tableCellParagraphFitsFullyWithinSlice({
+        sliceStartPx,
+        sliceBottomPx,
+        paragraphTopPx,
+        paragraphBottomPx
+      });
+      if (fullyVisible) {
+        plans.push({
+          paragraph: entry.paragraph,
+          paragraphIndex: entry.paragraphIndex,
+          topPx: Math.max(0, Math.round(paragraphTopPx - sliceStartPx)),
+          layoutEntry: entry.layoutEntry
+        });
+        continue;
+      }
+      const paragraphLineRange = resolveLineRangeWithinVerticalSlice(
+        entry.layoutEntry.lineTopOffsetsPx,
+        entry.layoutEntry.lineHeightPx,
+        sliceStartPx - textTopPx,
+        sliceBottomPx - textTopPx
+      );
+      if (!paragraphLineRange) {
+        continue;
+      }
+      const lineRangeTopPx = paragraphLineRange.startLineIndex > 0 ? textTopPx + entry.layoutEntry.lineTopOffsetsPx[paragraphLineRange.startLineIndex] : paragraphTopPx;
+      plans.push({
+        paragraph: entry.paragraph,
+        paragraphIndex: entry.paragraphIndex,
+        topPx: Math.max(0, Math.round(lineRangeTopPx - sliceStartPx)),
+        layoutEntry: entry.layoutEntry,
+        paragraphLineRange
+      });
+    }
+    tableCellParagraphSlicePlanCacheRef.current.set(slicePlanCacheKey, plans);
+    return plans;
+  };
+  const renderSlicedTableCellParagraph = (params) => {
+    const {
+      paragraph,
+      paragraphIndex,
+      tableIndex,
+      rowIndex,
+      cellIndex,
+      contentIndex,
+      cellContentWidthPx,
+      applyWordTableDefaults,
+      docGridLinePitchPx,
+      layoutEntry,
+      paragraphLineRange
+    } = params;
+    const numberingDefinitions = editor.model.metadata.numberingDefinitions;
+    const paragraphForLayout = layoutEntry.paragraphForLayout;
+    const hasPartialLineRange = paragraphSegmentHasPartialLineRange(paragraphLineRange);
+    const paragraphSegmentLineHeightPx = Math.max(
+      1,
+      paragraphLineRange?.lineHeightPx ?? layoutEntry.lineHeightPx
+    );
+    const paragraphSegmentStartLine = paragraphLineRange?.startLineIndex ?? 0;
+    const paragraphSegmentEndLine = paragraphLineRange?.endLineIndex ?? paragraphLineRange?.totalLineCount ?? 1;
+    const paragraphSegmentTotalLines = paragraphLineRange?.totalLineCount ?? Math.max(1, paragraphSegmentEndLine);
+    const paragraphSegmentVisibleLineCount = Math.max(
+      1,
+      paragraphSegmentEndLine - paragraphSegmentStartLine
+    );
+    const paragraphSegmentVisibleHeightPx = paragraphSegmentVisibleLineCount * paragraphSegmentLineHeightPx;
+    const paragraphSegmentTranslateYPx = paragraphSegmentStartLine * paragraphSegmentLineHeightPx;
+    const location = {
+      kind: "table-cell",
+      tableIndex,
+      rowIndex,
+      cellIndex,
+      paragraphIndex
+    };
+    const numberingLabel = paragraphNumberingLabels.get(
+      paragraphLocationKey(location)
+    );
+    const paragraphRenderTextWidthPx = paragraphAvailableTextWidthPx(
+      paragraphForLayout,
+      cellContentWidthPx,
+      numberingDefinitions
+    );
+    const pretextParagraphLayout = hasPartialLineRange && layoutEntry.pretextSource ? layoutEntry.pretextLayout && Math.abs(paragraphSegmentLineHeightPx - layoutEntry.lineHeightPx) <= 1 ? layoutEntry.pretextLayout : layoutParagraphPretextSource(
+      paragraphForLayout,
+      layoutEntry.pretextSource,
+      paragraphRenderTextWidthPx,
+      paragraphSegmentLineHeightPx,
+      []
+    ) : void 0;
+    const pretextParagraphTotalLines = Math.max(
+      0,
+      pretextParagraphLayout?.lineCount ?? 0
+    );
+    const pretextParagraphSliceStartLine = hasPartialLineRange && paragraphLineRange && pretextParagraphTotalLines > 0 ? Math.max(
+      0,
+      Math.min(
+        paragraphLineRange.startLineIndex,
+        pretextParagraphTotalLines
+      )
+    ) : void 0;
+    const pretextParagraphSliceEndLine = hasPartialLineRange && paragraphLineRange && pretextParagraphTotalLines > 0 && pretextParagraphSliceStartLine !== void 0 ? Math.max(
+      pretextParagraphSliceStartLine,
+      Math.min(
+        paragraphLineRange.endLineIndex,
+        pretextParagraphTotalLines
+      )
+    ) : void 0;
+    const pretextParagraphSliceLayout = hasPartialLineRange && pretextParagraphLayout && pretextParagraphSliceStartLine !== void 0 && pretextParagraphSliceEndLine !== void 0 && pretextParagraphLayout.lineCount > 0 ? sliceLayoutToLineRange(
+      pretextParagraphLayout,
+      pretextParagraphSliceStartLine,
+      pretextParagraphSliceEndLine
+    ) : void 0;
+    const shouldRenderParagraphSegmentWithPretext = hasPartialLineRange && Boolean(layoutEntry.pretextSource) && Boolean(pretextParagraphLayout) && pretextParagraphTotalLines > 0;
+    const paragraphSegmentClipBleed = shouldRenderParagraphSegmentWithPretext ? resolveParagraphSegmentClipBleedPx(paragraphLineRange) : resolveFallbackParagraphSegmentClipBleedPx(
+      paragraphForLayout,
+      paragraphLineRange
+    );
+    const paragraphSegmentClipBleedTopPx = paragraphSegmentClipBleed.topPx;
+    const paragraphSegmentClipBleedBottomPx = paragraphSegmentClipBleed.bottomPx;
+    const pretextSegmentNumberingMarkerBoxWidthPx = numberingLabel && paragraphSegmentStartLine === 0 ? resolveNumberingMarkerBoxWidthPx(
+      paragraph,
+      numberingDefinitions,
+      numberingLabel
+    ) ?? Math.max(
+      16,
+      Math.ceil(
+        measureTextWidthPx2(
+          numberingLabel.imageSrc ? numberingLabel.trailingText ?? "" : numberingLabel.text ?? "",
+          numberingLabel.style,
+          paragraphBaseFontSizePx(paragraph)
+        )
+      ) + (numberingLabel.imageSrc ? Math.ceil(numberingLabel.imageWidthPx ?? 12) + 2 : 0) + 4
+    ) : void 0;
+    const pretextSegmentNumberingMarkerNode = shouldRenderParagraphSegmentWithPretext && numberingLabel && paragraphSegmentStartLine === 0 && Number.isFinite(pretextSegmentNumberingMarkerBoxWidthPx) ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      "span",
+      {
+        contentEditable: false,
+        "data-docx-numbering-label": "true",
+        style: {
+          ...numberingMarkerStyle(
+            paragraph,
+            numberingDefinitions,
+            numberingLabel,
+            numberingLabel.style ? runStyleToCss(numberingLabel.style, documentContentTheme) : void 0,
+            documentContentTheme
+          ),
+          position: "absolute",
+          left: -Math.round(
+            pretextSegmentNumberingMarkerBoxWidthPx
+          ),
+          top: 0,
+          marginRight: 0,
+          zIndex: 1,
+          pointerEvents: "none"
+        },
+        children: numberingLabel.imageSrc ? /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+            "img",
+            {
+              src: numberingLabel.imageSrc,
+              alt: "",
+              "aria-hidden": "true",
+              draggable: false,
+              style: {
+                display: "inline-block",
+                verticalAlign: "text-bottom",
+                width: numberingLabel.imageWidthPx ?? 12,
+                height: numberingLabel.imageHeightPx ?? 12,
+                marginRight: 2,
+                filter: documentContentFilter
+              }
+            }
+          ),
+          numberingLabel.trailingText ?? ""
+        ] }) : numberingLabel.text ?? ""
+      },
+      `table-cell-${tableIndex}-${rowIndex}-${cellIndex}-${paragraphIndex}-numbering-marker-${paragraphSegmentStartLine}`
+    ) : void 0;
+    const baseParagraphStyle = tableCellParagraphBlockStyle(
+      paragraph,
+      numberingDefinitions,
+      headingStyles,
+      paragraphIndex,
+      applyWordTableDefaults,
+      docGridLinePitchPx
+    );
+    const paragraphStyle = {
+      ...baseParagraphStyle,
+      ...hasPartialLineRange ? {
+        marginTop: paragraphSegmentStartLine === 0 ? baseParagraphStyle.marginTop : 0,
+        marginBottom: paragraphSegmentEndLine >= paragraphSegmentTotalLines ? baseParagraphStyle.marginBottom : 0
+      } : void 0,
+      outline: "none"
+    };
+    const fallbackParagraphRuns = renderInteractiveParagraphRuns(
+      paragraph,
+      `body-cell-${tableIndex}-${rowIndex}-${cellIndex}-${contentIndex}`,
+      location
+    );
+    const renderedInteractiveParagraphContent = shouldRenderParagraphSegmentWithPretext ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      "div",
+      {
+        style: {
+          minHeight: paragraphSegmentVisibleHeightPx + paragraphSegmentClipBleedTopPx + paragraphSegmentClipBleedBottomPx,
+          marginTop: -paragraphSegmentClipBleedTopPx,
+          marginBottom: -paragraphSegmentClipBleedBottomPx,
+          paddingTop: paragraphSegmentClipBleedTopPx,
+          paddingBottom: paragraphSegmentClipBleedBottomPx,
+          overflow: "visible"
+        },
+        children: layoutEntry.pretextSource && pretextParagraphSliceLayout && pretextParagraphSliceLayout.lineCount > 0 ? renderWrappedPretextParagraph({
+          location,
+          keyPrefix: `body-cell-${tableIndex}-${rowIndex}-${cellIndex}-${contentIndex}-lines-${paragraphSegmentStartLine}-${paragraphSegmentEndLine}`,
+          source: layoutEntry.pretextSource,
+          layout: pretextParagraphSliceLayout,
+          lineHeightPx: paragraphSegmentLineHeightPx,
+          baseTextStyle: firstRunStyle(paragraph),
+          blockHeightPx: pretextParagraphSliceLayout.height,
+          obstacleNodes: pretextSegmentNumberingMarkerNode
+        }) : null
+      }
+    ) : hasPartialLineRange ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      "div",
+      {
+        style: {
+          height: paragraphSegmentVisibleHeightPx + paragraphSegmentClipBleedTopPx + paragraphSegmentClipBleedBottomPx,
+          marginTop: -paragraphSegmentClipBleedTopPx,
+          marginBottom: -paragraphSegmentClipBleedBottomPx,
+          overflow: "hidden"
+        },
+        children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          "div",
+          {
+            style: {
+              transform: `translateY(-${paragraphSegmentTranslateYPx - paragraphSegmentClipBleedTopPx}px)`
+            },
+            children: fallbackParagraphRuns
+          }
+        )
+      }
+    ) : fallbackParagraphRuns;
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      "div",
+      {
+        "data-docx-paragraph-host": "true",
+        "data-docx-paragraph-kind": "table-cell",
+        "data-docx-table-index": tableIndex,
+        "data-docx-row-index": rowIndex,
+        "data-docx-cell-index": cellIndex,
+        "data-docx-paragraph-index": paragraphIndex,
+        "data-docx-table-paragraph-index": paragraphIndex,
+        style: paragraphStyle,
+        children: renderedInteractiveParagraphContent
+      },
+      `body-cell-slice-${tableIndex}-${rowIndex}-${cellIndex}-${contentIndex}`
+    );
+  };
   const renderDocumentNode = (node, nodeIndex, tableRowRange, tableRowSlice, paragraphLineRange, options) => {
     const nodeDocGridLinePitchPx = docGridLinePitchPxByNodeIndex.get(nodeIndex);
     const nodeContentWidthPx = Math.max(
@@ -39109,7 +41176,7 @@ function DocxEditorViewer({
         paragraphLineRange
       );
       const paragraphHasActiveEditableSegment = activeEditableParagraphSegment?.nodeIndex === nodeIndex;
-      const shouldTrackParagraphElement = !hasPartialLineRange || paragraphSegmentIsActiveEditable || !paragraphHasActiveEditableSegment && paragraphSegmentStartLine === 0;
+      const shouldTrackParagraphElement = options?.suppressParagraphElementTracking === true ? false : !hasPartialLineRange || paragraphSegmentIsActiveEditable || !paragraphHasActiveEditableSegment && paragraphSegmentStartLine === 0;
       const isManualPageBreakParagraph = paragraphIsOnlyExplicitPageBreak2(node);
       const paragraphContentWidthPx = nodeContentWidthPx;
       const paragraphRenderTextWidthPx = paragraphAvailableTextWidthPx(
@@ -39118,7 +41185,8 @@ function DocxEditorViewer({
         editor.model.metadata.numberingDefinitions
       );
       const pretextParagraphSource = hasPartialLineRange ? buildParagraphPretextLayoutSource(node, {
-        allowExplicitLineBreakText: true
+        allowExplicitLineBreakText: true,
+        expandTabsForLayout: true
       }) : void 0;
       const pretextParagraphLayout = hasPartialLineRange && pretextParagraphSource ? layoutParagraphPretextSource(
         node,
@@ -39213,7 +41281,13 @@ function DocxEditorViewer({
         },
         `node-${nodeIndex}-numbering-marker-${paragraphSegmentStartLine}`
       ) : void 0;
-      const editable = !hasImage && !isReadOnly && (!hasPartialLineRange || paragraphSegmentIsActiveEditable) && !isManualPageBreakParagraph;
+      const resolvedBeforeSpacingPx = Number.isFinite(
+        options?.overrideBeforeSpacingPx
+      ) ? Math.max(0, Math.round(options?.overrideBeforeSpacingPx)) : void 0;
+      const resolvedAfterSpacingPx = Number.isFinite(
+        options?.overrideAfterSpacingPx
+      ) ? Math.max(0, Math.round(options?.overrideAfterSpacingPx)) : void 0;
+      const editable = !hasImage && !isReadOnly && options?.forceReadOnly !== true && (!hasPartialLineRange || paragraphSegmentIsActiveEditable) && !isManualPageBreakParagraph;
       const resolvedPageLayout = options?.pageLayout ?? documentLayout;
       const paragraphContainsLikelyFullPageCoverImage = node.children.some(
         (child) => child.type === "image" && shouldRenderAbsoluteFloatingImage(child) && likelyFullPageCoverImageRelativeToContentBox(
@@ -39283,8 +41357,11 @@ function DocxEditorViewer({
       const paragraphStyle = {
         ...baseParagraphStyle,
         ...hasPartialLineRange ? {
-          marginTop: paragraphSegmentStartLine === 0 ? beforeSpacingPx : 0,
-          marginBottom: paragraphSegmentEndLine >= paragraphSegmentTotalLines ? afterSpacingPx : 0
+          marginTop: paragraphSegmentStartLine === 0 ? resolvedBeforeSpacingPx ?? beforeSpacingPx : 0,
+          marginBottom: paragraphSegmentEndLine >= paragraphSegmentTotalLines ? resolvedAfterSpacingPx ?? afterSpacingPx : 0
+        } : resolvedBeforeSpacingPx !== void 0 || resolvedAfterSpacingPx !== void 0 ? {
+          ...resolvedBeforeSpacingPx !== void 0 ? { marginTop: resolvedBeforeSpacingPx } : void 0,
+          ...resolvedAfterSpacingPx !== void 0 ? { marginBottom: resolvedAfterSpacingPx } : void 0
         } : void 0,
         ...letterheadStyleAdjustments ?? void 0,
         ...options?.suppressLetterheadColumnLayout && options?.isFirstInLetterheadColumn ? { marginTop: 0 } : void 0,
@@ -39323,7 +41400,8 @@ function DocxEditorViewer({
         {
           style: {
             minHeight: paragraphSegmentVisibleHeightPx + paragraphSegmentClipBleedTopPx + paragraphSegmentClipBleedBottomPx,
-            marginBottom: -(paragraphSegmentClipBleedTopPx + paragraphSegmentClipBleedBottomPx),
+            marginTop: -paragraphSegmentClipBleedTopPx,
+            marginBottom: -paragraphSegmentClipBleedBottomPx,
             paddingTop: paragraphSegmentClipBleedTopPx,
             paddingBottom: paragraphSegmentClipBleedBottomPx,
             overflow: "visible"
@@ -39347,7 +41425,8 @@ function DocxEditorViewer({
         {
           style: {
             height: paragraphSegmentVisibleHeightPx + paragraphSegmentClipBleedTopPx + paragraphSegmentClipBleedBottomPx,
-            marginBottom: -(paragraphSegmentClipBleedTopPx + paragraphSegmentClipBleedBottomPx),
+            marginTop: -paragraphSegmentClipBleedTopPx,
+            marginBottom: -paragraphSegmentClipBleedBottomPx,
             overflow: "hidden"
           },
           children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
@@ -39933,7 +42012,7 @@ ${currentText.slice(end)}`;
           },
           children: !editable ? renderedInteractiveParagraphContent : null
         },
-        paragraphLineRange ? `epoch-${paragraphStructureEpoch}-node-${nodeIndex}-lines-${paragraphSegmentStartLine}-${paragraphSegmentEndLine}` : `epoch-${paragraphStructureEpoch}-node-${nodeIndex}`
+        paragraphLineRange ? `epoch-${paragraphStructureEpoch}-node-${nodeIndex}-lines-${paragraphSegmentStartLine}-${paragraphSegmentEndLine}${options?.syntheticKeySuffix ? `-${options.syntheticKeySuffix}` : ""}` : `epoch-${paragraphStructureEpoch}-node-${nodeIndex}${options?.syntheticKeySuffix ? `-${options.syntheticKeySuffix}` : ""}`
       );
     }
     const tableRowSliceOffsetPxForWrapper = tableRowSlice ? Math.max(0, Math.round(tableRowSlice.startOffsetPx)) : 0;
@@ -39966,7 +42045,7 @@ ${currentText.slice(end)}`;
             paddingTop: tableRowSliceTopBleedPxForWrapper,
             paddingBottom: tableRowSliceBottomBleedPxForWrapper,
             boxSizing: "border-box",
-            overflow: "clip"
+            overflow: "visible"
           } : void 0
         },
         onPointerEnter: () => {
@@ -39999,11 +42078,12 @@ ${currentText.slice(end)}`;
         },
         children: (() => {
           const tableIndentPx = twipsToSignedPixels(node.style?.indentTwips) ?? 0;
+          const columnCount = tableColumnCount(node);
+          const collapsedHorizontalBorderBleedPx = resolveCollapsedTableHorizontalOuterBleedPx(node, columnCount);
           const maxTableWidthPx = Math.max(
             120,
-            nodeContentWidthPx - tableIndentPx
+            nodeContentWidthPx - tableIndentPx - collapsedHorizontalBorderBleedPx
           );
-          const columnCount = tableColumnCount(node);
           const tableWidthPx = twipsToPixels(node.style?.widthTwips);
           const hasStoredColumnWidths = (tableColumnWidths[nodeIndex]?.length ?? 0) === columnCount;
           const rawColumnWidthsPx = resolveTableColumnWidths(
@@ -40096,6 +42176,7 @@ ${currentText.slice(end)}`;
                 "span",
                 {
                   contentEditable: false,
+                  "data-docx-pagination-ignore": "true",
                   style: {
                     position: "absolute",
                     top: -TABLE_HANDLE_SAFEZONE_TOP_PX,
@@ -40113,6 +42194,7 @@ ${currentText.slice(end)}`;
                 "span",
                 {
                   contentEditable: false,
+                  "data-docx-pagination-ignore": "true",
                   style: {
                     position: "absolute",
                     right: -TABLE_HANDLE_SAFEZONE_RIGHT_PX,
@@ -40202,10 +42284,7 @@ ${currentText.slice(end)}`;
                 style: {
                   width: resolvedTableWidthPx > 0 ? `${resolvedTableWidthPx}px` : "100%",
                   ...tableElementBorderStyle(node, tableBorderSpacingPx),
-                  tableLayout: node.style?.layout === "autofit" ? "auto" : "fixed",
-                  ...hasTableRowSlice && tableRowSliceOffsetPx > 0 ? {
-                    transform: `translateY(-${tableRowSliceOffsetPx - tableRowSliceTopBleedPx}px)`
-                  } : void 0
+                  tableLayout: node.style?.layout === "autofit" ? "auto" : "fixed"
                 },
                 children: [
                   /* @__PURE__ */ (0, import_jsx_runtime.jsx)("colgroup", { children: columnWidthsPx.map((widthPx, columnIndex) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
@@ -40253,7 +42332,7 @@ ${currentText.slice(end)}`;
                           );
                           const recursiveCellParagraphs = tableCellParagraphsRecursively(cell.nodes);
                           const cellHasImage = tableCellHasImage(cell.nodes);
-                          const editableCell = selectedByAnchor && !isMultiCellSelectionActive && !cellHasImage && !isReadOnly && cellParagraphs.length > 0;
+                          const editableCell = selectedByAnchor && !isSlicedRow && !isMultiCellSelectionActive && !cellHasImage && !isReadOnly && cellParagraphs.length > 0;
                           const nestedParagraphIndexesByNode = /* @__PURE__ */ new Map();
                           recursiveCellParagraphs.forEach(
                             (paragraph, paragraphIndex) => {
@@ -40263,7 +42342,7 @@ ${currentText.slice(end)}`;
                               );
                             }
                           );
-                          const tableCellEditScope = recursiveCellParagraphs.length > 0 && !isReadOnly && !isMultiCellSelectionActive && !cellHasImage ? {
+                          const tableCellEditScope = recursiveCellParagraphs.length > 0 && !isReadOnly && !isSlicedRow && !isMultiCellSelectionActive && !cellHasImage ? {
                             isEditable: true,
                             draftKeyPrefix: `${nodeIndex}:${rowIndex}:${cellIndex}`,
                             paragraphIndexesByNode: nestedParagraphIndexesByNode,
@@ -40304,6 +42383,38 @@ ${currentText.slice(end)}`;
                           ).reduce((sum, widthPx) => sum + widthPx, 0);
                           const cellBackgroundColor = cell.style?.backgroundColor ?? row.style?.backgroundColor;
                           const hasCustomCellRowHeight = hasCustomRowHeight || hasResolvedRowHeight;
+                          const mergedCellMarginTwips = mergeTableSpacing(
+                            tableCellMarginTwips,
+                            cell.style?.marginTwips
+                          );
+                          const cellPaddingPx = resolveTableSpacingPaddingPx(
+                            mergedCellMarginTwips
+                          );
+                          const cellRenderedWidthPx = cellWidthPx ?? spannedWidthPx;
+                          const cellContentWidthPx = Math.max(
+                            1,
+                            cellRenderedWidthPx - cellPaddingPx.left - cellPaddingPx.right
+                          );
+                          const slicedRowHeightPx = Math.max(
+                            MIN_PARAGRAPH_LINE_HEIGHT_PX,
+                            Math.round(
+                              rowBoundarySourceHeightsPx[rowIndex] ?? rowHeightPx ?? MIN_PARAGRAPH_LINE_HEIGHT_PX
+                            )
+                          );
+                          const slicedCellViewportHeightPx = isSlicedRow && tableRowSlice ? Math.max(
+                            MIN_PARAGRAPH_LINE_HEIGHT_PX,
+                            Math.round(tableRowSlice.sliceHeightPx)
+                          ) : void 0;
+                          const slicedParagraphPlans = isSlicedRow && tableRowSlice && !editableCell && slicedCellViewportHeightPx ? resolveTableCellParagraphSlicePlans({
+                            cell,
+                            rowHeightPx: slicedRowHeightPx,
+                            sliceStartPx: tableRowSliceOffsetPx,
+                            sliceHeightPx: slicedCellViewportHeightPx,
+                            cellContentWidthPx,
+                            tableCellMarginTwips,
+                            applyWordTableDefaults,
+                            docGridLinePitchPx: nodeDocGridLinePitchPx
+                          }) : void 0;
                           const renderedEditableCellContent = editableCell ? (() => {
                             let paragraphCursor = 0;
                             return cell.nodes.map(
@@ -40401,10 +42512,7 @@ ${currentText.slice(end)}`;
                                   cell.style?.borders
                                 ),
                                 ...tableSpacingPaddingStyle(
-                                  mergeTableSpacing(
-                                    tableCellMarginTwips,
-                                    cell.style?.marginTwips
-                                  )
+                                  mergedCellMarginTwips
                                 ),
                                 backgroundColor: cellBackgroundColor,
                                 verticalAlign: cell.style?.verticalAlign ?? "top",
@@ -41225,6 +43333,45 @@ ${currentText.slice(end)}`;
                                     );
                                   }
                                 }
+                              ) : slicedParagraphPlans && slicedCellViewportHeightPx ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                                "div",
+                                {
+                                  style: {
+                                    position: "relative",
+                                    height: slicedCellViewportHeightPx,
+                                    overflow: "visible"
+                                  },
+                                  children: slicedParagraphPlans.map((plan) => {
+                                    const contentIndex = cell.nodes.indexOf(
+                                      plan.paragraph
+                                    );
+                                    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                                      "div",
+                                      {
+                                        style: {
+                                          position: "absolute",
+                                          left: 0,
+                                          right: 0,
+                                          top: plan.topPx
+                                        },
+                                        children: renderSlicedTableCellParagraph({
+                                          paragraph: plan.paragraph,
+                                          paragraphIndex: plan.paragraphIndex,
+                                          tableIndex: nodeIndex,
+                                          rowIndex,
+                                          cellIndex,
+                                          contentIndex,
+                                          cellContentWidthPx,
+                                          applyWordTableDefaults,
+                                          docGridLinePitchPx: nodeDocGridLinePitchPx,
+                                          layoutEntry: plan.layoutEntry,
+                                          paragraphLineRange: plan.paragraphLineRange
+                                        })
+                                      },
+                                      `body-cell-slice-host-${nodeIndex}-${rowIndex}-${cellIndex}-${contentIndex}`
+                                    );
+                                  })
+                                }
                               ) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { style: { display: "grid", gap: 4 }, children: (() => {
                                 let paragraphCursor = 0;
                                 return cell.nodes.map(
@@ -42716,10 +44863,11 @@ ${currentText.slice(end)}`;
               pageLayout.pageHeightPx - pageLayout.marginsPx.top - pageLayout.marginsPx.bottom
             ),
             metricsBySection: paginationSectionMetrics,
-            measuredPageContentHeightsPxByPageIndex: measuredPageContentHeightByIndex,
+            measuredPageContentHeightsPxByPageIndex: renderMeasuredPageContentHeightsPxByPageIndex,
             measuredPageContentIdentityKeysByPageIndex: measuredPageContentIdentityKeysByIndex,
             pageIdentityKey: pageNodeSegmentIdentityKeysByPage[pageIndex],
-            useMeasuredPageContentHeights: useMeasuredPageContentHeightsForRender
+            useMeasuredPageContentHeights: useMeasuredPageContentHeightsForRender,
+            pageContentHeightScale: renderPageContentHeightScale
           });
           const headerFooterBodyDimmed = pageHeaderFooterEditActive;
           const documentPageBackgroundColor = editor.model.metadata.documentBackgroundColor;
@@ -43013,6 +45161,7 @@ ${currentText.slice(end)}`;
                             display: "flex",
                             flexDirection: "column",
                             minHeight: pageBodyAvailableHeightPx,
+                            overflow: "visible",
                             ...documentContentFilter ? { filter: documentContentFilter } : void 0
                           },
                           children: [
@@ -43080,6 +45229,44 @@ ${currentText.slice(end)}`;
                                   if (!columnNode) {
                                     return null;
                                   }
+                                  const explicitColumnBreakParagraphSegments = columnNode.type === "paragraph" && !columnSegment.tableRowRange && !columnSegment.tableRowSlice && !columnSegment.paragraphLineRange && !explicitColumnWidthsPx && (sectionColumns?.count ?? 0) > 1 ? splitParagraphAtExplicitColumnBreaks(columnNode) : void 0;
+                                  if (explicitColumnBreakParagraphSegments && explicitColumnBreakParagraphSegments.length > 1) {
+                                    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                                      React.Fragment,
+                                      {
+                                        children: explicitColumnBreakParagraphSegments.map(
+                                          (segmentParagraph, segmentIndex) => {
+                                            const isLastSegment = segmentIndex >= explicitColumnBreakParagraphSegments.length - 1;
+                                            return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                                              "div",
+                                              {
+                                                style: segmentIndex > 0 ? { breakBefore: "column" } : void 0,
+                                                children: renderDocumentNode(
+                                                  segmentParagraph,
+                                                  columnSegment.nodeIndex,
+                                                  void 0,
+                                                  void 0,
+                                                  void 0,
+                                                  {
+                                                    pageLayout,
+                                                    contentWidthPxOverride: columnContentWidthPx,
+                                                    suppressLikelyFullPageCoverImageKeys: suppressedLikelyFullPageCoverImageKeys,
+                                                    forceReadOnly: true,
+                                                    suppressParagraphElementTracking: segmentIndex > 0,
+                                                    syntheticKeySuffix: `column-break-${segmentIndex}`,
+                                                    overrideBeforeSpacingPx: segmentIndex === 0 ? void 0 : 0,
+                                                    overrideAfterSpacingPx: isLastSegment ? void 0 : 0
+                                                  }
+                                                )
+                                              },
+                                              `column-layout-node-${pageIndex}-${columnSegment.nodeIndex}-column-break-${segmentIndex}`
+                                            );
+                                          }
+                                        )
+                                      },
+                                      `column-layout-node-${pageIndex}-${columnSegment.nodeIndex}-column-break-group`
+                                    );
+                                  }
                                   const renderedNode = renderDocumentNode(
                                     columnNode,
                                     columnSegment.nodeIndex,
@@ -44751,6 +46938,9 @@ var DEFAULT_MIN_PARAGRAPH_LINE_HEIGHT_PX = 14;
 var PARAGRAPH_SEGMENT_TOP_BLEED_PX2 = 22;
 var PARAGRAPH_SEGMENT_DESCENDER_BLEED_PX2 = 6;
 var PARAGRAPH_SEGMENT_VISUAL_SAFETY_PX2 = 24;
+var LAST_RENDERED_PAGE_BREAK_HINT_MAX_REMAINING_SPACE_RATIO2 = 0.18;
+var LAST_RENDERED_PAGE_BREAK_HINT_MIN_REMAINING_SPACE_PX2 = DEFAULT_MIN_PARAGRAPH_LINE_HEIGHT_PX * 3;
+var LAST_RENDERED_PAGE_BREAK_HINT_MAX_REMAINING_SPACE_PX2 = 120;
 function paragraphSegmentHasPartialLineRange2(paragraphLineRange) {
   if (!paragraphLineRange) {
     return false;
@@ -44819,6 +47009,48 @@ function normalizedPositivePixelValue(value, fallback) {
   }
   return Math.max(1, Math.round(value));
 }
+function shouldHonorParagraphStartLastRenderedPageBreak2(params) {
+  const pageConsumedHeightPx = Math.max(
+    0,
+    Math.round(params.pageConsumedHeightPx)
+  );
+  const pageContentHeightPx = Math.max(
+    0,
+    Math.round(params.pageContentHeightPx)
+  );
+  if (pageConsumedHeightPx <= 0 || pageContentHeightPx <= 0) {
+    return false;
+  }
+  const remainingHeightPx = Math.max(
+    0,
+    pageContentHeightPx - pageConsumedHeightPx
+  );
+  const maxAllowedRemainingHeightPx = Math.max(
+    LAST_RENDERED_PAGE_BREAK_HINT_MIN_REMAINING_SPACE_PX2,
+    Math.min(
+      LAST_RENDERED_PAGE_BREAK_HINT_MAX_REMAINING_SPACE_PX2,
+      Math.round(
+        pageContentHeightPx * LAST_RENDERED_PAGE_BREAK_HINT_MAX_REMAINING_SPACE_RATIO2
+      )
+    )
+  );
+  return remainingHeightPx <= maxAllowedRemainingHeightPx;
+}
+function keepNextParagraphReservePx(paragraph, nextParagraph, callbacks, docGridLinePitchPx) {
+  if (paragraph.style?.keepNext !== true || !nextParagraph || !Number.isFinite(paragraph.style?.headingLevel)) {
+    return 0;
+  }
+  const nextParagraphText = nextParagraph.children.filter((child) => child.type === "text").map((child) => child.text).join(" ").replace(/\s+/g, " ").trim();
+  if (nextParagraph.style?.numbering === void 0 && nextParagraphText.length < 80) {
+    return 0;
+  }
+  return Math.max(
+    nextParagraph.style?.numbering ? 10 : 6,
+    Math.round(
+      callbacks.estimateParagraphLineHeightPx(nextParagraph, docGridLinePitchPx) * (nextParagraph.style?.numbering ? 1 : 0.5)
+    )
+  );
+}
 function normalizedMeasuredTableRowHeights(measuredRowHeightsPx, expectedRowCount, minParagraphLineHeightPx) {
   if (!measuredRowHeightsPx || measuredRowHeightsPx.length !== expectedRowCount) {
     return void 0;
@@ -45011,6 +47243,12 @@ function collectDocxEstimatedOverflowBreakStartNodeIndexes(model, hardBreakStart
           paragraphBeforeSpacingPx2(nextChainNode)
         );
         requiredHeightPx += Math.max(1, nextRawHeightPx - collapsedChainMarginPx);
+        requiredHeightPx += keepNextParagraphReservePx(
+          currentChainNode,
+          nextChainNode,
+          callbacks,
+          chainMetrics.docGridLinePitchPx
+        );
         chainPreviousParagraphAfterPx = paragraphAfterSpacingPx2(nextChainNode);
       }
     }
@@ -45107,7 +47345,10 @@ function buildDocumentPageNodeSegments2(model, pageContentHeightPx, pageContentW
           nodeMetrics.pageContentHeightPx
         );
       }
-      if (preferLastRenderedParagraphStartBreaks && paragraphStartsWithLastRenderedPageBreak2(node) && currentPageSegments.length > 0) {
+      if (preferLastRenderedParagraphStartBreaks && paragraphStartsWithLastRenderedPageBreak2(node) && shouldHonorParagraphStartLastRenderedPageBreak2({
+        pageConsumedHeightPx,
+        pageContentHeightPx: currentPageContentHeightPx
+      }) && currentPageSegments.length > 0) {
         startNextPage();
         pageConsumedHeightPx = 0;
         previousParagraphAfterPx = 0;
@@ -45332,6 +47573,12 @@ function buildDocumentPageNodeSegments2(model, pageContentHeightPx, pageContentW
             paragraphBeforeSpacingPx2(nextChainNode)
           );
           requiredHeightPx += Math.max(1, nextRawHeightPx - collapsedChainMarginPx);
+          requiredHeightPx += keepNextParagraphReservePx(
+            currentChainNode,
+            nextChainNode,
+            callbacks,
+            chainMetrics.docGridLinePitchPx
+          );
           chainPreviousParagraphAfterPx = paragraphAfterSpacingPx2(nextChainNode);
         }
       }
@@ -46132,6 +48379,7 @@ function ReactDocxViewer({
   useDocxPagination,
   useDocxParagraphStyles,
   useDocxTrackChanges,
+  useDocxViewerThumbnails,
   withPart
 });
 //# sourceMappingURL=index.cjs.map