@extend-ai/react-docx 0.7.0-alpha.2 → 0.7.0-alpha.4

package/dist/index.cjs

@@ -160,6 +160,15 @@ function __wbg_get_imports() {
       getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
       getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
     },
+    __wbg___wbindgen_is_null_ced4761460071341: function(arg0) {
+      const ret = getObject(arg0) === null;
+      return ret;
+    },
+    __wbg___wbindgen_is_object_3a2c414391dbf751: function(arg0) {
+      const val = getObject(arg0);
+      const ret = typeof val === "object" && val !== null;
+      return ret;
+    },
     __wbg___wbindgen_is_undefined_4410e3c20a99fa97: function(arg0) {
       const ret = getObject(arg0) === void 0;
       return ret;
@@ -175,12 +184,83 @@ function __wbg_get_imports() {
     __wbg___wbindgen_throw_bbadd78c1bac3a77: function(arg0, arg1) {
       throw new Error(getStringFromWasm0(arg0, arg1));
     },
+    __wbg_create_00e11a7cefe80760: function(arg0) {
+      const ret = Object.create(getObject(arg0));
+      return addHeapObject(ret);
+    },
+    __wbg_get_52a8a619f7b88df6: function() {
+      return handleError(function(arg0, arg1) {
+        const ret = Reflect.get(getObject(arg0), getObject(arg1));
+        return addHeapObject(ret);
+      }, arguments);
+    },
+    __wbg_get_unchecked_46e778e3cec74b5e: function(arg0, arg1) {
+      const ret = getObject(arg0)[arg1 >>> 0];
+      return addHeapObject(ret);
+    },
+    __wbg_instanceof_ArrayBuffer_a581da923203f29f: function(arg0) {
+      let result;
+      try {
+        result = getObject(arg0) instanceof ArrayBuffer;
+      } catch (_) {
+        result = false;
+      }
+      const ret = result;
+      return ret;
+    },
+    __wbg_instanceof_Uint8Array_b6fe1ac89eba107e: function(arg0) {
+      let result;
+      try {
+        result = getObject(arg0) instanceof Uint8Array;
+      } catch (_) {
+        result = false;
+      }
+      const ret = result;
+      return ret;
+    },
+    __wbg_isArray_139f48e3c057ede8: function(arg0) {
+      const ret = Array.isArray(getObject(arg0));
+      return ret;
+    },
+    __wbg_keys_bd51ff67a9b04698: function(arg0) {
+      const ret = Object.keys(getObject(arg0));
+      return addHeapObject(ret);
+    },
+    __wbg_length_68a9d5278d084f4f: function(arg0) {
+      const ret = getObject(arg0).length;
+      return ret;
+    },
+    __wbg_length_fb04d16d7bdf6d4c: function(arg0) {
+      const ret = getObject(arg0).length;
+      return ret;
+    },
+    __wbg_new_20b778a4c5c691c3: function() {
+      const ret = new Object();
+      return addHeapObject(ret);
+    },
+    __wbg_new_b06772b280cc6e52: function(arg0) {
+      const ret = new Uint8Array(getObject(arg0));
+      return addHeapObject(ret);
+    },
+    __wbg_new_from_slice_bb2d1778c0b87eb1: function(arg0, arg1) {
+      const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+      return addHeapObject(ret);
+    },
     __wbg_parse_246201845d0eb98c: function() {
       return handleError(function(arg0, arg1) {
         const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
         return addHeapObject(ret);
       }, arguments);
     },
+    __wbg_prototypesetcall_956c7493c68e29b4: function(arg0, arg1, arg2) {
+      Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
+    },
+    __wbg_set_a6ba3ac0e634b822: function() {
+      return handleError(function(arg0, arg1, arg2) {
+        const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
+        return ret;
+      }, arguments);
+    },
     __wbg_stringify_a42c95ea9a7591c9: function() {
       return handleError(function(arg0) {
         const ret = JSON.stringify(getObject(arg0));
@@ -474,9 +554,15 @@ async function defaultWasmSource() {
 async function initWasm(source) {
   if (!initPromise) {
     const chosen = source ?? overrideSource;
-    initPromise = (chosen !== void 0 ? Promise.resolve(chosen) : defaultWasmSource()).then(
-      (module_or_path) => __wbg_init({ module_or_path })
-    );
+    initPromise = (chosen !== void 0 ? Promise.resolve(chosen) : defaultWasmSource()).then((module_or_path) => __wbg_init({ module_or_path })).catch((error) => {
+      if (error instanceof WebAssembly.CompileError) {
+        throw new Error(
+          `react-docx: the bundled WebAssembly binary failed to compile. It requires WebAssembly SIMD support (Chrome 91+, Firefox 89+, Safari 16.4+, Node 16.4+). Original error: ${error.message}`,
+          { cause: error }
+        );
+      }
+      throw error;
+    });
   }
   return initPromise;
 }
@@ -515,7 +601,7 @@ function mapsToWasmPackage(input) {
   }
   const binaryAssets = {};
   for (const [name, asset] of input.binaryAssets.entries()) {
-    binaryAssets[name] = Array.from(asset);
+    binaryAssets[name] = asset;
   }
   return { parts, binaryAssets };
 }
@@ -2906,16 +2992,17 @@ function shouldAllowStoredPageCountReduction(options) {
   if (targetPageCount >= estimatedPageCount) {
     return true;
   }
+  const renderedBreakHintPageCount = Number.isFinite(
+    options.renderedBreakHintPageCount
+  ) ? Math.max(1, Math.round(options.renderedBreakHintPageCount)) : void 0;
+  const renderedBreakHintsSupportTarget = options.hasLastRenderedPageBreakHints === true && renderedBreakHintPageCount !== void 0 && targetPageCount >= renderedBreakHintPageCount;
   if (options.hasMeasuredBodyFooterOverlap === true) {
-    return false;
+    return renderedBreakHintsSupportTarget;
   }
   if (options.hasLastRenderedPageBreakHints !== true) {
     return true;
   }
-  const renderedBreakHintPageCount = Number.isFinite(
-    options.renderedBreakHintPageCount
-  ) ? Math.max(1, Math.round(options.renderedBreakHintPageCount)) : void 0;
-  return renderedBreakHintPageCount !== void 0 && targetPageCount >= renderedBreakHintPageCount;
+  return renderedBreakHintsSupportTarget;
 }
 function shouldLatchMeasuredBodyFooterOverlap(options) {
   if (options.measuredBodyFooterOverlap !== true) {
@@ -4022,6 +4109,425 @@ function sliceLayoutToLineRange(layout, startLineIndex, endLineIndex) {
   };
 }
 
+// src/content-signature.ts
+init_cjs_shims();
+var FNV_OFFSET_BASIS = 2166136261;
+var FNV_PRIME = 16777619;
+var LONG_STRING_SAMPLE_LENGTH = 64;
+var LONG_STRING_THRESHOLD = 256;
+function fnv1aAppend(hash, text) {
+  let next = hash;
+  for (let index = 0; index < text.length; index += 1) {
+    next ^= text.charCodeAt(index);
+    next = Math.imul(next, FNV_PRIME);
+  }
+  return next >>> 0;
+}
+function fnv1aAppendString(hash, value) {
+  if (value.length <= LONG_STRING_THRESHOLD) {
+    return fnv1aAppend(fnv1aAppend(hash, `${value.length}:`), value);
+  }
+  const head = value.slice(0, LONG_STRING_SAMPLE_LENGTH);
+  const middleIndex = Math.floor(value.length / 2);
+  const middle = value.slice(
+    middleIndex,
+    middleIndex + LONG_STRING_SAMPLE_LENGTH
+  );
+  const tail = value.slice(value.length - LONG_STRING_SAMPLE_LENGTH);
+  let next = fnv1aAppend(hash, `${value.length}:`);
+  next = fnv1aAppend(next, head);
+  next = fnv1aAppend(next, middle);
+  return fnv1aAppend(next, tail);
+}
+function fnv1aAppendValue(hash, value) {
+  if (value === null) {
+    return fnv1aAppend(hash, "~n");
+  }
+  switch (typeof value) {
+    case "undefined":
+      return fnv1aAppend(hash, "~u");
+    case "string":
+      return fnv1aAppendString(fnv1aAppend(hash, "~s"), value);
+    case "number":
+      return fnv1aAppend(hash, `~#${value}`);
+    case "boolean":
+      return fnv1aAppend(hash, value ? "~t" : "~f");
+    case "object":
+      break;
+    default:
+      return fnv1aAppend(hash, "~x");
+  }
+  if (Array.isArray(value)) {
+    let next2 = fnv1aAppend(hash, `~a${value.length}`);
+    for (const entry of value) {
+      next2 = fnv1aAppendValue(next2, entry);
+    }
+    return next2;
+  }
+  if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) {
+    const byteLength = value instanceof ArrayBuffer ? value.byteLength : value.byteLength;
+    return fnv1aAppend(hash, `~b${byteLength}`);
+  }
+  let next = fnv1aAppend(hash, "~o");
+  for (const key of Object.keys(value)) {
+    const entry = value[key];
+    if (entry === void 0) {
+      continue;
+    }
+    next = fnv1aAppend(next, key);
+    next = fnv1aAppendValue(next, entry);
+  }
+  return next;
+}
+function contentHash(value) {
+  return fnv1aAppendValue(FNV_OFFSET_BASIS, value).toString(36);
+}
+var nodeSignatureCache = /* @__PURE__ */ new WeakMap();
+function docNodeContentSignature(node) {
+  if (typeof node !== "object" || node === null) {
+    return contentHash(node);
+  }
+  const cached = nodeSignatureCache.get(node);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const signature = contentHash(node);
+  nodeSignatureCache.set(node, signature);
+  return signature;
+}
+var metadataSignatureCache = /* @__PURE__ */ new WeakMap();
+function docModelThumbnailMetadataSignature(metadata) {
+  const cached = metadataSignatureCache.get(metadata);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const relevant = metadata;
+  let hash = FNV_OFFSET_BASIS;
+  hash = fnv1aAppendValue(hash, relevant.sections);
+  hash = fnv1aAppendValue(hash, relevant.headerSections);
+  hash = fnv1aAppendValue(hash, relevant.footerSections);
+  hash = fnv1aAppendValue(hash, relevant.numberingDefinitions);
+  hash = fnv1aAppendValue(hash, relevant.footnotes);
+  hash = fnv1aAppendValue(hash, relevant.endnotes);
+  hash = fnv1aAppendValue(hash, relevant.documentBackgroundColor);
+  hash = fnv1aAppendValue(hash, relevant.compatibility);
+  const signature = (hash >>> 0).toString(36);
+  metadataSignatureCache.set(metadata, signature);
+  return signature;
+}
+
+// src/thumbnail-raster.ts
+init_cjs_shims();
+var DOCX_THUMBNAIL_EXCLUDE_ATTRIBUTE = "data-docx-thumbnail-exclude";
+var THUMBNAIL_EXCLUDED_CLONE_SELECTOR = [
+  `[${DOCX_THUMBNAIL_EXCLUDE_ATTRIBUTE}="true"]`,
+  "textarea",
+  '[data-image-resize-handle="true"]',
+  '[data-docx-table-move-handle="true"]'
+].join(",");
+var THUMBNAIL_IMAGE_DOWNSCALE_MIN_DATA_URI_LENGTH = 32768;
+var THUMBNAIL_IMAGE_DOWNSCALE_MAX_DIMENSION_PX = 512;
+var THUMBNAIL_IMAGE_JPEG_QUALITY = 0.78;
+function thumbnailSvgDataUri(svg) {
+  return `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`;
+}
+function thumbnailImageSourceQualifiesForDownscale(src) {
+  return src.length >= THUMBNAIL_IMAGE_DOWNSCALE_MIN_DATA_URI_LENGTH && src.startsWith("data:image/") && !src.startsWith("data:image/svg");
+}
+async function loadThumbnailImage(src) {
+  const image = new Image();
+  image.decoding = "async";
+  const loaded = new Promise((resolve, reject) => {
+    image.onload = () => resolve(image);
+    image.onerror = () => {
+      reject(new Error("Failed to decode DOCX thumbnail image."));
+    };
+  });
+  image.src = src;
+  if (typeof image.decode === "function") {
+    try {
+      await image.decode();
+      return image;
+    } catch {
+    }
+  }
+  return loaded;
+}
+var downscaledThumbnailImageCache = /* @__PURE__ */ new Map();
+async function downscaleThumbnailImageDataUri(src) {
+  if (typeof document === "undefined") {
+    return void 0;
+  }
+  const image = await loadThumbnailImage(src);
+  const naturalWidth = image.naturalWidth || image.width;
+  const naturalHeight = image.naturalHeight || image.height;
+  if (!naturalWidth || !naturalHeight) {
+    return void 0;
+  }
+  const scale = THUMBNAIL_IMAGE_DOWNSCALE_MAX_DIMENSION_PX / Math.max(naturalWidth, naturalHeight);
+  if (scale >= 1) {
+    return void 0;
+  }
+  const canvas = document.createElement("canvas");
+  canvas.width = Math.max(1, Math.round(naturalWidth * scale));
+  canvas.height = Math.max(1, Math.round(naturalHeight * scale));
+  const context = canvas.getContext("2d");
+  if (!context) {
+    return void 0;
+  }
+  context.imageSmoothingEnabled = true;
+  context.imageSmoothingQuality = "high";
+  context.drawImage(image, 0, 0, canvas.width, canvas.height);
+  const sourceIsJpeg = src.startsWith("data:image/jpeg") || src.startsWith("data:image/jpg");
+  const downscaled = sourceIsJpeg ? canvas.toDataURL("image/jpeg", THUMBNAIL_IMAGE_JPEG_QUALITY) : canvas.toDataURL("image/png");
+  return downscaled.length < src.length ? downscaled : void 0;
+}
+function getDownscaledThumbnailImageDataUri(src) {
+  const cached = downscaledThumbnailImageCache.get(src);
+  if (cached) {
+    return cached;
+  }
+  const pending = downscaleThumbnailImageDataUri(src).catch(() => void 0);
+  downscaledThumbnailImageCache.set(src, pending);
+  return pending;
+}
+async function buildDocxThumbnailSvgMarkup(params) {
+  const { pageElement, sourceWidthPx, sourceHeightPx, widthPx, heightPx } = params;
+  const clone = pageElement.cloneNode(true);
+  clone.querySelectorAll(THUMBNAIL_EXCLUDED_CLONE_SELECTOR).forEach((excluded) => {
+    excluded.remove();
+  });
+  const cloneImages = Array.from(clone.querySelectorAll("img"));
+  await Promise.all(
+    cloneImages.map(async (cloneImage) => {
+      const src = cloneImage.getAttribute("src");
+      if (!src || !thumbnailImageSourceQualifiesForDownscale(src)) {
+        return;
+      }
+      const downscaled = await getDownscaledThumbnailImageDataUri(src);
+      if (downscaled) {
+        cloneImage.setAttribute("src", downscaled);
+      }
+    })
+  );
+  const scaleX = widthPx / sourceWidthPx;
+  const scaleY = heightPx / sourceHeightPx;
+  const serializedPage = new XMLSerializer().serializeToString(clone);
+  return `
+    <svg xmlns="http://www.w3.org/2000/svg" width="${widthPx}" height="${heightPx}" viewBox="0 0 ${widthPx} ${heightPx}">
+      <foreignObject x="0" y="0" width="100%" height="100%">
+        <div xmlns="http://www.w3.org/1999/xhtml" style="width:${widthPx}px;height:${heightPx}px;overflow:hidden;">
+          <div style="width:${sourceWidthPx}px;height:${sourceHeightPx}px;transform-origin:top left;transform:scale(${scaleX}, ${scaleY});">
+            ${serializedPage}
+          </div>
+        </div>
+      </foreignObject>
+    </svg>
+  `;
+}
+async function rasterizeDocxThumbnailSurface(params) {
+  if (typeof window === "undefined" || typeof XMLSerializer === "undefined") {
+    throw new Error("DOCX thumbnails require a browser environment.");
+  }
+  const safeSourceWidthPx = Math.max(1, Math.round(params.sourceWidthPx));
+  const safeSourceHeightPx = Math.max(1, Math.round(params.sourceHeightPx));
+  const svgMarkup = await buildDocxThumbnailSvgMarkup({
+    pageElement: params.pageElement,
+    sourceWidthPx: safeSourceWidthPx,
+    sourceHeightPx: safeSourceHeightPx,
+    widthPx: params.widthPx,
+    heightPx: params.heightPx
+  });
+  const image = await loadThumbnailImage(thumbnailSvgDataUri(svgMarkup));
+  const surface = document.createElement("canvas");
+  surface.width = Math.max(1, Math.round(params.pixelWidthPx));
+  surface.height = Math.max(1, Math.round(params.pixelHeightPx));
+  const context = surface.getContext("2d");
+  if (!context) {
+    throw new Error("2D canvas context is unavailable for DOCX thumbnails.");
+  }
+  context.imageSmoothingEnabled = true;
+  context.imageSmoothingQuality = "high";
+  context.drawImage(image, 0, 0, surface.width, surface.height);
+  return surface;
+}
+function blitDocxThumbnailSurface(surface, canvas, resolution) {
+  canvas.width = Math.max(1, Math.round(resolution.pixelWidthPx));
+  canvas.height = Math.max(1, Math.round(resolution.pixelHeightPx));
+  canvas.style.width = `${Math.max(1, Math.round(resolution.widthPx))}px`;
+  canvas.style.height = `${Math.max(1, Math.round(resolution.heightPx))}px`;
+  const context = canvas.getContext("2d");
+  if (!context) {
+    throw new Error("2D canvas context is unavailable for DOCX thumbnails.");
+  }
+  context.setTransform(1, 0, 0, 1, 0, 0);
+  context.clearRect(0, 0, canvas.width, canvas.height);
+  context.drawImage(surface, 0, 0, canvas.width, canvas.height);
+}
+var DocxThumbnailSurfaceCache = class {
+  constructor(maxEntries) {
+    this.maxEntries = maxEntries;
+  }
+  entries = /* @__PURE__ */ new Map();
+  get size() {
+    return this.entries.size;
+  }
+  get(key) {
+    const value = this.entries.get(key);
+    if (value === void 0) {
+      return void 0;
+    }
+    this.entries.delete(key);
+    this.entries.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    this.entries.delete(key);
+    this.entries.set(key, value);
+    while (this.entries.size > this.maxEntries) {
+      const oldestKey = this.entries.keys().next().value;
+      if (oldestKey === void 0) {
+        break;
+      }
+      this.entries.delete(oldestKey);
+    }
+  }
+  clear() {
+    this.entries.clear();
+  }
+};
+var IDLE_TASK_TIMEOUT_MS = 300;
+function defaultScheduleTask(callback) {
+  const idleWindow = typeof window === "undefined" ? void 0 : window;
+  if (!idleWindow || typeof idleWindow.requestIdleCallback !== "function") {
+    setTimeout(callback, 16);
+    return;
+  }
+  let invoked = false;
+  const runOnce = () => {
+    if (invoked) {
+      return;
+    }
+    invoked = true;
+    callback();
+  };
+  const idleHandle = idleWindow.requestIdleCallback(runOnce, {
+    timeout: IDLE_TASK_TIMEOUT_MS
+  });
+  setTimeout(() => {
+    if (invoked) {
+      return;
+    }
+    if (typeof idleWindow.cancelIdleCallback === "function") {
+      idleWindow.cancelIdleCallback(idleHandle);
+    }
+    runOnce();
+  }, IDLE_TASK_TIMEOUT_MS + 50);
+}
+function defaultScheduleDelayed(callback, delayMs) {
+  setTimeout(callback, delayMs);
+}
+var SerialIdleTaskQueue = class {
+  pending = [];
+  lastRunAtByKey = /* @__PURE__ */ new Map();
+  scheduleTask;
+  scheduleDelayed;
+  minTaskIntervalMs;
+  now;
+  pumpScheduled = false;
+  running = false;
+  constructor(options) {
+    this.scheduleTask = options?.scheduleTask ?? defaultScheduleTask;
+    this.scheduleDelayed = options?.scheduleDelayed ?? defaultScheduleDelayed;
+    this.minTaskIntervalMs = Math.max(0, options?.minTaskIntervalMs ?? 0);
+    this.now = options?.now ?? (() => Date.now());
+  }
+  get pendingCount() {
+    return this.pending.length;
+  }
+  enqueue(key, run) {
+    return new Promise((resolve) => {
+      const existing = this.pending.find((entry) => entry.key === key);
+      if (existing) {
+        existing.run = run;
+        existing.resolvers.push(resolve);
+      } else {
+        this.pending.push({ key, run, resolvers: [resolve] });
+      }
+      this.schedulePump();
+    });
+  }
+  /** Drops all queued tasks, resolving their waiters without running them. */
+  clear() {
+    const dropped = this.pending.splice(0, this.pending.length);
+    this.lastRunAtByKey.clear();
+    dropped.forEach((entry) => {
+      entry.resolvers.forEach((resolveEntry) => {
+        resolveEntry();
+      });
+    });
+  }
+  schedulePump() {
+    if (this.pumpScheduled || this.running || this.pending.length === 0) {
+      return;
+    }
+    this.pumpScheduled = true;
+    this.scheduleTask(() => {
+      this.pumpScheduled = false;
+      void this.runNext();
+    });
+  }
+  takeNextEligibleEntry() {
+    if (this.pending.length === 0) {
+      return void 0;
+    }
+    const now = this.now();
+    let earliestWaitMs;
+    for (let index = 0; index < this.pending.length; index += 1) {
+      const candidate = this.pending[index];
+      if (!candidate) {
+        continue;
+      }
+      const lastRunAt = this.lastRunAtByKey.get(candidate.key);
+      const waitMs = lastRunAt === void 0 ? 0 : lastRunAt + this.minTaskIntervalMs - now;
+      if (waitMs <= 0) {
+        this.pending.splice(index, 1);
+        return { entry: candidate };
+      }
+      earliestWaitMs = earliestWaitMs === void 0 ? waitMs : Math.min(earliestWaitMs, waitMs);
+    }
+    return earliestWaitMs === void 0 ? void 0 : { retryDelayMs: earliestWaitMs };
+  }
+  async runNext() {
+    if (this.running) {
+      return;
+    }
+    const next = this.takeNextEligibleEntry();
+    if (!next) {
+      return;
+    }
+    if (!("entry" in next)) {
+      this.scheduleDelayed(() => {
+        this.schedulePump();
+      }, next.retryDelayMs);
+      return;
+    }
+    this.running = true;
+    const { entry } = next;
+    try {
+      await entry.run();
+    } catch {
+    } finally {
+      this.lastRunAtByKey.set(entry.key, this.now());
+      this.running = false;
+      entry.resolvers.forEach((resolveEntry) => {
+        resolveEntry();
+      });
+      this.schedulePump();
+    }
+  }
+};
+
 // src/editor.tsx
 var import_jsx_runtime = require("react/jsx-runtime");
 var HIGHLIGHT_TO_CSS = {
@@ -4118,6 +4624,9 @@ 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.08;
+var WORD_EMPTY_PARAGRAPH_LINE_SCALE = 1.21;
+var WORD_EMPTY_PARAGRAPH_LINE_SCALE_SERIF = 1.15;
+var WORD_EMPTY_PARAGRAPH_LINE_SCALE_SANS = 1.15;
 var WORD_AUTO_LINE_SCALE_BLEND_END_MULTIPLE = 1.08;
 var MIN_AUTO_LINE_MULTIPLE = 0.1;
 var MIN_PARAGRAPH_LINE_HEIGHT_PX = 14;
@@ -4162,7 +4671,6 @@ var TEXT_MEASURE_CACHE_MAX_ENTRIES = 12e3;
 var DEFAULT_TAB_STOP_PX = 48;
 var TAB_LEADER_ZONE_GAP_PX = 20;
 var EMPTY_PARAGRAPH_EXTRA_HEIGHT_PX = 0;
-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;
@@ -6682,19 +7190,6 @@ function floatingTextBoxVisibleTextFromImage(image) {
   const normalized = normalizeFloatingTextBoxComparisonText(text);
   return normalized.length > 0 ? normalized : void 0;
 }
-function absoluteFloatingTextBearingTextBoxFootprintPx(image) {
-  const floating = image.floating;
-  if (!shouldRenderAbsoluteFloatingImage(image) || !floating || image.syntheticTextBox !== true || syntheticTextBoxContainsPictureLayer(image) || !floatingTextBoxVisibleTextFromImage(image)) {
-    return 0;
-  }
-  const imageHeightPx = Number.isFinite(image.heightPx) && image.heightPx > 0 ? Math.round(image.heightPx) : Number.isFinite(image.widthPx) && image.widthPx > 0 ? Math.round(image.widthPx) : MIN_PARAGRAPH_LINE_HEIGHT_PX;
-  const distTPx = Math.max(0, Math.round(floating.distTPx ?? 0));
-  const distBPx = Math.max(0, Math.round(floating.distBPx ?? 0));
-  return Math.max(
-    MIN_PARAGRAPH_LINE_HEIGHT_PX,
-    imageHeightPx + distTPx + distBPx
-  );
-}
 function paragraphVisibleTextIsOnlyAbsoluteFloatingTextBoxContent(paragraph) {
   if (!paragraphHasVisibleText2(paragraph) || paragraphHasFormField2(paragraph)) {
     return false;
@@ -6727,38 +7222,9 @@ function paragraphHasOnlyWhitespaceText(paragraph) {
     return child.text.replace(/[\s\u00a0]+/g, "").length === 0;
   });
 }
-function paragraphHasActiveNumbering(paragraph) {
-  const numbering = paragraph.style?.numbering;
-  return Boolean(
-    numbering && Number.isFinite(numbering.numId) && Math.round(numbering.numId) > 0
-  );
-}
 function paragraphContainsSectionBreakProperties(paragraph) {
   return /<w:sectPr\b/i.test(paragraph.sourceXml ?? "");
 }
-function paragraphTextBearingAbsoluteFloatingTextBoxFootprintPx(paragraph) {
-  if (paragraphHasVisibleText2(paragraph) || paragraphHasFormField2(paragraph) || paragraphContainsSectionBreakProperties(paragraph)) {
-    return 0;
-  }
-  return paragraph.children.reduce((largest, child) => {
-    if (child.type !== "image") {
-      return largest;
-    }
-    return Math.max(
-      largest,
-      absoluteFloatingTextBearingTextBoxFootprintPx(child)
-    );
-  }, 0);
-}
-function paragraphAbsoluteFloatingAnchorsDependOnParagraphFlow(paragraph) {
-  return paragraph.children.some((child) => {
-    if (child.type !== "image" || !shouldRenderAbsoluteFloatingImage(child) || child.syntheticTextBox !== true || !floatingTextBoxVisibleTextFromImage(child) || child.floating?.behindDocument !== true) {
-      return false;
-    }
-    const verticalRelativeTo = child.floating?.verticalRelativeTo?.trim().toLowerCase();
-    return verticalRelativeTo === void 0 || verticalRelativeTo === "" || verticalRelativeTo === "paragraph" || verticalRelativeTo === "line";
-  });
-}
 function likelyFullPageCoverImageRelativeToContentBox(image, pageContentWidthPx, pageContentHeightPx) {
   if (!shouldRenderAbsoluteFloatingImage(image) || !image.floating) {
     return false;
@@ -6841,21 +7307,6 @@ function paragraphParticipatesInLeadingCoverLayout(model, nodeIndex, pageContent
   }
   return sawLikelyCoverArtAnchor;
 }
-function paragraphLikelyFullPageCoverFootprintPx(model, nodeIndex, paragraph, pageContentWidthPx, pageContentHeightPx) {
-  if (!paragraphParticipatesInLeadingCoverLayout(
-    model,
-    nodeIndex,
-    pageContentWidthPx,
-    pageContentHeightPx
-  ) || !paragraphIsLikelyFullPageCoverArtAnchor(
-    paragraph,
-    pageContentWidthPx,
-    pageContentHeightPx
-  )) {
-    return 0;
-  }
-  return Math.max(1, Math.round(pageContentHeightPx));
-}
 function fullPageCoverImageRenderKey(nodeIndex, childIndex) {
   return `${nodeIndex}:${childIndex}`;
 }
@@ -6894,71 +7345,6 @@ function fullPageCoverAbsoluteFloatingImageStyle(image, layout, options) {
     zIndex: floating?.behindDocument === true ? 0 : normalizedZIndex
   };
 }
-function paragraphActsAsLeadingCoverLayoutSpacer(model, nodeIndex, paragraph, pageContentWidthPx, pageContentHeightPx) {
-  if (nodeIndex <= 0 || !paragraphHasOnlyWhitespaceText(paragraph) || paragraphHasExplicitPageBreak2(paragraph)) {
-    return false;
-  }
-  if (paragraphHasActiveNumbering(paragraph)) {
-    return false;
-  }
-  return paragraphParticipatesInLeadingCoverLayout(
-    model,
-    nodeIndex,
-    pageContentWidthPx,
-    pageContentHeightPx
-  );
-}
-function paragraphActsAsLeadingCoverLayoutPreambleSpacer(model, nodeIndex, paragraph, pageContentWidthPx, pageContentHeightPx) {
-  if (!paragraphHasOnlyWhitespaceText(paragraph) || paragraphHasExplicitPageBreak2(paragraph) || paragraphHasActiveNumbering(paragraph)) {
-    return false;
-  }
-  const nextNode = model.nodes[nodeIndex + 1];
-  if (!nextNode || nextNode.type !== "paragraph") {
-    return false;
-  }
-  if (!paragraphParticipatesInLeadingCoverLayout(
-    model,
-    nodeIndex + 1,
-    pageContentWidthPx,
-    pageContentHeightPx
-  )) {
-    return false;
-  }
-  for (let probeIndex = nodeIndex - 1; probeIndex >= 0; probeIndex -= 1) {
-    const previousNode = model.nodes[probeIndex];
-    if (!previousNode || previousNode.type !== "paragraph") {
-      return false;
-    }
-    if (paragraphHasOnlyWhitespaceText(previousNode)) {
-      continue;
-    }
-    if (paragraphHasAbsoluteFloatingImage(previousNode)) {
-      return false;
-    }
-    return !paragraphIsLikelyFullPageCoverArtAnchor(
-      previousNode,
-      pageContentWidthPx,
-      pageContentHeightPx
-    );
-  }
-  return true;
-}
-function paragraphStartsNewPageAfterLeadingCoverLayout(model, nodeIndex, paragraph, pageContentWidthPx, pageContentHeightPx) {
-  if (nodeIndex <= 0 || !paragraphStartsNormalFlowContent(paragraph) || paragraphHasExplicitPageBreak2(paragraph) || paragraphHasPageBreakBefore2(paragraph)) {
-    return false;
-  }
-  const previousNode = model.nodes[nodeIndex - 1];
-  if (!previousNode || previousNode.type !== "paragraph") {
-    return false;
-  }
-  return paragraphActsAsLeadingCoverLayoutSpacer(
-    model,
-    nodeIndex - 1,
-    previousNode,
-    pageContentWidthPx,
-    pageContentHeightPx
-  );
-}
 function paragraphLooksLikeCheckboxChoiceRow(paragraph) {
   if (paragraph.children.some((child) => child.type === "image")) {
     return false;
@@ -7476,7 +7862,8 @@ function buildParagraphPretextLayoutSource(paragraph, options) {
   let combinedText = "";
   const paragraphBaseFontPx = paragraphBaseFontSizePx(paragraph);
   const tabStopPositionsPx = options?.expandTabsForLayout ? resolveParagraphTabStopsPx(paragraph) : [];
-  const fallbackTabWidthPx = paragraphLooksLikeCheckboxChoiceRow(paragraph) ? checkboxChoiceRowTabWidthPx(paragraph) : DEFAULT_TAB_STOP_PX;
+  const usesCheckboxRowTabFallback = paragraphLooksLikeCheckboxChoiceRow(paragraph);
+  const fallbackTabWidthPx = usesCheckboxRowTabFallback ? checkboxChoiceRowTabWidthPx(paragraph) : DEFAULT_TAB_STOP_PX;
   let approximateLineWidthPx = 0;
   let lastTextStyle = firstRunStyle(paragraph);
   for (let childIndex = 0; childIndex < paragraph.children.length; childIndex += 1) {
@@ -7542,7 +7929,8 @@ function buildParagraphPretextLayoutSource(paragraph, options) {
         const tabWidthPx = resolveTabSpacerWidthPx(
           tabStopPositionsPx,
           approximateLineWidthPx,
-          fallbackTabWidthPx
+          fallbackTabWidthPx,
+          usesCheckboxRowTabFallback
         );
         const spacerText = buildParagraphPretextTabSpacerText(
           tabWidthPx,
@@ -8291,10 +8679,14 @@ function updateEstimatedLineWidthPxForText(currentLineWidthPx, text, style) {
   const trailingSegment = segments[segments.length - 1] ?? "";
   return estimateTextAdvanceWidthPx(trailingSegment, style);
 }
-function resolveTabSpacerWidthPx(tabStopPositionsPx, currentLineWidthPx, fallbackWidthPx) {
+function resolveTabSpacerWidthPx(tabStopPositionsPx, currentLineWidthPx, fallbackWidthPx, fixedFallback = false) {
   const safeFallback = Math.max(12, Math.round(fallbackWidthPx));
   if (tabStopPositionsPx.length === 0) {
-    return safeFallback;
+    if (fixedFallback) {
+      return safeFallback;
+    }
+    const nextStop2 = (Math.floor((currentLineWidthPx + 0.5) / safeFallback) + 1) * safeFallback;
+    return Math.max(2, Math.round(nextStop2 - currentLineWidthPx));
   }
   const nextStop = tabStopPositionsPx.find(
     (stop) => stop > currentLineWidthPx + 0.5
@@ -9047,7 +9439,26 @@ function singleLineAutoScaleForFontFamily(fontFamily) {
   }
   return WORD_SINGLE_LINE_AUTO_SCALE;
 }
+function emptyParagraphLineScaleForFontFamily(fontFamily) {
+  const normalized = normalizeFontFamilyToken(fontFamily) ?? fontFamily?.toLowerCase();
+  if (!normalized) {
+    return WORD_EMPTY_PARAGRAPH_LINE_SCALE;
+  }
+  if (normalized === "times roman" || normalized === "times new roman" || normalized === "cambria" || normalized === "garamond" || normalized === "georgia" || normalized === "book antiqua" || normalized === "palatino linotype") {
+    return WORD_EMPTY_PARAGRAPH_LINE_SCALE_SERIF;
+  }
+  if (normalized === "arial") {
+    return WORD_EMPTY_PARAGRAPH_LINE_SCALE_SANS;
+  }
+  return WORD_EMPTY_PARAGRAPH_LINE_SCALE;
+}
+function paragraphRendersTextFreeLine(paragraph) {
+  return paragraphHasOnlyWhitespaceText(paragraph) || paragraphIsFloatingImageAnchorOnly(paragraph);
+}
 function resolveParagraphSingleLineAutoScale(paragraph, fontFamily) {
+  if (paragraphRendersTextFreeLine(paragraph)) {
+    return emptyParagraphLineScaleForFontFamily(fontFamily);
+  }
   const baseScale = singleLineAutoScaleForFontFamily(fontFamily);
   return paragraphHasCheckboxFormField(paragraph) ? Math.max(1.08, baseScale) : baseScale;
 }
@@ -9762,36 +10173,6 @@ function resolveMaxPretextLineRangeEndIndexThatFits(layout, startLineIndex, maxE
   }
   return bestEnd;
 }
-function estimateAbsoluteFloatingImageFootprintPx(paragraph, image) {
-  if (!shouldRenderAbsoluteFloatingImage(image)) {
-    return 0;
-  }
-  const floating = image.floating;
-  if (!floating) {
-    return 0;
-  }
-  const wrapType = (floating.wrapType ?? "none").trim().toLowerCase();
-  if (wrapType !== "none") {
-    return 0;
-  }
-  const behavesAsTextBearingFloatingTextBox = image.syntheticTextBox && !syntheticTextBoxContainsPictureLayer(image) && Boolean(floatingTextBoxVisibleTextFromImage(image));
-  if (behavesAsTextBearingFloatingTextBox) {
-    if (paragraphHasVisibleText2(paragraph) || paragraphHasFormField2(paragraph) || paragraphContainsSectionBreakProperties(paragraph)) {
-      return 0;
-    }
-    const imageHeightPx = Number.isFinite(image.heightPx) && image.heightPx > 0 ? Math.round(image.heightPx) : Number.isFinite(image.widthPx) && image.widthPx > 0 ? Math.round(image.widthPx) : MIN_PARAGRAPH_LINE_HEIGHT_PX;
-    const distTPx = Math.max(0, Math.round(floating.distTPx ?? 0));
-    const distBPx = Math.max(0, Math.round(floating.distBPx ?? 0));
-    return Math.max(
-      MIN_PARAGRAPH_LINE_HEIGHT_PX,
-      imageHeightPx + distTPx + distBPx
-    );
-  }
-  if (floating.behindDocument) {
-    return 0;
-  }
-  return 0;
-}
 function resolveAutoLineSpacingMultiple(lineTwips, fallbackMultiple) {
   if (!Number.isFinite(lineTwips)) {
     return Math.max(MIN_AUTO_LINE_MULTIPLE, fallbackMultiple);
@@ -9889,8 +10270,15 @@ function estimateParagraphLineHeightPx(paragraph, docGridLinePitchPx, disableDoc
       docGridMinimumLineHeightPx ?? 0
     );
   }
-  const multiple = calibrateAutoLineSpacingMultiple(
-    resolveAutoLineSpacingMultiple(lineTwips, defaultLineMultiple),
+  const resolvedAutoMultiple = resolveAutoLineSpacingMultiple(
+    lineTwips,
+    defaultLineMultiple
+  );
+  const multiple = paragraphRendersTextFreeLine(paragraph) ? Math.max(
+    MIN_AUTO_LINE_MULTIPLE,
+    Number((resolvedAutoMultiple * singleLineScale).toFixed(3))
+  ) : calibrateAutoLineSpacingMultiple(
+    resolvedAutoMultiple,
     baseFontFamily,
     singleLineScale
   );
@@ -9945,10 +10333,7 @@ function estimateParagraphHeightPx(paragraph, availableWidthPx, numberingDefinit
     numberingLabel
   );
   const absoluteFloatingAnchorOnlyParagraph = paragraphIsAbsoluteFloatingImageAnchorOnly(paragraph);
-  const sectionBreakAnchorCarryoverParagraph = paragraphIsSectionBreakAnchorCarryover(paragraph);
-  const collapsibleAbsoluteFloatingAnchorOnlyParagraph = absoluteFloatingAnchorOnlyParagraph && (!paragraphAbsoluteFloatingAnchorsDependOnParagraphFlow(paragraph) || sectionBreakAnchorCarryoverParagraph);
-  const paragraphFlowAnchoredAbsoluteFloatingAnchorOnlyParagraph = absoluteFloatingAnchorOnlyParagraph && !collapsibleAbsoluteFloatingAnchorOnlyParagraph;
-  const decorativeBehindTextAnchorOnlyParagraph = paragraphActsAsDecorativeBehindTextBackgroundOverlay(paragraph);
+  const collapsibleAbsoluteFloatingAnchorOnlyParagraph = absoluteFloatingAnchorOnlyParagraph && paragraphIsSectionBreakAnchorCarryover(paragraph);
   const inlineImageHeightPx = paragraph.children.reduce((largest, child) => {
     if (child.type !== "image") {
       return largest;
@@ -9967,27 +10352,14 @@ function estimateParagraphHeightPx(paragraph, availableWidthPx, numberingDefinit
       estimateWrappedFloatingImageFootprintPx(paragraph, child)
     );
   }, 0);
-  const absoluteFloatingImageHeightPx = paragraph.children.reduce(
-    (largest, child) => {
-      if (child.type !== "image") {
-        return largest;
-      }
-      return Math.max(
-        largest,
-        estimateAbsoluteFloatingImageFootprintPx(paragraph, child)
-      );
-    },
-    0
-  );
-  const effectiveAbsoluteFloatingImageHeightPx = collapsibleAbsoluteFloatingAnchorOnlyParagraph || decorativeBehindTextAnchorOnlyParagraph ? 0 : absoluteFloatingImageHeightPx;
-  const emptyParagraphHeightPx = decorativeBehindTextAnchorOnlyParagraph ? 0 : paragraphIsEffectivelyEmpty(paragraph) ? lineHeightPx + EMPTY_PARAGRAPH_EXTRA_HEIGHT_PX : 0;
+  const emptyParagraphHeightPx = paragraphIsEffectivelyEmpty(paragraph) ? lineHeightPx + EMPTY_PARAGRAPH_EXTRA_HEIGHT_PX : 0;
   const topBorderInsetPx = paragraphBorderInsetPx(
     paragraph.style?.borders?.top
   );
   const bottomBorderInsetPx = paragraphBorderInsetPx(
     paragraph.style?.borders?.bottom
   );
-  const textFlowHeightPx = collapsibleAbsoluteFloatingAnchorOnlyParagraph ? 0 : paragraphFlowAnchoredAbsoluteFloatingAnchorOnlyParagraph ? MIN_PARAGRAPH_LINE_HEIGHT_PX : (
+  const textFlowHeightPx = collapsibleAbsoluteFloatingAnchorOnlyParagraph ? 0 : (
     // When excluding the wrapped-float footprint, the dual-wrapped block
     // height spans the image; but the rendered paragraph only occupies its
     // text lines while the float overhangs. Use the text-line height so the
@@ -9995,11 +10367,10 @@ function estimateParagraphHeightPx(paragraph, availableWidthPx, numberingDefinit
     dualWrappedLayout && !excludeWrappedFloatingImageFootprint ? wrappedPretextParagraphBlockHeightPx(dualWrappedLayout.layout) : lineHeightPx * lineCount
   );
   const contentHeightPx = Math.max(
-    collapsibleAbsoluteFloatingAnchorOnlyParagraph || decorativeBehindTextAnchorOnlyParagraph ? 0 : paragraphFlowAnchoredAbsoluteFloatingAnchorOnlyParagraph ? MIN_PARAGRAPH_LINE_HEIGHT_PX : lineHeightPx,
+    collapsibleAbsoluteFloatingAnchorOnlyParagraph ? 0 : lineHeightPx,
     textFlowHeightPx,
     inlineImageHeightPx,
     wrappedFloatingImageHeightPx,
-    effectiveAbsoluteFloatingImageHeightPx,
     emptyParagraphHeightPx
   );
   if (excludeWrappedFloatingImageFootprint && paragraph.children.some((c) => c.type === "image")) {
@@ -11260,6 +11631,7 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
   let previousParagraphAfterPx = 0;
   let currentMetricsIndex = 0;
   let currentSectionPageFlowOriginPx = 0;
+  let committedKeepNextChainEndNodeIndex = -1;
   let currentPageContentHeightPx = resolveMetricsPageContentHeightPx(
     0,
     metricsBySection[0]
@@ -11318,56 +11690,14 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
       previousParagraphAfterPx = 0;
       continue;
     }
-    if (node.type === "paragraph" && paragraphActsAsLeadingCoverLayoutPreambleSpacer(
-      model,
-      nodeIndex,
-      node,
-      nodeMetrics.pageContentWidthPx,
-      nodeMetrics.pageContentHeightPx
-    )) {
-      previousParagraphAfterPx = 0;
-      continue;
-    }
     if (node.type === "paragraph" && paragraphActsAsTrailingRenderedPageBreakSpacer(model, nodeIndex, node)) {
       previousParagraphAfterPx = 0;
       continue;
     }
-    if (node.type === "paragraph" && paragraphActsAsLeadingCoverLayoutOverlay(
-      model,
-      nodeIndex,
-      node,
-      nodeMetrics.pageContentWidthPx,
-      nodeMetrics.pageContentHeightPx
-    )) {
-      currentPageSegments.push({ nodeIndex });
-      previousParagraphAfterPx = 0;
-      continue;
-    }
-    if (node.type === "paragraph" && paragraphActsAsDecorativeBehindTextBackgroundOverlay(node)) {
-      currentPageSegments.push({ nodeIndex });
-      previousParagraphAfterPx = 0;
-      continue;
-    }
     if (node.type === "paragraph" && paragraphCollapsesIntoPreviousParagraph(node, model.nodes[nodeIndex - 1])) {
       continue;
     }
     if (node.type === "paragraph") {
-      if (paragraphStartsNewPageAfterLeadingCoverLayout(
-        model,
-        nodeIndex,
-        node,
-        nodeMetrics.pageContentWidthPx,
-        nodeMetrics.pageContentHeightPx
-      ) && currentPageSegments.length > 0) {
-        startNextPage();
-        pageConsumedHeightPx = 0;
-        previousParagraphAfterPx = 0;
-        currentSectionPageFlowOriginPx = 0;
-        currentPageContentHeightPx = resolveMetricsPageContentHeightPx(
-          currentPageIndex,
-          nodeMetrics
-        );
-      }
       if (paragraphHasPageBreakBefore2(node) && currentPageSegments.length > 0) {
         startNextPage();
         pageConsumedHeightPx = 0;
@@ -11451,18 +11781,12 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
         1,
         estimatedOrMeasuredHeightPx - directBeforeSpacingPx - directAfterSpacingPx + beforeSpacingPx + afterSpacingPx
       );
-      const coverFootprintPx = paragraphLikelyFullPageCoverFootprintPx(
-        model,
-        nodeIndex,
-        node,
-        nodeMetrics.pageContentWidthPx,
-        nodeMetrics.pageContentHeightPx
-      );
-      const paragraphTooTallForSinglePage = Math.max(rawNodeHeightPx, coverFootprintPx) > nodeMetrics.pageContentHeightPx + PAGE_OVERFLOW_TOLERANCE_PX;
+      const paragraphTooTallForSinglePage = rawNodeHeightPx > nodeMetrics.pageContentHeightPx + PAGE_OVERFLOW_TOLERANCE_PX;
       const keepLinesOverflowSplit = node.style?.keepLines === true && paragraphTooTallForSinglePage;
       const keepNextOverflowSplit = node.style?.keepNext === true && paragraphTooTallForSinglePage;
       const forceOverflowSplit = keepLinesOverflowSplit || keepNextOverflowSplit;
-      if (forceOverflowSplit && pageConsumedHeightPx > 0 && currentPageSegments.length > 0) {
+      const nodeIsWithinCommittedKeepNextChain = nodeIndex <= committedKeepNextChainEndNodeIndex;
+      if (forceOverflowSplit && !nodeIsWithinCommittedKeepNextChain && pageConsumedHeightPx > 0 && currentPageSegments.length > 0) {
         startNextPage();
         pageConsumedHeightPx = 0;
         previousParagraphAfterPx = 0;
@@ -11475,7 +11799,7 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
       const collapsedMarginPx = pageConsumedHeightPx > 0 ? Math.min(previousParagraphAfterPx, beforeSpacingPx) : 0;
       const collapsedNodeHeightPx = Math.max(
         1,
-        Math.max(rawNodeHeightPx, coverFootprintPx) - collapsedMarginPx
+        rawNodeHeightPx - collapsedMarginPx
       );
       const paragraphSupportsPretextSegmentRendering = Boolean(
         paragraphPretextSourceForSegmentRendering
@@ -11501,7 +11825,7 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
       }
       const collapsedNodeHeightPxAdjusted = Math.max(
         1,
-        Math.max(rawNodeHeightPx, coverFootprintPx) - collapsedMarginPx
+        rawNodeHeightPx - collapsedMarginPx
       );
       const paragraphPretextLineCount = paragraphContainsExplicitLineBreakText(node) || paragraphContainsTabCharacter(node) ? resolveParagraphPretextLayoutForSegmentRendering()?.lineCount : void 0;
       const supportsImageParagraphLineSplit = paragraphHasImage2(node) && paragraphSupportsPretextSegmentRendering;
@@ -11725,7 +12049,8 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
         continue;
       }
       let requiredHeightPx = collapsedNodeHeightPxAdjusted;
-      if (node.style?.keepNext === true && paragraphHasVisibleText2(node)) {
+      let keepNextChainEndNodeIndex = -1;
+      if (node.style?.keepNext === true && !nodeIsWithinCommittedKeepNextChain && paragraphHasVisibleText2(node)) {
         let chainCursor = nodeIndex;
         let chainPreviousParagraphAfterPx = afterSpacingPx;
         while (chainCursor < model.nodes.length - 1) {
@@ -11785,6 +12110,7 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
           );
           chainPreviousParagraphAfterPx = nextAfterSpacingPx;
         }
+        keepNextChainEndNodeIndex = chainCursor;
       }
       const remainingHeightPx = currentPageContentHeightPx - pageConsumedHeightPx;
       const canKeepTrailingSectionTailOnCurrentPage = shouldKeepTrailingSectionTailOnCurrentPage(
@@ -11826,11 +12152,11 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
           nodeMetrics
         );
       }
+      if (pageConsumedHeightPx === 0 && keepNextChainEndNodeIndex > nodeIndex) {
+        committedKeepNextChainEndNodeIndex = keepNextChainEndNodeIndex;
+      }
       currentPageSegments.push({ nodeIndex });
-      const effectiveNodeHeightPx = Math.max(
-        pageConsumedHeightPx > 0 ? collapsedNodeHeightPx : rawNodeHeightPx,
-        coverFootprintPx
-      );
+      const effectiveNodeHeightPx = pageConsumedHeightPx > 0 ? collapsedNodeHeightPx : rawNodeHeightPx;
       pageConsumedHeightPx += effectiveNodeHeightPx;
       previousParagraphAfterPx = afterSpacingPx;
       continue;
@@ -12637,11 +12963,15 @@ function paragraphLineHeight(paragraph, docGridLinePitchPx, disableDocGridSnap =
         disableDocGridSnap
       )}px`;
     }
-    const lineMultiple = calibrateAutoLineSpacingMultiple(
-      resolveAutoLineSpacingMultiple(
-        lineTwips,
-        DEFAULT_PARAGRAPH_LINE_MULTIPLE
-      ),
+    const resolvedAutoMultiple = resolveAutoLineSpacingMultiple(
+      lineTwips,
+      DEFAULT_PARAGRAPH_LINE_MULTIPLE
+    );
+    const lineMultiple = paragraphRendersTextFreeLine(paragraph) ? Math.max(
+      MIN_AUTO_LINE_MULTIPLE,
+      Number((resolvedAutoMultiple * singleLineScale).toFixed(3))
+    ) : calibrateAutoLineSpacingMultiple(
+      resolvedAutoMultiple,
       baseFontFamily,
       singleLineScale
     );
@@ -12984,9 +13314,7 @@ function paragraphBlockStyle(paragraph, numberingDefinitions, headingStyles, doc
   const suppressTocNumberingTextIndent = isTableOfContentsParagraph(paragraph) && paragraphHasNumbering(paragraph);
   const suppressIndentForFloatingAnchorOnlyParagraph = paragraphIsFloatingImageAnchorOnly(paragraph);
   const suppressStackingContextForBehindTextAnchorOnlyParagraph = paragraphIsBehindTextAbsoluteFloatingImageAnchorOnly(paragraph);
-  const suppressFlowFootprintForBehindTextAnchorOnlyParagraph = paragraphActsAsDecorativeBehindTextBackgroundOverlay(paragraph);
-  const textBearingAbsoluteFloatingTextBoxFootprintPx = paragraphTextBearingAbsoluteFloatingTextBoxFootprintPx(paragraph);
-  const reservedMinHeightPx = suppressFlowFootprintForBehindTextAnchorOnlyParagraph ? void 0 : textBearingAbsoluteFloatingTextBoxFootprintPx > 0 ? textBearingAbsoluteFloatingTextBoxFootprintPx : paragraphIsEffectivelyEmpty(paragraph) ? estimateParagraphLineHeightPx(
+  const reservedMinHeightPx = paragraphIsEffectivelyEmpty(paragraph) ? estimateParagraphLineHeightPx(
     paragraph,
     docGridLinePitchPx,
     disableDocGridSnap
@@ -13005,15 +13333,13 @@ function paragraphBlockStyle(paragraph, numberingDefinitions, headingStyles, doc
     // line-box strut tracks the actual content instead of the browser's
     // 16px default, which inflates lines for sub-12pt paragraphs.
     fontSize: `${paragraphBaseFontSizePx(paragraph)}px`,
-    lineHeight: suppressFlowFootprintForBehindTextAnchorOnlyParagraph ? 0 : paragraphLineHeight(paragraph, docGridLinePitchPx, disableDocGridSnap),
-    ...suppressFlowFootprintForBehindTextAnchorOnlyParagraph ? {
-      height: 0,
-      marginTop: 0,
-      marginBottom: 0
-    } : {
-      marginTop: beforeSpacing,
-      marginBottom: afterSpacing
-    },
+    lineHeight: paragraphLineHeight(
+      paragraph,
+      docGridLinePitchPx,
+      disableDocGridSnap
+    ),
+    marginTop: beforeSpacing,
+    marginBottom: afterSpacing,
     marginLeft: suppressIndentForFloatingAnchorOnlyParagraph ? 0 : leftIndent,
     marginRight: suppressIndentForFloatingAnchorOnlyParagraph ? 0 : rightIndent,
     backgroundColor: paragraph.style?.backgroundColor,
@@ -14744,7 +15070,8 @@ function renderParagraphRuns(paragraph, keyPrefix, documentTheme = "light", numb
   const resolveNextTabWidthPx = () => resolveTabSpacerWidthPx(
     tabStopPositionsPx,
     approximateLineWidthPx,
-    fallbackTabWidthPx
+    fallbackTabWidthPx,
+    checkboxChoiceRow
   );
   const appendPlainTextWithSoftBreakControl = (target, keySeed, text, style, measureStyle) => {
     const shouldControlSoftBreakStretch = paragraph.style?.align === "justify" && text.includes("\n");
@@ -22822,12 +23149,32 @@ function ensureDocxViewerPageSurfaceRegistry(editor) {
   if (!registry) {
     registry = {
       pageElements: /* @__PURE__ */ new Map(),
+      pageContentKeys: /* @__PURE__ */ new Map(),
       listeners: /* @__PURE__ */ new Set()
     };
     docxViewerPageSurfaceRegistryByEditor.set(owner, registry);
   }
   return registry;
 }
+function syncDocxViewerPageSurfaceContentKeys(editor, contentKeysByPage) {
+  const registry = ensureDocxViewerPageSurfaceRegistry(editor);
+  let changed = false;
+  contentKeysByPage.forEach((contentKey, pageIndex) => {
+    if (registry.pageContentKeys.get(pageIndex) !== contentKey) {
+      registry.pageContentKeys.set(pageIndex, contentKey);
+      changed = true;
+    }
+  });
+  registry.pageContentKeys.forEach((_, pageIndex) => {
+    if (pageIndex >= contentKeysByPage.length) {
+      registry.pageContentKeys.delete(pageIndex);
+      changed = true;
+    }
+  });
+  if (changed) {
+    notifyDocxViewerPageSurfaceSubscribers(registry);
+  }
+}
 function subscribeDocxViewerPageSurfaces(editor, listener) {
   const registry = ensureDocxViewerPageSurfaceRegistry(editor);
   registry.listeners.add(listener);
@@ -22891,62 +23238,8 @@ function resolveDocxViewerPageSurfaceSize(element, fallbackWidthPx, fallbackHeig
     heightPx: Math.max(1, Math.round(fallbackHeightPx))
   };
 }
-async function rasterizeDocxViewerPageSurfaceToCanvas(params) {
-  if (typeof window === "undefined" || typeof XMLSerializer === "undefined") {
-    throw new Error("DOCX thumbnails require a browser environment.");
-  }
-  const {
-    pageElement,
-    sourceWidthPx,
-    sourceHeightPx,
-    canvas,
-    widthPx,
-    heightPx,
-    pixelWidthPx,
-    pixelHeightPx
-  } = params;
-  const safeSourceWidthPx = Math.max(1, Math.round(sourceWidthPx));
-  const safeSourceHeightPx = Math.max(1, Math.round(sourceHeightPx));
-  const scaleX = widthPx / safeSourceWidthPx;
-  const scaleY = heightPx / safeSourceHeightPx;
-  const serializedPage = new XMLSerializer().serializeToString(
-    pageElement.cloneNode(true)
-  );
-  const svgMarkup = `
-    <svg xmlns="http://www.w3.org/2000/svg" width="${widthPx}" height="${heightPx}" viewBox="0 0 ${widthPx} ${heightPx}">
-      <foreignObject x="0" y="0" width="100%" height="100%">
-        <div xmlns="http://www.w3.org/1999/xhtml" style="width:${widthPx}px;height:${heightPx}px;overflow:hidden;">
-          <div style="width:${safeSourceWidthPx}px;height:${safeSourceHeightPx}px;transform-origin:top left;transform:scale(${scaleX}, ${scaleY});">
-            ${serializedPage}
-          </div>
-        </div>
-      </foreignObject>
-    </svg>
-  `;
-  const svgDataUrl = svgDataUri(svgMarkup);
-  const image = await new Promise((resolve, reject) => {
-    const nextImage = new Image();
-    nextImage.decoding = "async";
-    nextImage.onload = () => resolve(nextImage);
-    nextImage.onerror = () => {
-      reject(new Error("Failed to rasterize DOCX page thumbnail."));
-    };
-    nextImage.src = svgDataUrl;
-  });
-  canvas.width = Math.max(1, Math.round(pixelWidthPx));
-  canvas.height = Math.max(1, Math.round(pixelHeightPx));
-  canvas.style.width = `${Math.max(1, Math.round(widthPx))}px`;
-  canvas.style.height = `${Math.max(1, Math.round(heightPx))}px`;
-  const context = canvas.getContext("2d");
-  if (!context) {
-    throw new Error("2D canvas context is unavailable for DOCX thumbnails.");
-  }
-  context.setTransform(1, 0, 0, 1, 0, 0);
-  context.clearRect(0, 0, canvas.width, canvas.height);
-  context.imageSmoothingEnabled = true;
-  context.imageSmoothingQuality = "high";
-  context.drawImage(image, 0, 0, canvas.width, canvas.height);
-}
+var DOCX_THUMBNAIL_SURFACE_CACHE_MAX_ENTRIES = 32;
+var DOCX_THUMBNAIL_MIN_RASTER_INTERVAL_MS = 200;
 function resolveDocxPageThumbnailResolution(options) {
   const safeSourceWidthPx = Math.max(1, Math.round(options.sourceWidthPx));
   const safeSourceHeightPx = Math.max(1, Math.round(options.sourceHeightPx));
@@ -23020,8 +23313,51 @@ function useDocxPageThumbnails(editor, options = {}) {
     },
     []
   );
+  const thumbnailSurfaceCacheRef = React.useRef(void 0);
+  const thumbnailRasterQueueRef = React.useRef(void 0);
+  const lastPaintedThumbnailKeyByCanvasRef = React.useRef(
+    /* @__PURE__ */ new WeakMap()
+  );
+  const ensureThumbnailSurfaceCache = React.useCallback(() => {
+    if (!thumbnailSurfaceCacheRef.current) {
+      thumbnailSurfaceCacheRef.current = new DocxThumbnailSurfaceCache(
+        DOCX_THUMBNAIL_SURFACE_CACHE_MAX_ENTRIES
+      );
+    }
+    return thumbnailSurfaceCacheRef.current;
+  }, []);
+  const ensureThumbnailRasterQueue = React.useCallback(() => {
+    if (!thumbnailRasterQueueRef.current) {
+      thumbnailRasterQueueRef.current = new SerialIdleTaskQueue({
+        minTaskIntervalMs: DOCX_THUMBNAIL_MIN_RASTER_INTERVAL_MS
+      });
+    }
+    return thumbnailRasterQueueRef.current;
+  }, []);
+  React.useEffect(() => {
+    thumbnailSurfaceCacheRef.current?.clear();
+    thumbnailRasterQueueRef.current?.clear();
+    lastPaintedThumbnailKeyByCanvasRef.current = /* @__PURE__ */ new WeakMap();
+  }, [editor.documentLoadNonce, pageSurfaceRegistryOwner]);
+  const thumbnailResolutionOptionsKey = React.useMemo(() => {
+    const bounds = options.resolution;
+    const boundsKey = typeof bounds === "number" ? `n${bounds}` : bounds ? `b${bounds.maxWidth ?? ""}x${bounds.maxHeight ?? ""}` : "";
+    return `${boundsKey}|${options.maxWidthPx ?? ""}|${options.maxHeightPx ?? ""}|${options.pixelRatio ?? ""}`;
+  }, [
+    options.maxHeightPx,
+    options.maxWidthPx,
+    options.pixelRatio,
+    options.resolution
+  ]);
+  const thumbnailSkipKeyForPage = React.useCallback(
+    (pageIndex) => {
+      const contentKey = pageSurfaceRegistry.pageContentKeys.get(pageIndex);
+      return contentKey === void 0 ? void 0 : `${contentKey}|${editor.documentTheme}|${thumbnailResolutionOptionsKey}`;
+    },
+    [editor.documentTheme, pageSurfaceRegistry, thumbnailResolutionOptionsKey]
+  );
   const renderPageThumbnailToCanvas = React.useCallback(
-    async (pageIndex, canvas) => {
+    async (pageIndex, canvas, renderOptions) => {
       if (options.disabled) {
         return;
       }
@@ -23029,63 +23365,101 @@ function useDocxPageThumbnails(editor, options = {}) {
       if (!targetCanvas) {
         return;
       }
-      const pageElement = mountedPageElements.get(pageIndex);
+      const pageElement = pageSurfaceRegistry.pageElements.get(pageIndex);
       if (!pageElement || !pageElement.isConnected) {
         updatePageThumbnailState(pageIndex, "unavailable");
         return;
       }
-      const sourceSize = resolveDocxViewerPageSurfaceSize(
-        pageElement,
-        fallbackLayout.pageWidthPx,
-        fallbackLayout.pageHeightPx
-      );
-      const resolution = resolveDocxPageThumbnailResolution({
-        sourceWidthPx: sourceSize.widthPx,
-        sourceHeightPx: sourceSize.heightPx,
-        resolution: options.resolution,
-        maxWidthPx: options.maxWidthPx,
-        maxHeightPx: options.maxHeightPx,
-        pixelRatio: options.pixelRatio
-      });
+      const force = renderOptions?.force === true;
+      const lastPaintedKey = lastPaintedThumbnailKeyByCanvasRef.current.get(targetCanvas);
+      if (!force && lastPaintedKey !== void 0 && lastPaintedKey === thumbnailSkipKeyForPage(pageIndex)) {
+        updatePageThumbnailState(pageIndex, "ready");
+        return;
+      }
       updatePageThumbnailState(pageIndex, "rendering");
-      try {
-        await rasterizeDocxViewerPageSurfaceToCanvas({
-          pageElement,
+      await ensureThumbnailRasterQueue().enqueue(targetCanvas, async () => {
+        const livePageElement = pageSurfaceRegistry.pageElements.get(pageIndex);
+        if (!livePageElement || !livePageElement.isConnected) {
+          updatePageThumbnailState(pageIndex, "unavailable");
+          return;
+        }
+        const runSkipKey = thumbnailSkipKeyForPage(pageIndex);
+        const sourceSize = resolveDocxViewerPageSurfaceSize(
+          livePageElement,
+          fallbackLayout.pageWidthPx,
+          fallbackLayout.pageHeightPx
+        );
+        const resolution = resolveDocxPageThumbnailResolution({
           sourceWidthPx: sourceSize.widthPx,
           sourceHeightPx: sourceSize.heightPx,
-          canvas: targetCanvas,
-          widthPx: resolution.widthPx,
-          heightPx: resolution.heightPx,
-          pixelWidthPx: resolution.pixelWidthPx,
-          pixelHeightPx: resolution.pixelHeightPx
+          resolution: options.resolution,
+          maxWidthPx: options.maxWidthPx,
+          maxHeightPx: options.maxHeightPx,
+          pixelRatio: options.pixelRatio
         });
-        updatePageThumbnailState(pageIndex, "ready");
-      } catch (error) {
-        updatePageThumbnailState(
-          pageIndex,
-          "error",
-          error instanceof Error ? error : new Error("Failed to render DOCX page thumbnail.")
-        );
-      }
+        const surfaceKey = runSkipKey === void 0 ? void 0 : `${runSkipKey}|${sourceSize.widthPx}x${sourceSize.heightPx}|${resolution.pixelWidthPx}x${resolution.pixelHeightPx}`;
+        const surfaceCache = ensureThumbnailSurfaceCache();
+        try {
+          let surface = !force && surfaceKey !== void 0 ? surfaceCache.get(surfaceKey) : void 0;
+          if (!surface) {
+            surface = await rasterizeDocxThumbnailSurface({
+              pageElement: livePageElement,
+              sourceWidthPx: sourceSize.widthPx,
+              sourceHeightPx: sourceSize.heightPx,
+              widthPx: resolution.widthPx,
+              heightPx: resolution.heightPx,
+              pixelWidthPx: resolution.pixelWidthPx,
+              pixelHeightPx: resolution.pixelHeightPx
+            });
+            if (surfaceKey !== void 0) {
+              surfaceCache.set(surfaceKey, surface);
+            }
+          }
+          blitDocxThumbnailSurface(surface, targetCanvas, resolution);
+          if (runSkipKey !== void 0) {
+            lastPaintedThumbnailKeyByCanvasRef.current.set(
+              targetCanvas,
+              runSkipKey
+            );
+          }
+          updatePageThumbnailState(pageIndex, "ready");
+        } catch (error) {
+          updatePageThumbnailState(
+            pageIndex,
+            "error",
+            error instanceof Error ? error : new Error("Failed to render DOCX page thumbnail.")
+          );
+        }
+      });
     },
     [
+      ensureThumbnailRasterQueue,
+      ensureThumbnailSurfaceCache,
       fallbackLayout.pageHeightPx,
       fallbackLayout.pageWidthPx,
-      mountedPageElements,
       options.disabled,
       options.resolution,
       options.maxHeightPx,
       options.maxWidthPx,
       options.pixelRatio,
+      pageSurfaceRegistry,
+      thumbnailSkipKeyForPage,
       updatePageThumbnailState
     ]
   );
-  const rerenderAttachedThumbnails = React.useCallback(async () => {
-    const tasks = [...attachedCanvasByPageRef.current.keys()].map(
-      (pageIndex) => renderPageThumbnailToCanvas(pageIndex)
-    );
-    await Promise.all(tasks);
-  }, [renderPageThumbnailToCanvas]);
+  const requestAttachedThumbnailRenders = React.useCallback(
+    async (renderOptions) => {
+      const tasks = [...attachedCanvasByPageRef.current.keys()].map(
+        (pageIndex) => renderPageThumbnailToCanvas(pageIndex, void 0, renderOptions)
+      );
+      await Promise.all(tasks);
+    },
+    [renderPageThumbnailToCanvas]
+  );
+  const rerenderAttachedThumbnails = React.useCallback(
+    async () => requestAttachedThumbnailRenders({ force: true }),
+    [requestAttachedThumbnailRenders]
+  );
   const renderPageThumbnailToCanvasRef = React.useRef(
     renderPageThumbnailToCanvas
   );
@@ -23097,7 +23471,7 @@ function useDocxPageThumbnails(editor, options = {}) {
     renderToCanvasCallbacksRef.current.clear();
   }, [pageSurfaceRegistryOwner]);
   React.useEffect(() => {
-    void rerenderAttachedThumbnails();
+    void requestAttachedThumbnailRenders();
   }, [
     editor.documentLoadNonce,
     editor.documentTheme,
@@ -23108,7 +23482,7 @@ function useDocxPageThumbnails(editor, options = {}) {
     options.maxHeightPx,
     options.maxWidthPx,
     options.pixelRatio,
-    rerenderAttachedThumbnails
+    requestAttachedThumbnailRenders
   ]);
   const thumbnails = React.useMemo(() => {
     const totalPages = Math.max(1, editor.totalPages);
@@ -25498,6 +25872,42 @@ function DocxEditorViewer({
     pageNodeSegmentsByPage,
     primarySectionPropertiesXml
   ]);
+  const pageThumbnailContentKeysByPage = React.useMemo(() => {
+    const metadataSignature = docModelThumbnailMetadataSignature(
+      editor.model.metadata
+    );
+    return pageNodeSegmentsByPage.map((pageSegments, pageIndex) => {
+      const sectionInfo = pageSectionInfoByIndex[pageIndex];
+      let nodeSignatures = "";
+      for (const segment of pageSegments) {
+        nodeSignatures += docNodeContentSignature(
+          editor.model.nodes[segment.nodeIndex]
+        );
+        nodeSignatures += ",";
+      }
+      return [
+        editor.documentLoadNonce,
+        trackedChangesEnabled ? "tc1" : "tc0",
+        metadataSignature,
+        sectionInfo ? `${sectionInfo.sectionIndex}.${sectionInfo.pageNumber}` : "s?",
+        pageNodeSegmentIdentityKeysByPage[pageIndex] ?? "",
+        nodeSignatures
+      ].join("|");
+    });
+  }, [
+    editor.documentLoadNonce,
+    editor.model,
+    pageNodeSegmentIdentityKeysByPage,
+    pageNodeSegmentsByPage,
+    pageSectionInfoByIndex,
+    trackedChangesEnabled
+  ]);
+  React.useEffect(() => {
+    syncDocxViewerPageSurfaceContentKeys(
+      editor,
+      pageThumbnailContentKeysByPage
+    );
+  }, [pageSurfaceRegistryOwner, pageThumbnailContentKeysByPage]);
   const resolveStyleRefFieldValueForPage = React.useMemo(() => {
     const valueCache = /* @__PURE__ */ new Map();
     const nodes = editor.model.nodes;
@@ -25756,6 +26166,14 @@ function DocxEditorViewer({
     overscan: pageVirtualizationOverscan
   });
   const internalPageVirtualizer = internalVirtualScrollUsesWindow ? internalWindowPageVirtualizer : internalElementPageVirtualizer;
+  React.useLayoutEffect(() => {
+    internalElementPageVirtualizer.measure();
+    internalWindowPageVirtualizer.measure();
+  }, [
+    estimateVirtualPageSize,
+    internalElementPageVirtualizer,
+    internalWindowPageVirtualizer
+  ]);
   const internalVirtualItems = internalPageVirtualizer.getVirtualItems();
   const internalVisiblePageRange = React.useMemo(() => {
     if (!internalPageVirtualizationEnabled) {
@@ -25798,8 +26216,8 @@ function DocxEditorViewer({
       return internalVisiblePageRange;
     }
     const scrollDirection = internalPageVirtualizer.scrollDirection;
-    const renderPreviousPage = scrollDirection !== "backward";
-    const renderNextPage = scrollDirection === "backward";
+    const renderPreviousPage = scrollDirection !== "forward";
+    const renderNextPage = scrollDirection !== "backward";
     const startPageIndex = clampNumber(
       internalVisiblePageRange.startPageIndex - (renderPreviousPage ? LARGE_TABLE_PAGE_ADJACENT_RENDER_COUNT : 0),
       0,
@@ -33214,6 +33632,7 @@ function DocxEditorViewer({
                   "span",
                   {
                     contentEditable: false,
+                    ...{ [DOCX_THUMBNAIL_EXCLUDE_ATTRIBUTE]: "true" },
                     style: {
                       position: "absolute",
                       left: rect.left,
@@ -33236,6 +33655,7 @@ function DocxEditorViewer({
                   "span",
                   {
                     contentEditable: false,
+                    ...{ [DOCX_THUMBNAIL_EXCLUDE_ATTRIBUTE]: "true" },
                     style: {
                       position: "absolute",
                       left: caretRect.left,
@@ -33605,7 +34025,10 @@ function DocxEditorViewer({
         Math.round(options?.pageFlowTopPx ?? 0)
       );
       const bodyParagraphOriginLeftPx = interactiveBodyFloatingPageOriginPx ? paragraphPageLayout.marginsPx.left : void 0;
-      const bodyParagraphOriginTopPx = interactiveBodyFloatingPageOriginPx ? paragraphPageLayout.marginsPx.top + paragraphPageFlowTopPx : void 0;
+      const bodyParagraphOriginTopPx = interactiveBodyFloatingPageOriginPx ? paragraphActsAsPageAnchoredCoverOverlayHost(
+        paragraph,
+        paragraphPageLayout
+      ) ? paragraphPageLayout.marginsPx.top + paragraphPageFlowTopPx : 0 : void 0;
       const resizedWidthPxByImageIndex = /* @__PURE__ */ new Map();
       const resizedHeightPxByImageIndex = /* @__PURE__ */ new Map();
       const movePreviewByImageIndex = /* @__PURE__ */ new Map();
@@ -36439,13 +36862,6 @@ function DocxEditorViewer({
           options?.pageFlowForeignExclusions ?? []
         )
       );
-      const leadingCoverLayoutSpacer = paragraphActsAsLeadingCoverLayoutSpacer(
-        editor.model,
-        nodeIndex,
-        node,
-        paragraphContentWidthPx,
-        resolvedPageLayout.pageHeightPx - resolvedPageLayout.marginsPx.top - resolvedPageLayout.marginsPx.bottom
-      );
       const beforeSpacingPx = effectiveParagraphBeforeSpacingPx(
         editor.model,
         nodeIndex,
@@ -36499,14 +36915,12 @@ function DocxEditorViewer({
           marginTop: (typeof baseParagraphStyle.marginTop === "number" ? baseParagraphStyle.marginTop : 0) - (pageAnchoredCoverOverlayParagraph ? resolvedPageLayout.marginsPx.top : 0),
           marginLeft: -resolvedPageLayout.marginsPx.left,
           marginRight: -resolvedPageLayout.marginsPx.right,
-          minHeight: 0,
-          height: 0,
-          lineHeight: 0,
+          // A cover-overlay host is remapped to the page surface and must
+          // not displace flow; an ordinary anchor host still occupies its
+          // one-line paragraph box (Word semantics).
+          ...pageAnchoredCoverOverlayParagraph ? { minHeight: 0, height: 0, lineHeight: 0 } : void 0,
           overflow: "visible"
         } : requiresPageAbsoluteContext ? { position: "static" } : requiresLocalAbsoluteContext ? { position: "relative" } : hasDualWrappedFloatingImage ? { position: "relative" } : void 0,
-        ...leadingCoverLayoutSpacer ? {
-          minHeight: `${estimateParagraphLineHeightPx(node, nodeDocGridLinePitchPx) + EMPTY_PARAGRAPH_EXTRA_HEIGHT_PX + LEADING_COVER_SPACER_EXTRA_HEIGHT_PX}px`
-        } : void 0,
         // Carry the paragraph's run font on the editable host so text typed into
         // it (which is a bare, not-yet-committed text node, not a styled run
         // span) renders in the same font the committed run will use — i.e. the
@@ -37541,6 +37955,22 @@ ${currentText.slice(end)}`;
                           const rowSpanValue = cell.style?.rowSpan && cell.style.rowSpan > 1 ? cell.style.rowSpan : 1;
                           const colSpan = colSpanValue > 1 ? colSpanValue : void 0;
                           const rowSpan = rowSpanValue > 1 ? rowSpanValue : void 0;
+                          const exactRowSpanRows = node.rows.slice(
+                            rowIndex,
+                            rowIndex + rowSpanValue
+                          );
+                          const exactRowSpanClipHeightPx = exactRowSpanRows.length > 0 && exactRowSpanRows.every((spannedRow, rowOffset) => {
+                            const spannedHeightPx = rowHeightsPx[rowIndex + rowOffset];
+                            return spannedRow.style?.heightRule === "exact" && Number.isFinite(spannedHeightPx) && spannedHeightPx > 0;
+                          }) ? exactRowSpanRows.reduce(
+                            (sum, _spannedRow, rowOffset) => sum + Math.max(
+                              MIN_PARAGRAPH_LINE_HEIGHT_PX,
+                              Math.round(
+                                rowHeightsPx[rowIndex + rowOffset]
+                              )
+                            ),
+                            0
+                          ) : void 0;
                           const startColumnIndex = columnCursor;
                           const boundaryColumnIndex = startColumnIndex + colSpanValue - 1;
                           columnCursor += colSpanValue;
@@ -38659,12 +39089,11 @@ ${currentText.slice(end)}`;
                                   style: {
                                     display: "grid",
                                     gap: 0,
-                                    // Word clips content of hRule="exact" rows
-                                    // at the declared height; without this the
-                                    // row balloons to fit content (height on a
-                                    // <tr>/<td> is only ever a minimum).
-                                    ...row.style?.heightRule === "exact" && !isSlicedRow && resolvedRowHeightStyle?.height ? {
-                                      maxHeight: resolvedRowHeightStyle.height,
+                                    // Without the clip the row balloons to fit
+                                    // content (height on a <tr>/<td> is only
+                                    // ever a minimum).
+                                    ...exactRowSpanClipHeightPx !== void 0 && !isSlicedRow ? {
+                                      maxHeight: `${exactRowSpanClipHeightPx}px`,
                                       overflow: "hidden"
                                     } : void 0
                                   },
@@ -40451,11 +40880,27 @@ ${currentText.slice(end)}`;
                                   currentGroup.segments.push(segment);
                                   return;
                                 }
+                                if (currentGroup && parseSectionStartType(
+                                  documentSections[currentSectionIndex]?.sectionPropertiesXml
+                                ) === "nextcolumn") {
+                                  const previousColumns = sectionColumnsBySectionIndex[currentGroup.sectionIndex];
+                                  const nextColumns = sectionColumnsBySectionIndex[currentSectionIndex];
+                                  const sameGeometry = previousColumns && nextColumns && previousColumns.count === nextColumns.count && Math.abs(
+                                    previousColumns.gapPx - nextColumns.gapPx
+                                  ) <= 2 && JSON.stringify(previousColumns.widthsPx ?? null) === JSON.stringify(nextColumns.widthsPx ?? null);
+                                  if (sameGeometry) {
+                                    currentGroup.segments.push(segment);
+                                    return;
+                                  }
+                                }
                                 sectionGroups.push({
                                   sectionIndex: currentSectionIndex,
                                   segments: [segment]
                                 });
                               });
+                              if (typeof window !== "undefined" && window.__docxDebugGroups) {
+                                console.log("[groups]", pageIndex, JSON.stringify(sectionGroups.map((g) => ({ s: g.sectionIndex, n: g.segments.map((x) => x.nodeIndex) }))));
+                              }
                               return sectionGroups.map((group, groupIndex) => {
                                 const sectionColumns = sectionColumnsBySectionIndex[group.sectionIndex];
                                 const isLastGroupOnPage = groupIndex === sectionGroups.length - 1;
@@ -40624,7 +41069,7 @@ ${currentText.slice(end)}`;
                                           (editor.model.metadata.sections ?? []).filter(
                                             (candidate) => parseSectionStartType(
                                               candidate.sectionPropertiesXml
-                                            ) === "nextColumn"
+                                            ) === "nextcolumn"
                                           ).map(
                                             (candidate) => Math.max(
                                               0,
@@ -42542,6 +42987,7 @@ function collectDocxEstimatedOverflowBreakStartNodeIndexes(model, hardBreakStart
   let pageConsumedHeightPx = 0;
   let previousParagraphAfterPx = 0;
   let currentMetricsIndex = 0;
+  let committedKeepNextChainEndNodeIndex = -1;
   const suppressSpacingBeforeAfterPageBreak = options?.suppressSpacingBeforeAfterPageBreak ?? false;
   let currentPageContentHeightPx = metricsBySection[0]?.pageContentHeightPx ?? fallbackMetrics.pageContentHeightPx;
   for (let nodeIndex = 0; nodeIndex < model.nodes.length; nodeIndex += 1) {
@@ -42579,7 +43025,8 @@ function collectDocxEstimatedOverflowBreakStartNodeIndexes(model, hardBreakStart
     const collapsedMarginPx = node.type === "paragraph" && pageConsumedHeightPx > 0 ? Math.min(previousParagraphAfterPx, nodeBeforeSpacingPx) : 0;
     const collapsedNodeHeightPx = Math.max(1, rawNodeHeightPx - collapsedMarginPx);
     let requiredHeightPx = collapsedNodeHeightPx;
-    if (node.type === "paragraph" && node.style?.keepNext === true && callbacks.paragraphHasVisibleText(node)) {
+    let keepNextChainEndNodeIndex = -1;
+    if (node.type === "paragraph" && node.style?.keepNext === true && nodeIndex > committedKeepNextChainEndNodeIndex && callbacks.paragraphHasVisibleText(node)) {
       let chainCursor = nodeIndex;
       let chainPreviousParagraphAfterPx = paragraphAfterSpacingPx2(node);
       while (chainCursor < model.nodes.length - 1) {
@@ -42637,6 +43084,7 @@ function collectDocxEstimatedOverflowBreakStartNodeIndexes(model, hardBreakStart
         );
         chainPreviousParagraphAfterPx = paragraphAfterSpacingPx2(nextChainNode);
       }
+      keepNextChainEndNodeIndex = chainCursor;
     }
     const remainingHeightPx = currentPageContentHeightPx - pageConsumedHeightPx;
     if (pageConsumedHeightPx > 0 && requiredHeightPx > remainingHeightPx + pageOverflowTolerancePx) {
@@ -42645,6 +43093,9 @@ function collectDocxEstimatedOverflowBreakStartNodeIndexes(model, hardBreakStart
       previousParagraphAfterPx = 0;
       currentPageContentHeightPx = nodeMetrics.pageContentHeightPx;
     }
+    if (pageConsumedHeightPx === 0 && keepNextChainEndNodeIndex > nodeIndex) {
+      committedKeepNextChainEndNodeIndex = keepNextChainEndNodeIndex;
+    }
     const effectiveNodeHeightPx = pageConsumedHeightPx > 0 ? collapsedNodeHeightPx : rawNodeHeightPx;
     pageConsumedHeightPx += effectiveNodeHeightPx;
     previousParagraphAfterPx = node.type === "paragraph" ? paragraphAfterSpacingPx2(node) : 0;
@@ -42696,6 +43147,7 @@ function buildDocumentPageNodeSegments2(model, pageContentHeightPx, pageContentW
   let pageConsumedHeightPx = 0;
   let previousParagraphAfterPx = 0;
   let currentMetricsIndex = 0;
+  let committedKeepNextChainEndNodeIndex = -1;
   let currentPageContentHeightPx = resolvePageContentHeightPx(
     0,
     metricsBySection[0]?.pageContentHeightPx ?? fallbackMetrics.pageContentHeightPx
@@ -42759,7 +43211,8 @@ function buildDocumentPageNodeSegments2(model, pageContentHeightPx, pageContentW
       const keepLinesOverflowSplit = node.style?.keepLines === true && paragraphTooTallForSinglePage;
       const keepNextOverflowSplit = node.style?.keepNext === true && paragraphTooTallForSinglePage;
       const forceOverflowSplit = keepLinesOverflowSplit || keepNextOverflowSplit;
-      if (forceOverflowSplit && pageConsumedHeightPx > 0 && currentPageSegments.length > 0) {
+      const nodeIsWithinCommittedKeepNextChain = nodeIndex <= committedKeepNextChainEndNodeIndex;
+      if (forceOverflowSplit && !nodeIsWithinCommittedKeepNextChain && pageConsumedHeightPx > 0 && currentPageSegments.length > 0) {
         startNextPage();
         pageConsumedHeightPx = 0;
         previousParagraphAfterPx = 0;
@@ -42909,7 +43362,8 @@ function buildDocumentPageNodeSegments2(model, pageContentHeightPx, pageContentW
         continue;
       }
       let requiredHeightPx = collapsedNodeHeightPx;
-      if (node.style?.keepNext === true && callbacks.paragraphHasVisibleText(node)) {
+      let keepNextChainEndNodeIndex = -1;
+      if (node.style?.keepNext === true && !nodeIsWithinCommittedKeepNextChain && callbacks.paragraphHasVisibleText(node)) {
         let chainCursor = nodeIndex;
         let chainPreviousParagraphAfterPx = afterSpacingPx;
         while (chainCursor < model.nodes.length - 1) {
@@ -42967,6 +43421,7 @@ function buildDocumentPageNodeSegments2(model, pageContentHeightPx, pageContentW
           );
           chainPreviousParagraphAfterPx = paragraphAfterSpacingPx2(nextChainNode);
         }
+        keepNextChainEndNodeIndex = chainCursor;
       }
       const remainingHeightPx = currentPageContentHeightPx - pageConsumedHeightPx;
       if (pageConsumedHeightPx > 0 && requiredHeightPx > remainingHeightPx + pageOverflowTolerancePx) {
@@ -42978,6 +43433,9 @@ function buildDocumentPageNodeSegments2(model, pageContentHeightPx, pageContentW
           nodeMetrics.pageContentHeightPx
         );
       }
+      if (pageConsumedHeightPx === 0 && keepNextChainEndNodeIndex > nodeIndex) {
+        committedKeepNextChainEndNodeIndex = keepNextChainEndNodeIndex;
+      }
       currentPageSegments.push({ nodeIndex });
       const effectiveNodeHeightPx = pageConsumedHeightPx > 0 ? collapsedNodeHeightPx : rawNodeHeightPx;
       pageConsumedHeightPx += effectiveNodeHeightPx;