@superdoc-dev/cli 0.16.0-next.4 → 0.16.0-next.5

package/dist/index.js

@@ -68110,7 +68110,7 @@ var init_remark_gfm_BhnWr3yf_es = __esm(() => {
   emptyOptions2 = {};
 });
 
-// ../../packages/superdoc/dist/chunks/SuperConverter-nmIRMGtB.es.js
+// ../../packages/superdoc/dist/chunks/SuperConverter-LqX_f8x4.es.js
 function getExtensionConfigField(extension$1, field, context = { name: "" }) {
   const fieldValue = extension$1.config[field];
   if (typeof fieldValue === "function")
@@ -98476,7 +98476,7 @@ function importNoteEntries({ partXml, childElementName, filename, docx, editor,
     const idNumber = Number(id2);
     const originalXml = carbonCopy(el);
     const type = el?.attributes?.["w:type"] || null;
-    if (type === "separator" || type === "continuationSeparator") {
+    if (type === "separator" || type === "continuationSeparator" || type === "continuationNotice") {
       results.push({
         id: id2,
         type,
@@ -102188,17 +102188,78 @@ function buildReferenceMarkerRun(displayText, params3) {
     fontSize: baseFontSize * SUBSCRIPT_SUPERSCRIPT_SCALE
   }, params3);
 }
+function toUpperRoman(num) {
+  if (num < 1 || num > 3999)
+    return String(num);
+  const values = [
+    1000,
+    900,
+    500,
+    400,
+    100,
+    90,
+    50,
+    40,
+    10,
+    9,
+    5,
+    4,
+    1
+  ];
+  const numerals = [
+    "M",
+    "CM",
+    "D",
+    "CD",
+    "C",
+    "XC",
+    "L",
+    "XL",
+    "X",
+    "IX",
+    "V",
+    "IV",
+    "I"
+  ];
+  let result = "";
+  let remaining = num;
+  for (let i$1 = 0;i$1 < values.length; i$1 += 1)
+    while (remaining >= values[i$1]) {
+      result += numerals[i$1];
+      remaining -= values[i$1];
+    }
+  return result;
+}
+function toUpperLetter(num) {
+  if (num < 1)
+    return "A";
+  let result = "";
+  let n = num;
+  while (n > 0) {
+    const remainder = (n - 1) % 26;
+    result = String.fromCharCode(65 + remainder) + result;
+    n = Math.floor((n - 1) / 26);
+  }
+  return result;
+}
 function footnoteReferenceToBlock(params3) {
   const { node: node3, converterContext } = params3;
-  const id2 = node3.attrs?.id;
-  const displayId = resolveFootnoteDisplayNumber(id2, converterContext.footnoteNumberById) ?? id2 ?? "*";
-  return buildReferenceMarkerRun(String(displayId), params3);
+  const attrs = node3.attrs;
+  const id2 = attrs?.id;
+  if (isCustomMarkFollows(attrs?.customMarkFollows))
+    return buildReferenceMarkerRun("", params3);
+  const cardinal = resolveFootnoteDisplayNumber(id2, converterContext.footnoteNumberById);
+  const key = id2 == null ? null : String(id2);
+  const numFmt = key && converterContext.footnoteFormatById?.[key] || converterContext.footnoteNumberFormat;
+  return buildReferenceMarkerRun(cardinal != null ? formatFootnoteCardinal(cardinal, numFmt) : id2 != null ? String(id2) : "*", params3);
 }
 function endnoteReferenceToBlock(params3) {
   const { node: node3, converterContext } = params3;
   const id2 = node3.attrs?.id;
-  const displayId = resolveEndnoteDisplayNumber(id2, converterContext.endnoteNumberById) ?? id2 ?? "*";
-  return buildReferenceMarkerRun(String(displayId), params3);
+  const cardinal = resolveEndnoteDisplayNumber(id2, converterContext.endnoteNumberById);
+  const key = id2 == null ? null : String(id2);
+  const numFmt = key && converterContext.endnoteFormatById?.[key] || converterContext.endnoteNumberFormat;
+  return buildReferenceMarkerRun(cardinal != null ? formatFootnoteCardinal(cardinal, numFmt) : id2 != null ? String(id2) : "*", params3);
 }
 function runNodeChildrenToRuns({ node: node3, inheritedMarks, sdtMetadata, converterContext, paragraphProperties, visitNode }) {
   const mergedMarks = [...node3.marks ?? [], ...inheritedMarks ?? []];
@@ -106753,6 +106814,147 @@ function setDefaultTableStyle(settingsRoot, styleId) {
 function removeDefaultTableStyle(settingsRoot) {
   settingsRoot.elements = ensureSettingsRootElements(settingsRoot).filter((entry) => entry.name !== "w:defaultTableStyle");
 }
+function readFootnoteNumberFormat(settingsRoot) {
+  return readNoteNumberFormat(settingsRoot, "w:footnotePr");
+}
+function readEndnoteNumberFormat(settingsRoot) {
+  return readNoteNumberFormat(settingsRoot, "w:endnotePr");
+}
+function readNoteNumberFormat(settingsRoot, containerName) {
+  const container = settingsRoot.elements?.find((entry) => entry.name === containerName);
+  if (!container || !Array.isArray(container.elements))
+    return null;
+  const numFmt = container.elements.find((entry) => entry.name === "w:numFmt");
+  if (!numFmt)
+    return null;
+  const val = numFmt.attributes?.["w:val"];
+  return typeof val === "string" && val.length > 0 ? val : null;
+}
+function readFootnoteNumberStart(settingsRoot) {
+  return readNoteNumberStart(settingsRoot, "w:footnotePr");
+}
+function readEndnoteNumberStart(settingsRoot) {
+  return readNoteNumberStart(settingsRoot, "w:endnotePr");
+}
+function readNoteNumberStart(settingsRoot, containerName) {
+  const container = settingsRoot.elements?.find((entry) => entry.name === containerName);
+  if (!container || !Array.isArray(container.elements))
+    return null;
+  const numStart = container.elements.find((entry) => entry.name === "w:numStart");
+  if (!numStart)
+    return null;
+  const val = numStart.attributes?.["w:val"];
+  if (typeof val !== "string" && typeof val !== "number")
+    return null;
+  const n = Number(val);
+  return Number.isFinite(n) && n >= 1 ? Math.floor(n) : null;
+}
+function readFootnotePosition(settingsRoot) {
+  return readNotePosition(settingsRoot, "w:footnotePr");
+}
+function readEndnotePosition(settingsRoot) {
+  return readNotePosition(settingsRoot, "w:endnotePr");
+}
+function readNotePosition(settingsRoot, containerName) {
+  const container = settingsRoot.elements?.find((entry) => entry.name === containerName);
+  if (!container || !Array.isArray(container.elements))
+    return null;
+  const el = container.elements.find((entry) => entry.name === "w:pos");
+  if (!el)
+    return null;
+  const val = el.attributes?.["w:val"];
+  if (val === "pageBottom" || val === "beneathText" || val === "sectEnd" || val === "docEnd")
+    return val;
+  return null;
+}
+function readFootnoteNumberRestart(settingsRoot) {
+  return readNoteNumberRestart(settingsRoot, "w:footnotePr");
+}
+function readEndnoteNumberRestart(settingsRoot) {
+  return readNoteNumberRestart(settingsRoot, "w:endnotePr");
+}
+function readNoteNumberRestart(settingsRoot, containerName) {
+  const container = settingsRoot.elements?.find((entry) => entry.name === containerName);
+  if (!container || !Array.isArray(container.elements))
+    return null;
+  const el = container.elements.find((entry) => entry.name === "w:numRestart");
+  if (!el)
+    return null;
+  const val = el.attributes?.["w:val"];
+  if (val === "continuous" || val === "eachPage" || val === "eachSect")
+    return val;
+  return null;
+}
+function readSectionNoteConfigs(documentRoot, containerName) {
+  const result = /* @__PURE__ */ new Map;
+  if (!documentRoot)
+    return result;
+  const bodyEl = findBody(documentRoot);
+  if (!bodyEl)
+    return result;
+  let sectionIndex = 0;
+  for (const child of bodyEl.elements ?? [])
+    if (child.name === "w:sectPr") {
+      const config$42 = extractSectionNoteConfig(child, containerName);
+      if (config$42)
+        result.set(sectionIndex, config$42);
+      sectionIndex += 1;
+    } else if (child.name === "w:p") {
+      const sectPr = findChildByName(findChildByName(child, "w:pPr"), "w:sectPr");
+      if (sectPr) {
+        const config$42 = extractSectionNoteConfig(sectPr, containerName);
+        if (config$42)
+          result.set(sectionIndex, config$42);
+        sectionIndex += 1;
+      }
+    }
+  return result;
+}
+function findBody(root2) {
+  if (root2.name === "w:body")
+    return root2;
+  if (!Array.isArray(root2.elements))
+    return null;
+  for (const child of root2.elements) {
+    if (child.name === "w:body")
+      return child;
+    const inner = child.elements?.find((g2) => g2.name === "w:body");
+    if (inner)
+      return inner;
+  }
+  return null;
+}
+function findChildByName(parent, name) {
+  if (!parent)
+    return null;
+  return parent.elements?.find((entry) => entry.name === name) ?? null;
+}
+function extractSectionNoteConfig(sectPr, containerName) {
+  const container = findChildByName(sectPr, containerName);
+  if (!container)
+    return null;
+  const config$42 = {};
+  const numFmt = findChildByName(container, "w:numFmt");
+  if (numFmt) {
+    const val = numFmt.attributes?.["w:val"];
+    if (typeof val === "string" && val.length > 0)
+      config$42.numFmt = val;
+  }
+  const numStart = findChildByName(container, "w:numStart");
+  if (numStart) {
+    const val = numStart.attributes?.["w:val"];
+    const n = typeof val === "string" || typeof val === "number" ? Number(val) : NaN;
+    if (Number.isFinite(n) && n >= 1)
+      config$42.numStart = Math.floor(n);
+  }
+  const numRestart = findChildByName(container, "w:numRestart");
+  if (numRestart) {
+    const val = numRestart.attributes?.["w:val"];
+    if (val === "continuous" || val === "eachPage" || val === "eachSect")
+      config$42.numRestart = val;
+  }
+  return Object.keys(config$42).length > 0 ? config$42 : null;
+}
 function hasOddEvenHeadersFooters(settingsRoot) {
   return settingsRoot.elements?.some((entry) => entry.name === "w:evenAndOddHeaders") === true;
 }
@@ -121737,7 +121939,7 @@ var isRegExp = (value) => {
 }, handleAlpha = (path2, lvlText) => generateNumbering(path2, lvlText, intToAlpha), handleLowerAlpha = (path2, lvlText) => {
   const result = handleAlpha(path2, lvlText);
   return result ? result.toLowerCase() : null;
-}, handleOrdinal = (path2, lvlText) => generateNumbering(path2, lvlText, ordinalFormatter), handleCustom = (path2, lvlText, customFormat) => generateFromCustom(path2, lvlText, customFormat), handleJapaneseCounting = (path2, lvlText) => generateNumbering(path2, lvlText, intToJapaneseCounting), handleDecimalZero = (path2, lvlText) => generateNumbering(path2, lvlText, decimalZeroFormatter), listIndexMap, generateOrderedListIndex = ({ listLevel, lvlText, listNumberingType, customFormat }) => {
+}, handleOrdinal = (path2, lvlText) => generateNumbering(path2, lvlText, ordinalFormatter), handleOrdinalText = (path2, lvlText) => generateNumbering(path2, lvlText, ordinalTextFormatter), handleCardinalText = (path2, lvlText) => generateNumbering(path2, lvlText, cardinalTextFormatter), handleCustom = (path2, lvlText, customFormat) => generateFromCustom(path2, lvlText, customFormat), handleJapaneseCounting = (path2, lvlText) => generateNumbering(path2, lvlText, intToJapaneseCounting), handleDecimalZero = (path2, lvlText) => generateNumbering(path2, lvlText, decimalZeroFormatter), listIndexMap, generateOrderedListIndex = ({ listLevel, lvlText, listNumberingType, customFormat }) => {
   if (typeof lvlText !== "string")
     return null;
   const handler$1 = listIndexMap[listNumberingType];
@@ -121759,6 +121961,32 @@ var isRegExp = (value) => {
   ];
   const lastTwo = value % 100;
   return `${value}${suffixes[(lastTwo - 20) % 10] || suffixes[lastTwo] || suffixes[0]}`;
+}, ONES_ORDINAL, TENS_ORDINAL, ONES_CARDINAL, TENS_CARDINAL, ordinalTextFormatter = (value) => {
+  if (!Number.isFinite(value) || value < 1)
+    return "";
+  if (value < ONES_ORDINAL.length)
+    return ONES_ORDINAL[value];
+  if (value < 100) {
+    const t = Math.floor(value / 10);
+    const o = value % 10;
+    if (o === 0)
+      return TENS_ORDINAL[t];
+    return `${TENS_CARDINAL[t]}-${ONES_ORDINAL[o]}`;
+  }
+  return ordinalFormatter(value);
+}, cardinalTextFormatter = (value) => {
+  if (!Number.isFinite(value) || value < 1)
+    return "";
+  if (value < ONES_CARDINAL.length)
+    return ONES_CARDINAL[value];
+  if (value < 100) {
+    const t = Math.floor(value / 10);
+    const o = value % 10;
+    if (o === 0)
+      return TENS_CARDINAL[t];
+    return `${TENS_CARDINAL[t]}-${ONES_CARDINAL[o]}`;
+  }
+  return String(value);
 }, decimalZeroFormatter = (value, idx) => {
   if (value >= 10 || idx === 0)
     return String(value);
@@ -129059,7 +129287,33 @@ var isRegExp = (value) => {
   inheritedMarks: stripVerticalPositioningFromMarks(params3.inheritedMarks),
   runProperties: stripVerticalPositioningFromRunProperties(params3.runProperties),
   node: buildSyntheticTextNode(displayText, stripVerticalPositioningFromMarks(params3.node.marks))
-}), resolveFootnoteDisplayNumber = (id2, footnoteNumberById) => {
+}), SUPPORTED_FORMATS, formatFootnoteCardinal = (cardinal, numFmt) => {
+  const fmt = numFmt && SUPPORTED_FORMATS.has(numFmt) ? numFmt : "decimal";
+  const num = Math.max(1, cardinal);
+  switch (fmt) {
+    case "decimal":
+      return String(num);
+    case "upperRoman":
+      return toUpperRoman(num);
+    case "lowerRoman":
+      return toUpperRoman(num).toLowerCase();
+    case "upperLetter":
+      return toUpperLetter(num);
+    case "lowerLetter":
+      return toUpperLetter(num).toLowerCase();
+    case "numberInDash":
+      return `-${num}-`;
+    default:
+      return String(num);
+  }
+}, isCustomMarkFollows = (value) => {
+  if (value === true || value === 1)
+    return true;
+  if (typeof value !== "string")
+    return false;
+  const v = value.trim().toLowerCase();
+  return v === "1" || v === "true" || v === "on";
+}, resolveFootnoteDisplayNumber = (id2, footnoteNumberById) => {
   const key = id2 == null ? null : String(id2);
   if (!key)
     return null;
@@ -130249,7 +130503,7 @@ var isRegExp = (value) => {
       state.kern = kernNode.attributes["w:val"];
   }
 }, SuperConverter;
-var init_SuperConverter_nmIRMGtB_es = __esm(() => {
+var init_SuperConverter_LqX_f8x4_es = __esm(() => {
   init_rolldown_runtime_Bg48TavK_es();
   init_jszip_C49i9kUs_es();
   init_xml_js_CqGKpaft_es();
@@ -160177,9 +160431,79 @@ var init_SuperConverter_nmIRMGtB_es = __esm(() => {
     lowerLetter: handleLowerAlpha,
     upperLetter: handleAlpha,
     ordinal: handleOrdinal,
+    ordinalText: handleOrdinalText,
+    cardinalText: handleCardinalText,
     custom: handleCustom,
     japaneseCounting: handleJapaneseCounting
   };
+  ONES_ORDINAL = [
+    "",
+    "First",
+    "Second",
+    "Third",
+    "Fourth",
+    "Fifth",
+    "Sixth",
+    "Seventh",
+    "Eighth",
+    "Ninth",
+    "Tenth",
+    "Eleventh",
+    "Twelfth",
+    "Thirteenth",
+    "Fourteenth",
+    "Fifteenth",
+    "Sixteenth",
+    "Seventeenth",
+    "Eighteenth",
+    "Nineteenth"
+  ];
+  TENS_ORDINAL = [
+    "",
+    "",
+    "Twentieth",
+    "Thirtieth",
+    "Fortieth",
+    "Fiftieth",
+    "Sixtieth",
+    "Seventieth",
+    "Eightieth",
+    "Ninetieth"
+  ];
+  ONES_CARDINAL = [
+    "",
+    "One",
+    "Two",
+    "Three",
+    "Four",
+    "Five",
+    "Six",
+    "Seven",
+    "Eight",
+    "Nine",
+    "Ten",
+    "Eleven",
+    "Twelve",
+    "Thirteen",
+    "Fourteen",
+    "Fifteen",
+    "Sixteen",
+    "Seventeen",
+    "Eighteen",
+    "Nineteen"
+  ];
+  TENS_CARDINAL = [
+    "",
+    "",
+    "Twenty",
+    "Thirty",
+    "Forty",
+    "Fifty",
+    "Sixty",
+    "Seventy",
+    "Eighty",
+    "Ninety"
+  ];
   normalizeChars = new Set([
     "",
     "",
@@ -167436,6 +167760,14 @@ var init_SuperConverter_nmIRMGtB_es = __esm(() => {
       this.name = "NotInlineNodeError";
     }
   };
+  SUPPORTED_FORMATS = new Set([
+    "decimal",
+    "upperRoman",
+    "lowerRoman",
+    "upperLetter",
+    "lowerLetter",
+    "numberInDash"
+  ]);
   sdtMetadataCache = /* @__PURE__ */ new Map;
   NON_RENDERED_STRUCTURAL_INLINE_TYPES = new Set([
     "bookmarkEnd",
@@ -168938,7 +169270,7 @@ var init_SuperConverter_nmIRMGtB_es = __esm(() => {
   };
 });
 
-// ../../packages/superdoc/dist/chunks/create-headless-toolbar-7bitVHMJ.es.js
+// ../../packages/superdoc/dist/chunks/create-headless-toolbar-BOETXxAI.es.js
 function parseSizeUnit(val = "0") {
   const length3 = val.toString() || "0";
   const value = Number.parseFloat(length3);
@@ -179269,8 +179601,8 @@ var CSS_DIMENSION_REGEX, DOM_SIZE_UNITS, normalizeActorId = (value) => {
     }
   };
 };
-var init_create_headless_toolbar_7bitVHMJ_es = __esm(() => {
-  init_SuperConverter_nmIRMGtB_es();
+var init_create_headless_toolbar_BOETXxAI_es = __esm(() => {
+  init_SuperConverter_LqX_f8x4_es();
   init_uuid_qzgm05fK_es();
   init_constants_D_X7xF4s_es();
   init_dist_B8HfvhaK_es();
@@ -228433,7 +228765,7 @@ var init_remark_gfm_eZN6yzWQ_es = __esm(() => {
   init_remark_gfm_BhnWr3yf_es();
 });
 
-// ../../packages/superdoc/dist/chunks/src-BrZa8lMN.es.js
+// ../../packages/superdoc/dist/chunks/src-iuHADPff.es.js
 function deleteProps(obj, propOrProps) {
   const props = typeof propOrProps === "string" ? [propOrProps] : propOrProps;
   const removeNested = (target, pathParts, index2 = 0) => {
@@ -268133,7 +268465,9 @@ function resolveParagraphContent(fragment2, block, measure) {
         bold: m$1.run?.bold,
         italic: m$1.run?.italic,
         color: m$1.run?.color,
-        letterSpacing: m$1.run?.letterSpacing
+        letterSpacing: m$1.run?.letterSpacing,
+        allCaps: m$1.run?.allCaps,
+        smallCaps: m$1.run?.smallCaps
       },
       sourceAnchor: block.sourceAnchor
     };
@@ -269098,25 +269432,6 @@ function normalizeLines(measure) {
     lineHeight: measure.totalHeight || 0
   }];
 }
-function sliceLines(lines, startIndex, availableHeight) {
-  let height = 0;
-  let index2 = startIndex;
-  while (index2 < lines.length) {
-    const lineHeight = lines[index2].lineHeight || 0;
-    if (height > 0 && height + lineHeight > availableHeight)
-      break;
-    height += lineHeight;
-    index2 += 1;
-  }
-  if (index2 === startIndex) {
-    height = lines[startIndex].lineHeight || 0;
-    index2 += 1;
-  }
-  return {
-    toLine: index2,
-    height
-  };
-}
 function shouldSuppressOwnSpacing(ownStyleId, ownContextualSpacing, adjacentStyleId) {
   return ownContextualSpacing && !!ownStyleId && !!adjacentStyleId && ownStyleId === adjacentStyleId;
 }
@@ -269412,14 +269727,56 @@ function layoutParagraphBlock(ctx$1, anchors) {
       }
     else
       state.trailingSpacing = 0;
-    if (state.cursorY >= state.contentBottom)
+    const FN_SAFETY_MARGIN_PX = 1;
+    const fallbackBandOverhead = (refsTotal) => refsTotal > 0 ? 22 + Math.max(0, refsTotal - 1) * 2 : 0;
+    const bandOverhead = (refsTotal) => {
+      if (refsTotal <= 0)
+        return 0;
+      const fromCtx = ctx$1.getFootnoteBandOverhead?.(refsTotal);
+      return (typeof fromCtx === "number" && Number.isFinite(fromCtx) && fromCtx >= 0 ? fromCtx : fallbackBandOverhead(refsTotal)) + FN_SAFETY_MARGIN_PX;
+    };
+    const rawContentBottom = state.contentBottom + state.pageFootnoteReserve;
+    const computeEffectiveBottom = (extraDemand, extraRefs) => {
+      const totalDemand = extraDemand;
+      const totalRefs = state.footnoteRefsThisPage + extraRefs;
+      const demandWithOverhead = totalDemand > 0 ? totalDemand + bandOverhead(totalRefs) : 0;
+      const reservedSpace = Math.max(state.pageFootnoteReserve, demandWithOverhead);
+      const minBodyLineHeight = lines[fromLine]?.lineHeight ?? 0;
+      const maxAdditional = Math.max(0, rawContentBottom - state.topMargin - minBodyLineHeight);
+      return rawContentBottom - Math.min(reservedSpace, maxAdditional);
+    };
+    const computeFootnoteClusterDemand = (pmStart, pmEnd) => {
+      const candidate = ctx$1.getFootnoteAnchorsForBlockId ? ctx$1.getFootnoteAnchorsForBlockId(block.id, pmStart, pmEnd) : [];
+      const committed = state.footnoteAnchorsThisPage ?? [];
+      if (candidate.length === 0 && committed.length === 0)
+        return 0;
+      let demand = 0;
+      for (const anchor of committed)
+        demand += anchor.fullHeight;
+      for (const anchor of candidate)
+        demand += anchor.fullHeight;
+      return demand;
+    };
+    const previewRange = computeFragmentPmRange2(block, lines, fromLine, fromLine + 1);
+    const previewRefs = ctx$1.getFootnoteRefCountForBlockId ? ctx$1.getFootnoteRefCountForBlockId(block.id, previewRange.pmStart, previewRange.pmEnd) : 0;
+    const computePreviewBottom = () => {
+      return computeEffectiveBottom(computeFootnoteClusterDemand(previewRange.pmStart ?? 0, previewRange.pmEnd ?? 0), previewRefs);
+    };
+    let effectiveBottom = computePreviewBottom();
+    if (state.cursorY >= effectiveBottom) {
       state = advanceColumn(state);
-    if (state.contentBottom - state.cursorY <= 0)
+      effectiveBottom = computePreviewBottom();
+    }
+    if (effectiveBottom - state.cursorY <= 0) {
       state = advanceColumn(state);
+      effectiveBottom = computePreviewBottom();
+    }
     const nextLineHeight = lines[fromLine].lineHeight || 0;
-    const remainingHeight = state.contentBottom - state.cursorY;
-    if (state.page.fragments.length > 0 && remainingHeight < nextLineHeight)
+    const remainingHeight = effectiveBottom - state.cursorY;
+    if (state.page.fragments.length > 0 && remainingHeight < nextLineHeight) {
       state = advanceColumn(state);
+      effectiveBottom = computePreviewBottom();
+    }
     let effectiveColumnWidth = columnWidth;
     let offsetX = 0;
     if (didRemeasureForFloats) {
@@ -269427,9 +269784,50 @@ function layoutParagraphBlock(ctx$1, anchors) {
       offsetX = narrowestOffsetX;
     }
     const borderVertical = borderExpansion.top + borderExpansion.bottom;
-    const availableForSlice = Math.max(0, state.contentBottom - state.cursorY - borderVertical);
-    const slice2 = sliceLines(lines, fromLine, availableForSlice);
+    let toLine = fromLine;
+    let height = 0;
+    let sliceDemand = 0;
+    let sliceRefs = 0;
+    while (toLine < lines.length) {
+      const lineHeight = lines[toLine].lineHeight || 0;
+      const range = computeFragmentPmRange2(block, lines, fromLine, toLine + 1);
+      const orderedDemand = computeFootnoteClusterDemand(range.pmStart ?? 0, range.pmEnd ?? 0);
+      const nextRefs = ctx$1.getFootnoteRefCountForBlockId ? ctx$1.getFootnoteRefCountForBlockId(block.id, range.pmStart, range.pmEnd) : 0;
+      if (toLine === fromLine) {
+        height = lineHeight;
+        sliceDemand = orderedDemand;
+        sliceRefs = nextRefs;
+        toLine = fromLine + 1;
+        continue;
+      }
+      if (state.cursorY + height + lineHeight + borderVertical > computeEffectiveBottom(orderedDemand, nextRefs))
+        break;
+      height += lineHeight;
+      sliceDemand = orderedDemand;
+      sliceRefs = nextRefs;
+      toLine += 1;
+    }
+    const slice2 = {
+      toLine,
+      height
+    };
     const fragmentHeight = slice2.height;
+    if (sliceDemand > 0 || sliceRefs > 0) {
+      state.footnoteDemandThisPage = sliceDemand;
+      state.footnoteRefsThisPage = (state.footnoteRefsThisPage ?? 0) + sliceRefs;
+    }
+    if (ctx$1.getFootnoteAnchorsForBlockId) {
+      const committedRange = computeFragmentPmRange2(block, lines, fromLine, toLine);
+      const newAnchors = ctx$1.getFootnoteAnchorsForBlockId(block.id, committedRange.pmStart, committedRange.pmEnd);
+      if (newAnchors.length > 0) {
+        if (!state.footnoteAnchorsThisPage)
+          state.footnoteAnchorsThisPage = [];
+        const seen = new Set(state.footnoteAnchorsThisPage.map((a2) => a2.refId));
+        for (const a2 of newAnchors)
+          if (!seen.has(a2.refId))
+            state.footnoteAnchorsThisPage.push(a2);
+      }
+    }
     const adjustedX = columnX(state.columnIndex) + offsetX + negativeLeftIndent;
     const adjustedWidth = effectiveColumnWidth - negativeLeftIndent - negativeRightIndent;
     const fragment2 = {
@@ -270856,8 +271254,10 @@ function createPaginator(opts) {
       footer: footerDistance
     };
     const pageSizeOverride = currentPageSize.w !== defaultPageSize.w || currentPageSize.h !== defaultPageSize.h ? currentPageSize : undefined;
+    const pageIndex = pages.length;
+    const pageFootnoteReserve = opts.getFootnoteReserveForPage?.(pageIndex) ?? 0;
     const state = {
-      page: opts.createPage(pages.length + 1, pageMargins, pageSizeOverride),
+      page: opts.createPage(pageIndex + 1, pageMargins, pageSizeOverride),
       cursorY: topMargin,
       columnIndex: 0,
       topMargin,
@@ -270867,7 +271267,11 @@ function createPaginator(opts) {
       trailingSpacing: 0,
       lastParagraphStyleId: undefined,
       lastParagraphContextualSpacing: false,
-      maxCursorY: topMargin
+      maxCursorY: topMargin,
+      pageFootnoteReserve,
+      footnoteDemandThisPage: 0,
+      footnoteRefsThisPage: 0,
+      footnoteAnchorsThisPage: []
     };
     states.push(state);
     pages.push(state.page);
@@ -270893,6 +271297,8 @@ function createPaginator(opts) {
       state.trailingSpacing = 0;
       state.lastParagraphStyleId = undefined;
       state.lastParagraphContextualSpacing = false;
+      state.footnoteAnchorsThisPage = [];
+      state.footnoteRefsThisPage = 0;
       return state;
     }
     return startNewPage();
@@ -270912,7 +271318,7 @@ function createPaginator(opts) {
     pruneTrailingEmptyPages
   };
 }
-function toUpperRoman(num) {
+function toUpperRoman2(num) {
   if (num < 1 || num > 3999)
     return String(num);
   const values = [
@@ -270955,9 +271361,9 @@ function toUpperRoman(num) {
   return result;
 }
 function toLowerRoman(num) {
-  return toUpperRoman(num).toLowerCase();
+  return toUpperRoman2(num).toLowerCase();
 }
-function toUpperLetter(num) {
+function toUpperLetter2(num) {
   if (num < 1)
     return "A";
   let result = "";
@@ -270970,7 +271376,7 @@ function toUpperLetter(num) {
   return result;
 }
 function toLowerLetter(num) {
-  return toUpperLetter(num).toLowerCase();
+  return toUpperLetter2(num).toLowerCase();
 }
 function formatPageNumber(pageNumber, format) {
   const num = Math.max(1, pageNumber);
@@ -270978,11 +271384,11 @@ function formatPageNumber(pageNumber, format) {
     case "decimal":
       return String(num);
     case "upperRoman":
-      return toUpperRoman(num);
+      return toUpperRoman2(num);
     case "lowerRoman":
       return toLowerRoman(num);
     case "upperLetter":
-      return toUpperLetter(num);
+      return toUpperLetter2(num);
     case "lowerLetter":
       return toLowerLetter(num);
     case "numberInDash":
@@ -272024,6 +272430,135 @@ function layoutDocument(blocks2, measures, options = {}) {
     }
     return page;
   };
+  const footnoteAnchorsByBlockId = (() => {
+    const out = /* @__PURE__ */ new Map;
+    const refs = options.footnotes?.refs;
+    const bodyHeights = options.footnotes?.bodyHeightById;
+    const firstLineHeights = options.footnotes?.firstLineHeightById;
+    if (!Array.isArray(refs) || refs.length === 0 || !bodyHeights)
+      return out;
+    const resolveBlockPmRange = (block) => {
+      const attrsRange = block.attrs;
+      let pmStart = typeof attrsRange?.pmStart === "number" ? attrsRange.pmStart : undefined;
+      let pmEnd = typeof attrsRange?.pmEnd === "number" ? attrsRange.pmEnd : undefined;
+      if (pmStart == null && block.kind === "paragraph") {
+        const runs2 = block.runs;
+        if (Array.isArray(runs2))
+          for (const run2 of runs2) {
+            const rs = run2.pmStart;
+            const re2 = run2.pmEnd;
+            if (typeof rs === "number")
+              pmStart = pmStart == null ? rs : Math.min(pmStart, rs);
+            if (typeof re2 === "number")
+              pmEnd = pmEnd == null ? re2 : Math.max(pmEnd, re2);
+          }
+      }
+      if (pmStart == null)
+        return null;
+      return {
+        pmStart,
+        pmEnd: pmEnd ?? pmStart + 1
+      };
+    };
+    const refByPos = /* @__PURE__ */ new Map;
+    const seenIds = /* @__PURE__ */ new Set;
+    for (const ref$1 of refs) {
+      if (seenIds.has(ref$1.id))
+        continue;
+      seenIds.add(ref$1.id);
+      refByPos.set(ref$1.pos, ref$1.id);
+    }
+    const recordIfHit = (range, topLevelId) => {
+      for (const [pos, refId] of refByPos.entries()) {
+        if (pos < range.pmStart || pos > range.pmEnd)
+          continue;
+        const fullHeight = bodyHeights.get(refId);
+        if (typeof fullHeight !== "number" || !Number.isFinite(fullHeight) || fullHeight <= 0)
+          continue;
+        const firstLineRaw = firstLineHeights?.get(refId);
+        const firstLineHeight = typeof firstLineRaw === "number" && Number.isFinite(firstLineRaw) && firstLineRaw > 0 ? Math.min(firstLineRaw, fullHeight) : fullHeight;
+        const list5 = out.get(topLevelId) ?? [];
+        list5.push({
+          pmPos: pos,
+          refId,
+          fullHeight,
+          firstLineHeight
+        });
+        out.set(topLevelId, list5);
+        refByPos.delete(pos);
+      }
+    };
+    for (const block of blocks2) {
+      if (refByPos.size === 0)
+        break;
+      const range = resolveBlockPmRange(block);
+      if (range)
+        recordIfHit(range, block.id);
+      if (block.kind === "table")
+        for (const row2 of block.rows ?? [])
+          for (const cell2 of row2.cells ?? []) {
+            const cellChildren = cell2.blocks ? cell2.blocks : cell2.paragraph ? [cell2.paragraph] : [];
+            for (const child of cellChildren) {
+              const childRange = resolveBlockPmRange(child);
+              if (childRange)
+                recordIfHit(childRange, block.id);
+            }
+          }
+    }
+    for (const list5 of out.values())
+      list5.sort((a2, b$1) => a2.pmPos - b$1.pmPos);
+    return out;
+  })();
+  const getFootnoteAnchorsForBlockId = (blockId, pmStart, pmEnd) => {
+    const entries2 = footnoteAnchorsByBlockId.get(blockId);
+    if (!entries2 || entries2.length === 0)
+      return [];
+    if (pmStart == null || pmEnd == null)
+      return entries2;
+    const out = [];
+    for (const e of entries2)
+      if (e.pmPos >= pmStart && e.pmPos <= pmEnd)
+        out.push(e);
+    return out;
+  };
+  const getFootnoteDemandForBlockId = (blockId, pmStart, pmEnd, committed) => {
+    const candidate = getFootnoteAnchorsForBlockId(blockId, pmStart, pmEnd);
+    if (candidate.length === 0 && (!committed || committed.length === 0))
+      return 0;
+    const cluster = committed && committed.length > 0 ? [...committed, ...candidate] : candidate;
+    if (cluster.length === 0)
+      return 0;
+    let total = 0;
+    for (let i4 = 0;i4 < cluster.length - 1; i4 += 1)
+      total += cluster[i4].fullHeight;
+    total += cluster[cluster.length - 1].firstLineHeight;
+    return total;
+  };
+  const getFootnoteRefCountForBlockId = (blockId, pmStart, pmEnd) => {
+    const entries2 = footnoteAnchorsByBlockId.get(blockId);
+    if (!entries2 || entries2.length === 0)
+      return 0;
+    if (pmStart == null || pmEnd == null)
+      return entries2.length;
+    let count2 = 0;
+    for (const e of entries2)
+      if (e.pmPos >= pmStart && e.pmPos <= pmEnd)
+        count2 += 1;
+    return count2;
+  };
+  const getFootnoteBandOverhead = (() => {
+    const fn2 = options.footnotes;
+    const safeNum = (v, fallback) => typeof v === "number" && Number.isFinite(v) && v >= 0 ? v : fallback;
+    const topPadding = safeNum(fn2?.topPadding, 6);
+    const dividerHeight = safeNum(fn2?.dividerHeight, 6);
+    const separatorSpacingBefore = safeNum(fn2?.separatorSpacingBefore, 12);
+    const gap = safeNum(fn2?.gap, 2);
+    return (refsTotal) => {
+      if (refsTotal <= 0)
+        return 0;
+      return topPadding + dividerHeight + separatorSpacingBefore + Math.max(0, refsTotal - 1) * gap;
+    };
+  })();
   let pageCount = 0;
   let activeNumberFormat = "decimal";
   let activePageCounter = 1;
@@ -272062,15 +272597,19 @@ function layoutDocument(blocks2, measures, options = {}) {
   let activeSectionIndex = initialSectionMetadata?.sectionIndex ?? 0;
   let pendingSectionIndex = null;
   const sectionFirstPageNumbers = /* @__PURE__ */ new Map;
+  const readFootnoteReserveForPageIndex = (pageIndex) => {
+    const reserves = options.footnoteReservedByPageIndex;
+    const reserve = Array.isArray(reserves) ? reserves[pageIndex] : 0;
+    return typeof reserve === "number" && Number.isFinite(reserve) && reserve > 0 ? reserve : 0;
+  };
   const paginator = createPaginator({
     margins: paginatorMargins,
     getActiveTopMargin: () => activeTopMargin,
     getActiveBottomMargin: () => {
-      const reserves = options.footnoteReservedByPageIndex;
       const pageIndex = Math.max(0, pageCount - 1);
-      const reserve = Array.isArray(reserves) ? reserves[pageIndex] : 0;
-      return activeBottomMargin + (typeof reserve === "number" && Number.isFinite(reserve) && reserve > 0 ? reserve : 0);
+      return activeBottomMargin + readFootnoteReserveForPageIndex(pageIndex);
     },
+    getFootnoteReserveForPage: (pageIndex) => readFootnoteReserveForPageIndex(pageIndex),
     getActiveHeaderDistance: () => activeHeaderDistance,
     getActiveFooterDistance: () => activeFooterDistance,
     getActivePageSize: () => activePageSize,
@@ -272703,7 +273242,11 @@ function layoutDocument(blocks2, measures, options = {}) {
         columnX,
         floatManager,
         remeasureParagraph: options.remeasureParagraph,
-        overrideSpacingAfter
+        overrideSpacingAfter,
+        getFootnoteDemandForBlockId,
+        getFootnoteRefCountForBlockId,
+        getFootnoteBandOverhead,
+        getFootnoteAnchorsForBlockId
       }, anchorsForPara ? {
         anchoredDrawings: anchorsForPara,
         pageWidth: activePageSize.w,
@@ -273040,6 +273583,14 @@ function layoutDocument(blocks2, measures, options = {}) {
     }
     state.page.columnRegions = regions;
   }
+  for (let i4 = 0;i4 < pages.length && i4 < paginator.states.length; i4++) {
+    const s2 = paginator.states[i4];
+    const maxY = s2.maxCursorY ?? 0;
+    const cursorY = s2.cursorY ?? 0;
+    const trailing = s2.trailingSpacing ?? 0;
+    const adjusted = Math.max(maxY, cursorY) - (cursorY >= maxY ? trailing : 0);
+    pages[i4].bodyMaxY = Math.max(s2.topMargin ?? 0, adjusted);
+  }
   return {
     pageSize,
     pages,
@@ -274523,9 +275074,7 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
     headerFooter = undefined;
     nextBlocks = rewriteSectionBreaksForSemanticFlow(nextBlocks, options);
   }
-  const dirtyStart = performance.now();
   const dirty = computeDirtyRegions(previousBlocks, nextBlocks);
-  performance.now() - dirtyStart;
   if (dirty.deletedBlockIds.length > 0)
     measureCache.invalidate(dirty.deletedBlockIds);
   const perSectionConstraints = computePerSectionConstraints(options, nextBlocks);
@@ -274716,7 +275265,6 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
     remeasureParagraph: (block, maxWidth, firstLineIndent) => remeasureParagraph(block, maxWidth, firstLineIndent)
   });
   perfLog$1(`[Perf] 4.2 Layout document (pagination): ${(performance.now() - layoutStart).toFixed(2)}ms`);
-  layout.pages.length;
   const maxIterations = 3;
   let currentBlocks = nextBlocks;
   let currentMeasures = measures;
@@ -274800,7 +275348,7 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
     const safeTopPadding = Math.max(0, topPadding);
     const safeDividerHeight = Math.max(0, dividerHeight);
     const continuationDividerHeight = safeDividerHeight;
-    const continuationDividerWidthFactor = 0.3;
+    const SEPARATOR_DEFAULT_WIDTH_FACTOR = 0.5;
     const footnoteWidth = resolveFootnoteMeasurementWidth(options, currentBlocks);
     if (footnoteWidth > 0) {
       const footnoteConstraints = {
@@ -274848,6 +275396,7 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
         const hasContinuationByColumn = /* @__PURE__ */ new Map;
         const rangesByFootnoteId = /* @__PURE__ */ new Map;
         const cappedPages = /* @__PURE__ */ new Set;
+        const ledgersByPage = /* @__PURE__ */ new Map;
         collectFootnoteIdsByColumn(idsByColumn$1).forEach((id2) => {
           const blocks2 = footnotesInput.blocksById.get(id2) ?? [];
           rangesByFootnoteId.set(id2, buildFootnoteRanges(blocks2, measuresById$1));
@@ -274860,25 +275409,23 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
           const maxReserve = computeMaxFootnoteReserve(layoutForPages, pageIndex, baseReserve);
           const columns = pageColumns$1.get(pageIndex);
           const columnCount = Math.max(1, Math.floor(columns?.count ?? 1));
-          let demand = 0;
-          for (let columnIndex = 0;columnIndex < columnCount; columnIndex += 1) {
-            const ids = idsByColumn$1.get(pageIndex)?.get(columnIndex) ?? [];
-            let columnDemand = 0;
-            ids.forEach((id2, idx) => {
-              const ranges = rangesByFootnoteId.get(id2) ?? [];
-              let rangesHeight = 0;
-              ranges.forEach((range) => {
-                const spacingAfter = "spacingAfter" in range ? range.spacingAfter ?? 0 : 0;
-                rangesHeight += range.height + spacingAfter;
-              });
-              columnDemand += rangesHeight + (idx > 0 ? safeGap : 0);
+          const placementCeiling = maxReserve;
+          const fullHeightOf = (id2) => {
+            const ranges = rangesByFootnoteId.get(id2) ?? [];
+            let total = 0;
+            ranges.forEach((range) => {
+              const spacingAfter = "spacingAfter" in range ? range.spacingAfter ?? 0 : 0;
+              total += range.height + spacingAfter;
             });
-            if (columnDemand > 0)
-              columnDemand += safeSeparatorSpacingBefore + safeDividerHeight + safeTopPadding;
-            if (columnDemand > demand)
-              demand = columnDemand;
-          }
-          const placementCeiling = demand > 0 ? Math.min(Math.ceil(demand), maxReserve) : maxReserve;
+            return total;
+          };
+          const firstLineOf = (id2) => {
+            const measured = firstLineHeightById.get(id2);
+            if (typeof measured === "number" && Number.isFinite(measured) && measured > 0)
+              return measured;
+            const ranges = rangesByFootnoteId.get(id2) ?? [];
+            return ranges.length > 0 ? ranges[0].height : 0;
+          };
           const pendingForPage = /* @__PURE__ */ new Map;
           pendingByColumn.forEach((entries2, columnIndex) => {
             const targetIndex = columnIndex < columnCount ? columnIndex : Math.max(0, columnCount - 1);
@@ -274886,6 +275433,21 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
             list5.push(...entries2);
             pendingForPage.set(targetIndex, list5);
           });
+          const continuationInForPage = [];
+          pendingForPage.forEach((entries2) => {
+            entries2.forEach((entry) => {
+              let total = 0;
+              entry.ranges.forEach((range) => {
+                const spacingAfter = "spacingAfter" in range ? range.spacingAfter ?? 0 : 0;
+                total += range.height + spacingAfter;
+              });
+              continuationInForPage.push({
+                id: entry.id,
+                remainingRangeCount: entry.ranges.length,
+                remainingHeightPx: total
+              });
+            });
+          });
           pendingByColumn = /* @__PURE__ */ new Map;
           const pageSlices = [];
           let pageReserve = 0;
@@ -274893,9 +275455,8 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
             let usedHeight = 0;
             const columnSlices = [];
             const nextPending = [];
-            let stopPlacement = false;
             const columnKey = footnoteColumnKey(pageIndex, columnIndex);
-            const placeFootnote = (id2, ranges, isContinuation) => {
+            const placeFootnote = (id2, ranges, isContinuation, isLastOnPage) => {
               if (!ranges || ranges.length === 0)
                 return {
                   placed: false,
@@ -274904,12 +275465,17 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
               const isFirstSlice = columnSlices.length === 0;
               const overhead = isFirstSlice ? (isFirstSlice ? safeSeparatorSpacingBefore : 0) + (isFirstSlice ? isContinuation ? continuationDividerHeight : safeDividerHeight : 0) + safeTopPadding : 0;
               const gapBefore = !isFirstSlice ? safeGap : 0;
-              const { slice: slice2, remainingRanges } = fitFootnoteContent(id2, ranges, Math.max(0, placementCeiling - usedHeight - overhead - gapBefore), pageIndex, columnIndex, isContinuation, measuresById$1, isFirstSlice && placementCeiling > 0);
+              const { slice: slice2, remainingRanges } = fitFootnoteContent(id2, ranges, Math.max(0, placementCeiling - usedHeight - overhead - gapBefore), pageIndex, columnIndex, isContinuation, measuresById$1, (isLastOnPage || isContinuation) && placementCeiling > 0);
               if (slice2.ranges.length === 0)
                 return {
                   placed: false,
                   remaining: ranges
                 };
+              if (!isLastOnPage && !isContinuation && remainingRanges.length > 0)
+                return {
+                  placed: false,
+                  remaining: ranges
+                };
               if (isFirstSlice) {
                 usedHeight += overhead;
                 if (isContinuation)
@@ -274924,19 +275490,25 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
                 remaining: remainingRanges
               };
             };
+            const ids = idsByColumn$1.get(pageIndex)?.get(columnIndex) ?? [];
+            const lastIdx = ids.length - 1;
+            let clusterReserve = 0;
+            for (let i4 = 0;i4 < ids.length; i4 += 1) {
+              clusterReserve += i4 === lastIdx ? firstLineOf(ids[i4]) : fullHeightOf(ids[i4]);
+              if (i4 > 0)
+                clusterReserve += safeGap;
+            }
+            usedHeight += clusterReserve;
             const pending = pendingForPage.get(columnIndex) ?? [];
-            for (const entry of pending) {
-              if (stopPlacement) {
-                nextPending.push(entry);
-                continue;
-              }
+            for (let pendingIdx = 0;pendingIdx < pending.length; pendingIdx += 1) {
+              const entry = pending[pendingIdx];
               if (!entry.ranges || entry.ranges.length === 0)
                 continue;
-              const result = placeFootnote(entry.id, entry.ranges, true);
+              const result = placeFootnote(entry.id, entry.ranges, true, false);
               if (!result.placed) {
-                nextPending.push(entry);
-                stopPlacement = true;
-                continue;
+                for (let deferIdx = pendingIdx;deferIdx < pending.length; deferIdx += 1)
+                  nextPending.push(pending[deferIdx]);
+                break;
               }
               if (result.remaining.length > 0)
                 nextPending.push({
@@ -274944,36 +275516,33 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
                   ranges: result.remaining
                 });
             }
-            if (!stopPlacement) {
-              const ids = idsByColumn$1.get(pageIndex)?.get(columnIndex) ?? [];
-              for (let idIndex = 0;idIndex < ids.length; idIndex += 1) {
-                const id2 = ids[idIndex];
-                const ranges = rangesByFootnoteId.get(id2) ?? [];
-                if (ranges.length === 0)
-                  continue;
-                const result = placeFootnote(id2, ranges, false);
-                if (!result.placed) {
+            usedHeight -= clusterReserve;
+            for (let idIndex = 0;idIndex < ids.length; idIndex += 1) {
+              const id2 = ids[idIndex];
+              const ranges = rangesByFootnoteId.get(id2) ?? [];
+              if (ranges.length === 0)
+                continue;
+              const result = placeFootnote(id2, ranges, false, idIndex === lastIdx);
+              if (!result.placed) {
+                nextPending.push({
+                  id: id2,
+                  ranges
+                });
+                for (let remainingIndex = idIndex + 1;remainingIndex < ids.length; remainingIndex += 1) {
+                  const remainingId = ids[remainingIndex];
+                  const remainingRanges = rangesByFootnoteId.get(remainingId) ?? [];
                   nextPending.push({
-                    id: id2,
-                    ranges
+                    id: remainingId,
+                    ranges: remainingRanges
                   });
-                  for (let remainingIndex = idIndex + 1;remainingIndex < ids.length; remainingIndex += 1) {
-                    const remainingId = ids[remainingIndex];
-                    const remainingRanges = rangesByFootnoteId.get(remainingId) ?? [];
-                    nextPending.push({
-                      id: remainingId,
-                      ranges: remainingRanges
-                    });
-                  }
-                  stopPlacement = true;
-                  break;
                 }
-                if (result.remaining.length > 0)
-                  nextPending.push({
-                    id: id2,
-                    ranges: result.remaining
-                  });
+                break;
               }
+              if (result.remaining.length > 0)
+                nextPending.push({
+                  id: id2,
+                  ranges: result.remaining
+                });
             }
             if (columnSlices.length > 0) {
               const rawReserve = Math.max(0, Math.ceil(usedHeight));
@@ -274988,7 +275557,148 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
           }
           if (pageSlices.length > 0)
             slicesByPage.set(pageIndex, pageSlices);
-          reserves$1[pageIndex] = pageReserve;
+          reserves$1[pageIndex] = Math.max(reserves$1[pageIndex] ?? 0, pageReserve);
+          {
+            const idsOnPage = (() => {
+              const out = [];
+              for (let cIdx = 0;cIdx < columnCount; cIdx += 1) {
+                const colIds = idsByColumn$1.get(pageIndex)?.get(cIdx) ?? [];
+                for (const id2 of colIds)
+                  if (!out.includes(id2))
+                    out.push(id2);
+              }
+              return out;
+            })();
+            const seenNewAnchor = /* @__PURE__ */ new Set;
+            const mandatorySliceIds = [];
+            const continuationSliceIds = [];
+            const extendedSliceIds = [];
+            let actualBandHeight = 0;
+            const overheadBase = Math.max(0, separatorSpacingBefore) + safeDividerHeight + safeTopPadding;
+            for (const slice2 of pageSlices) {
+              if (slice2.isContinuation)
+                continuationSliceIds.push(slice2.id);
+              else if (!seenNewAnchor.has(slice2.id)) {
+                mandatorySliceIds.push(slice2.id);
+                seenNewAnchor.add(slice2.id);
+              } else
+                extendedSliceIds.push(slice2.id);
+              actualBandHeight += slice2.totalHeight;
+            }
+            if (pageSlices.length > 0)
+              actualBandHeight += overheadBase + safeGap * Math.max(0, pageSlices.length - 1);
+            let mandatoryReserve = 0;
+            let preferredReserve = 0;
+            let continuationInHeight = 0;
+            for (const entry of continuationInForPage)
+              continuationInHeight += entry.remainingHeightPx;
+            if (continuationInHeight > 0) {
+              mandatoryReserve += continuationInHeight;
+              preferredReserve += continuationInHeight;
+              if (idsOnPage.length > 0) {
+                mandatoryReserve += safeGap;
+                preferredReserve += safeGap;
+              }
+            }
+            if (idsOnPage.length > 0) {
+              for (let i4 = 0;i4 < idsOnPage.length; i4 += 1) {
+                const isLast = i4 === idsOnPage.length - 1;
+                mandatoryReserve += isLast ? firstLineOf(idsOnPage[i4]) : fullHeightOf(idsOnPage[i4]);
+                preferredReserve += fullHeightOf(idsOnPage[i4]);
+                if (i4 > 0) {
+                  mandatoryReserve += safeGap;
+                  preferredReserve += safeGap;
+                }
+              }
+              mandatoryReserve += overheadBase;
+              preferredReserve += overheadBase;
+            } else if (continuationInHeight > 0) {
+              mandatoryReserve += overheadBase;
+              preferredReserve += overheadBase;
+            }
+            let lastAnchorRenderedLines = 0;
+            if (idsOnPage.length > 0) {
+              const lastId = idsOnPage[idsOnPage.length - 1];
+              for (const slice2 of pageSlices) {
+                if (slice2.id !== lastId || slice2.isContinuation)
+                  continue;
+                for (const range of slice2.ranges)
+                  if (range.kind === "paragraph" || range.kind === "list-item")
+                    lastAnchorRenderedLines += Math.max(0, range.toLine - range.fromLine);
+                  else
+                    lastAnchorRenderedLines += 1;
+              }
+            }
+            const continuationOut = [];
+            pendingByColumn.forEach((entries2) => {
+              entries2.forEach((entry) => {
+                let total = 0;
+                entry.ranges.forEach((range) => {
+                  const spacingAfter = "spacingAfter" in range ? range.spacingAfter ?? 0 : 0;
+                  total += range.height + spacingAfter;
+                });
+                continuationOut.push({
+                  id: entry.id,
+                  remainingRangeCount: entry.ranges.length,
+                  remainingHeightPx: total
+                });
+              });
+            });
+            ledgersByPage.set(pageIndex, {
+              anchorIds: idsOnPage,
+              mandatorySliceIds,
+              continuationSliceIds,
+              extendedSliceIds,
+              continuationIn: continuationInForPage,
+              continuationOut,
+              mandatoryReservePx: Math.ceil(mandatoryReserve),
+              preferredReservePx: Math.ceil(preferredReserve),
+              actualBandHeightPx: Math.ceil(actualBandHeight),
+              lastAnchorRenderedLines
+            });
+          }
+          if (pageIndex + 1 < pageCount) {
+            let continuationDemand = 0;
+            pendingByColumn.forEach((entries2) => {
+              entries2.forEach((entry) => {
+                entry.ranges.forEach((range) => {
+                  const spacingAfter = "spacingAfter" in range ? range.spacingAfter ?? 0 : 0;
+                  continuationDemand += range.height + spacingAfter;
+                });
+              });
+            });
+            let nextClusterDemand = 0;
+            for (let cIdx = 0;cIdx < columnCount; cIdx += 1) {
+              const idsNext = idsByColumn$1.get(pageIndex + 1)?.get(cIdx) ?? [];
+              if (idsNext.length === 0)
+                continue;
+              let columnCluster = 0;
+              for (let i4 = 0;i4 < idsNext.length; i4 += 1) {
+                const isLast = i4 === idsNext.length - 1;
+                columnCluster += isLast ? firstLineOf(idsNext[i4]) : fullHeightOf(idsNext[i4]);
+                if (i4 > 0)
+                  columnCluster += safeGap;
+              }
+              if (columnCluster > nextClusterDemand)
+                nextClusterDemand = columnCluster;
+            }
+            if (continuationDemand > 0 || nextClusterDemand > 0) {
+              const overhead = safeSeparatorSpacingBefore + continuationDividerHeight + safeTopPadding;
+              const nextPage = layoutForPages.pages?.[pageIndex + 1];
+              const nextPageSize = nextPage?.size ?? layoutForPages.pageSize ?? DEFAULT_PAGE_SIZE$1;
+              const nextTop = normalizeMargin(nextPage?.margins?.top, DEFAULT_MARGINS$1.top);
+              const nextBottomRaw = normalizeMargin(nextPage?.margins?.bottom, DEFAULT_MARGINS$1.bottom);
+              const physicalContentHeight = Math.max(0, nextPageSize.h - nextTop - nextBottomRaw);
+              const minBodyHeight = MIN_FOOTNOTE_BODY_HEIGHT * 20;
+              const nextPageMaxBand = Math.max(0, physicalContentHeight - minBodyHeight);
+              const overheadForBand = nextClusterDemand > 0 || continuationDemand > 0 ? overhead : 0;
+              const clusterRoomPx = nextClusterDemand > 0 ? Math.min(nextClusterDemand, Math.max(0, nextPageMaxBand - overheadForBand)) : 0;
+              const continuationRoomPx = Math.max(0, nextPageMaxBand - overheadForBand - clusterRoomPx);
+              const continuationToReservePx = Math.min(continuationDemand, continuationRoomPx);
+              const finalReserve = Math.min(clusterRoomPx + continuationToReservePx + overheadForBand, nextPageMaxBand);
+              reserves$1[pageIndex + 1] = Math.max(reserves$1[pageIndex + 1] ?? 0, Math.ceil(finalReserve));
+            }
+          }
         }
         if (cappedPages.size > 0)
           console.warn("[layout] Footnote reserve capped to preserve body area", { pages: Array.from(cappedPages) });
@@ -275001,7 +275711,8 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
           slicesByPage,
           reserves: reserves$1,
           hasContinuationByColumn,
-          separatorSpacingBefore: safeSeparatorSpacingBefore
+          separatorSpacingBefore: safeSeparatorSpacingBefore,
+          ledgersByPage
         };
       };
       const injectFragments = (layoutForPages, plan$1, measuresById$1, reservesByPageIndex, blockById, pageColumns$1) => {
@@ -275010,6 +275721,23 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
         for (let pageIndex = 0;pageIndex < layoutForPages.pages.length; pageIndex++) {
           const page = layoutForPages.pages[pageIndex];
           page.footnoteReserved = Math.max(0, reservesByPageIndex[pageIndex] ?? plan$1.reserves[pageIndex] ?? 0);
+          const draft = plan$1.ledgersByPage.get(pageIndex);
+          if (draft)
+            page.footnoteLedger = {
+              pageIndex,
+              anchorIds: draft.anchorIds,
+              mandatorySliceIds: draft.mandatorySliceIds,
+              continuationSliceIds: draft.continuationSliceIds,
+              extendedSliceIds: draft.extendedSliceIds,
+              continuationIn: draft.continuationIn,
+              continuationOut: draft.continuationOut,
+              mandatoryReservePx: draft.mandatoryReservePx,
+              preferredReservePx: draft.preferredReservePx,
+              actualBandHeightPx: draft.actualBandHeightPx,
+              appliedBodyReservePx: page.footnoteReserved ?? 0,
+              deadReservePx: Math.max(0, (page.footnoteReserved ?? 0) - draft.actualBandHeightPx),
+              lastAnchorRenderedLines: draft.lastAnchorRenderedLines
+            };
           const slices = plan$1.slicesByPage.get(pageIndex) ?? [];
           if (slices.length === 0)
             continue;
@@ -275025,7 +275753,10 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
             left: marginLeft,
             contentWidth: pageContentWidth
           };
-          const bandTopY = pageSize.h - (page.margins.bottom ?? 0);
+          const physicalBottomMargin = Math.max(0, (page.margins.bottom ?? 0) - (page.footnoteReserved ?? 0));
+          const pageBottomLimit = pageSize.h - physicalBottomMargin;
+          const bodyMaxYValue = page.bodyMaxY;
+          const bodyMaxY = typeof bodyMaxYValue === "number" && Number.isFinite(bodyMaxYValue) ? bodyMaxYValue : pageSize.h - (page.margins.bottom ?? 0);
           const slicesByColumn = /* @__PURE__ */ new Map;
           slices.forEach((slice2) => {
             const columnIndex = Number.isFinite(slice2.columnIndex) ? slice2.columnIndex : 0;
@@ -275044,9 +275775,16 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
               return;
             const columnKey = footnoteColumnKey(pageIndex, columnIndex);
             const isContinuation = plan$1.hasContinuationByColumn.get(columnKey) ?? false;
-            let cursorY = bandTopY + Math.max(0, plan$1.separatorSpacingBefore);
+            const colSeparatorHeight = isContinuation ? continuationDividerHeight : safeDividerHeight;
+            let colTotalBandHeight = Math.max(0, plan$1.separatorSpacingBefore) + colSeparatorHeight + safeTopPadding;
+            for (let s2 = 0;s2 < columnSlices.length; s2 += 1) {
+              colTotalBandHeight += columnSlices[s2].totalHeight;
+              if (s2 > 0)
+                colTotalBandHeight += safeGap;
+            }
+            let cursorY = Math.max(bodyMaxY, pageBottomLimit - colTotalBandHeight) + Math.max(0, plan$1.separatorSpacingBefore);
             const separatorHeight = isContinuation ? continuationDividerHeight : safeDividerHeight;
-            const separatorWidth = isContinuation ? Math.max(0, contentWidth * continuationDividerWidthFactor) : contentWidth;
+            const separatorWidth = isContinuation ? contentWidth : Math.max(0, contentWidth * SEPARATOR_DEFAULT_WIDTH_FACTOR);
             if (separatorHeight > 0 && separatorWidth > 0) {
               const separatorId = isContinuation ? `footnote-continuation-separator-page-${page.number}-col-${columnIndex}` : `footnote-separator-page-${page.number}-col-${columnIndex}`;
               decorativeBlocks.push({
@@ -275222,9 +275960,77 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
           idsByColumn: assignFootnotesToColumns(layoutForPages, footnotesInput.refs, columns)
         };
       };
-      const relayout = (footnoteReservedByPageIndex) => layoutDocument(currentBlocks, currentMeasures, {
+      let bodyHeightById = /* @__PURE__ */ new Map;
+      let firstLineHeightById = /* @__PURE__ */ new Map;
+      const refreshBodyHeights = (measures$1) => {
+        const totalMap = /* @__PURE__ */ new Map;
+        const firstLineMap = /* @__PURE__ */ new Map;
+        footnotesInput.blocksById.forEach((blocks2, footnoteId) => {
+          let total = 0;
+          let firstLine = 0;
+          for (const block of blocks2) {
+            const measure = measures$1.get(block.id);
+            if (!measure)
+              continue;
+            if (measure.kind === "paragraph") {
+              const measureH = measure.totalHeight;
+              if (typeof measureH === "number" && Number.isFinite(measureH))
+                total += measureH;
+              const spacing = block.attrs?.spacing;
+              const after2 = spacing?.after ?? spacing?.lineSpaceAfter;
+              if (typeof after2 === "number" && Number.isFinite(after2) && after2 > 0)
+                total += after2;
+              if (firstLine === 0) {
+                const lines = measure.lines;
+                const lh = lines && lines.length > 0 ? lines[0].lineHeight : undefined;
+                if (typeof lh === "number" && Number.isFinite(lh) && lh > 0)
+                  firstLine = lh;
+              }
+            } else if (measure.kind === "image" || measure.kind === "drawing") {
+              const measureH = measure.height;
+              if (typeof measureH === "number" && Number.isFinite(measureH))
+                total += measureH;
+              if (firstLine === 0 && typeof measureH === "number" && Number.isFinite(measureH))
+                firstLine = measureH;
+            } else if (measure.kind === "table") {
+              const measureH = measure.totalHeight;
+              if (typeof measureH === "number" && Number.isFinite(measureH))
+                total += measureH;
+              if (firstLine === 0 && typeof measureH === "number" && Number.isFinite(measureH))
+                firstLine = measureH;
+            } else if (measure.kind === "list" && block.kind === "list") {
+              for (const item of block.items) {
+                const itemMeasure = measure.items.find((entry) => entry.itemId === item.id);
+                if (!itemMeasure?.paragraph?.lines)
+                  continue;
+                for (const line of itemMeasure.paragraph.lines)
+                  total += line.lineHeight ?? 0;
+                total += getParagraphSpacingAfter(item.paragraph);
+              }
+              if (firstLine === 0) {
+                const lh = measure.items[0]?.paragraph?.lines?.[0]?.lineHeight;
+                if (typeof lh === "number" && Number.isFinite(lh) && lh > 0)
+                  firstLine = lh;
+              }
+            }
+          }
+          if (total > 0)
+            totalMap.set(footnoteId, total);
+          if (firstLine > 0)
+            firstLineMap.set(footnoteId, firstLine);
+        });
+        bodyHeightById = totalMap;
+        firstLineHeightById = firstLineMap;
+      };
+      const relayout = (footnoteReservedByPageIndex, plannerSeparatorSpacingBefore) => layoutDocument(currentBlocks, currentMeasures, {
         ...options,
         footnoteReservedByPageIndex,
+        footnotes: {
+          ...footnotesInput,
+          bodyHeightById,
+          firstLineHeightById,
+          ...typeof plannerSeparatorSpacingBefore === "number" && Number.isFinite(plannerSeparatorSpacingBefore) ? { separatorSpacingBefore: plannerSeparatorSpacingBefore } : {}
+        },
         headerContentHeights,
         footerContentHeights,
         headerContentHeightsBySectionRef,
@@ -275233,17 +276039,20 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
         footerContentHeightsByRId,
         remeasureParagraph: (block, maxWidth, firstLineIndent) => remeasureParagraph(block, maxWidth, firstLineIndent)
       });
+      const allFootnoteIds = new Set(footnotesInput.refs.map((ref$1) => ref$1.id));
       let { columns: pageColumns, idsByColumn } = resolveFootnoteAssignments(layout);
-      let { measuresById } = await measureFootnoteBlocks(collectFootnoteIdsByColumn(idsByColumn));
+      let { measuresById } = await measureFootnoteBlocks(allFootnoteIds);
+      refreshBodyHeights(measuresById);
       let plan = computeFootnoteLayoutPlan(layout, idsByColumn, measuresById, [], pageColumns);
       let reserves = plan.reserves;
       if (reserves.some((h$2) => h$2 > 0)) {
         let reservesStabilized = false;
         const seenReserveVectors = [reserves.slice()];
         for (let pass = 0;pass < MAX_FOOTNOTE_LAYOUT_PASSES; pass += 1) {
-          layout = relayout(reserves);
+          layout = relayout(reserves, plan.separatorSpacingBefore);
           ({ columns: pageColumns, idsByColumn } = resolveFootnoteAssignments(layout));
-          ({ measuresById } = await measureFootnoteBlocks(collectFootnoteIdsByColumn(idsByColumn)));
+          ({ measuresById } = await measureFootnoteBlocks(allFootnoteIds));
+          refreshBodyHeights(measuresById);
           plan = computeFootnoteLayoutPlan(layout, idsByColumn, measuresById, reserves, pageColumns);
           const nextReserves = plan.reserves;
           if (nextReserves.length === reserves.length && nextReserves.every((h$2, i4) => (reserves[i4] ?? 0) === h$2) && reserves.every((h$2, i4) => (nextReserves[i4] ?? 0) === h$2)) {
@@ -275270,12 +276079,53 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
           return true;
         };
         const applyReserves = async (target) => {
-          layout = relayout(target);
+          layout = relayout(target, finalPlan.separatorSpacingBefore);
           reservesAppliedToLayout = target;
           ({ columns: finalPageColumns, idsByColumn: finalIdsByColumn } = resolveFootnoteAssignments(layout));
-          ({ blocks: finalBlocks, measuresById: finalMeasuresById } = await measureFootnoteBlocks(collectFootnoteIdsByColumn(finalIdsByColumn)));
+          ({ blocks: finalBlocks, measuresById: finalMeasuresById } = await measureFootnoteBlocks(allFootnoteIds));
+          refreshBodyHeights(finalMeasuresById);
           finalPlan = computeFootnoteLayoutPlan(layout, finalIdsByColumn, finalMeasuresById, reservesAppliedToLayout, finalPageColumns);
         };
+        const buildFootnoteLedgers = (plan$1, appliedReserves, pageCount) => {
+          const ledgers = [];
+          for (let pageIndex = 0;pageIndex < pageCount; pageIndex += 1) {
+            const draft = plan$1.ledgersByPage.get(pageIndex);
+            if (!draft)
+              continue;
+            const appliedBodyReservePx = Math.max(0, appliedReserves[pageIndex] ?? plan$1.reserves[pageIndex] ?? 0);
+            ledgers.push({
+              pageIndex,
+              anchorIds: draft.anchorIds,
+              mandatorySliceIds: draft.mandatorySliceIds,
+              continuationSliceIds: draft.continuationSliceIds,
+              extendedSliceIds: draft.extendedSliceIds,
+              continuationIn: draft.continuationIn,
+              continuationOut: draft.continuationOut,
+              mandatoryReservePx: draft.mandatoryReservePx,
+              preferredReservePx: draft.preferredReservePx,
+              actualBandHeightPx: draft.actualBandHeightPx,
+              appliedBodyReservePx,
+              deadReservePx: Math.max(0, appliedBodyReservePx - draft.actualBandHeightPx),
+              lastAnchorRenderedLines: draft.lastAnchorRenderedLines
+            });
+          }
+          return ledgers;
+        };
+        const capReserveForRelayout = (requestedReserve, pageIndex, referenceLayout, referenceReserves) => {
+          const requested = Number.isFinite(requestedReserve) ? Math.max(0, requestedReserve) : 0;
+          const page = referenceLayout.pages?.[pageIndex];
+          if (!page)
+            return requested;
+          const pageSize = page.size ?? referenceLayout.pageSize ?? DEFAULT_PAGE_SIZE$1;
+          const topMargin = normalizeMargin(page.margins?.top, DEFAULT_MARGINS$1.top);
+          const bottomWithReserve = normalizeMargin(page.margins?.bottom, DEFAULT_MARGINS$1.bottom);
+          const currentReserve = Number.isFinite(referenceReserves[pageIndex]) ? Math.max(0, referenceReserves[pageIndex]) : 0;
+          const physicalBottomMargin = Math.max(0, bottomWithReserve - currentReserve);
+          const physicalContentHeight = pageSize.h - topMargin - physicalBottomMargin;
+          if (!Number.isFinite(physicalContentHeight))
+            return requested;
+          return Math.min(requested, Math.max(0, physicalContentHeight - MIN_FOOTNOTE_BODY_HEIGHT));
+        };
         const growReserves = async (maxPasses) => {
           const seen = [reservesAppliedToLayout.slice()];
           for (let pass = 0;pass < maxPasses; pass += 1) {
@@ -275301,6 +276151,74 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
           }
           return false;
         };
+        const GROW_MAX_PASSES = 10;
+        const PREFERRED_RESERVE_MAX_CANDIDATES = 12;
+        const PREFERRED_RESERVE_MAX_ACCEPTED_CANDIDATES = PREFERRED_RESERVE_MAX_CANDIDATES;
+        const PREFERRED_RESERVE_WINDOW_AHEAD = 3;
+        const runPreferredReserveTrials = async () => {
+          let acceptedPreferredTrials = 0;
+          let rejectedPreferredTrials = 0;
+          const rejectedPreferredPages = /* @__PURE__ */ new Set;
+          for (let candidatePass = 0;candidatePass < PREFERRED_RESERVE_MAX_CANDIDATES; candidatePass += 1) {
+            const beforeLayout = layout;
+            const beforePlan = finalPlan;
+            const beforeReserves = reservesAppliedToLayout.slice();
+            const beforeLedgers = buildFootnoteLedgers(beforePlan, beforeReserves, beforeLayout.pages.length);
+            const candidate = getPreferredReserveCandidates(beforeLedgers).find((entry) => !rejectedPreferredPages.has(entry.pageIndex));
+            if (!candidate)
+              break;
+            const targetReserves = getPreferredReserveTrialTargets(candidate, beforeReserves[candidate.pageIndex] ?? 0);
+            let acceptedCandidate = false;
+            for (const targetReserve of targetReserves) {
+              const trialReserves = beforeReserves.slice();
+              const cappedPreferredReserve = capReserveForRelayout(targetReserve, candidate.pageIndex, beforeLayout, beforeReserves);
+              trialReserves[candidate.pageIndex] = Math.max(trialReserves[candidate.pageIndex] ?? 0, cappedPreferredReserve);
+              await applyReserves(trialReserves);
+              const trialConverged = await growReserves(GROW_MAX_PASSES);
+              const afterLedgers = buildFootnoteLedgers(finalPlan, reservesAppliedToLayout, layout.pages.length);
+              const score = scoreFootnoteWindow({
+                beforeLayout,
+                afterLayout: layout,
+                candidatePageIndex: candidate.pageIndex,
+                candidateAnchorId: candidate.anchorIds[candidate.anchorIds.length - 1],
+                beforeLedger: beforeLedgers,
+                afterLedger: afterLedgers,
+                windowAhead: PREFERRED_RESERVE_WINDOW_AHEAD
+              });
+              if (trialConverged && score.accept) {
+                if (layoutDebugEnabled$1)
+                  console.log("[incrementalLayout] Accepted footnote preferred-reserve trial", {
+                    pageIndex: candidate.pageIndex,
+                    targetReserve,
+                    score
+                  });
+                acceptedPreferredTrials += 1;
+                acceptedCandidate = true;
+                break;
+              }
+              if (layoutDebugEnabled$1)
+                console.log("[incrementalLayout] Rejected footnote preferred-reserve trial", {
+                  pageIndex: candidate.pageIndex,
+                  targetReserve,
+                  trialConverged,
+                  score
+                });
+              await applyReserves(beforeReserves);
+            }
+            if (acceptedCandidate) {
+              if (acceptedPreferredTrials >= PREFERRED_RESERVE_MAX_ACCEPTED_CANDIDATES)
+                break;
+              continue;
+            }
+            rejectedPreferredTrials += 1;
+            rejectedPreferredPages.add(candidate.pageIndex);
+          }
+          if (layoutDebugEnabled$1 && (acceptedPreferredTrials > 0 || rejectedPreferredTrials > 0))
+            console.log("[incrementalLayout] Footnote preferred-reserve trials", {
+              accepted: acceptedPreferredTrials,
+              rejected: rejectedPreferredTrials
+            });
+        };
         const TIGHTEN_SLACK_PX = 8;
         if ((() => {
           const plan$1 = finalPlan.reserves;
@@ -275313,10 +276231,11 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
               return true;
             if (a2 >= TIGHTEN_SLACK_PX && p$12 === 0)
               return true;
+            if (a2 >= TIGHTEN_SLACK_PX && a2 - p$12 > TIGHTEN_SLACK_PX)
+              return true;
           }
           return false;
         })()) {
-          const GROW_MAX_PASSES = 10;
           if (!await growReserves(GROW_MAX_PASSES))
             console.warn("[incrementalLayout] Footnote post-reserve loop did not converge; some pages may have footnotes overflowing the reserved band.");
           const MAX_TIGHTEN_ITERATIONS = 8;
@@ -275325,16 +276244,26 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
             for (let i4 = 0;i4 < reservesAppliedToLayout.length; i4 += 1) {
               const applied = reservesAppliedToLayout[i4] ?? 0;
               const planned = finalPlan.reserves[i4] ?? 0;
-              if (applied >= TIGHTEN_SLACK_PX && planned === 0)
-                pagesToTighten.push(i4);
+              if (applied < TIGHTEN_SLACK_PX)
+                continue;
+              if (planned === 0)
+                pagesToTighten.push({
+                  i: i4,
+                  target: 0
+                });
+              else if (applied - planned > TIGHTEN_SLACK_PX)
+                pagesToTighten.push({
+                  i: i4,
+                  target: planned
+                });
             }
             if (pagesToTighten.length === 0)
               break;
             const safeApplied = reservesAppliedToLayout.slice();
             const safePageCount = layout.pages.length;
             const tightened = reservesAppliedToLayout.slice();
-            for (const i4 of pagesToTighten)
-              tightened[i4] = 0;
+            for (const { i: i4, target } of pagesToTighten)
+              tightened[i4] = target;
             await applyReserves(tightened);
             if (!await growReserves(GROW_MAX_PASSES) || layout.pages.length > safePageCount) {
               await applyReserves(safeApplied);
@@ -275342,6 +276271,30 @@ async function incrementalLayout(previousBlocks, _previousLayout, nextBlocks, op
             }
           }
         }
+        const ONE_LINE_TAIL_PX = 24;
+        const runWidowOrphanAbsorb = async () => {
+          const ledgers = buildFootnoteLedgers(finalPlan, reservesAppliedToLayout, layout.pages.length);
+          const target = reservesAppliedToLayout.slice();
+          let bumped = 0;
+          for (const ledger of ledgers) {
+            const tailPx = ledger.continuationOut.reduce((s2, e) => s2 + (e.remainingHeightPx || 0), 0);
+            if (tailPx <= 0 || tailPx > ONE_LINE_TAIL_PX)
+              continue;
+            const requested = capReserveForRelayout(ledger.preferredReservePx, ledger.pageIndex, layout, reservesAppliedToLayout);
+            if (requested > (target[ledger.pageIndex] ?? 0)) {
+              target[ledger.pageIndex] = requested;
+              bumped += 1;
+            }
+          }
+          if (bumped === 0)
+            return;
+          const safeApplied = reservesAppliedToLayout.slice();
+          await applyReserves(target);
+          if (!await growReserves(GROW_MAX_PASSES))
+            await applyReserves(safeApplied);
+        };
+        await runWidowOrphanAbsorb();
+        await runPreferredReserveTrials();
         const blockById = /* @__PURE__ */ new Map;
         finalBlocks.forEach((block) => {
           blockById.set(block.id, block);
@@ -277757,15 +278710,95 @@ function createLayoutMetrics(perf, startMark, layout, blocks2) {
     pageCount: layout.pages?.length ?? 0
   };
 }
+function computeNoteNumbering(editorState, noteTypeName, options) {
+  const numberById = {};
+  const formatById = {};
+  const order$1 = [];
+  if (!editorState)
+    return {
+      numberById,
+      order: order$1
+    };
+  const seen = /* @__PURE__ */ new Set;
+  const sectionConfigs = options.sectionConfigs ?? /* @__PURE__ */ new Map;
+  const refPageById = options.refPageById;
+  let sectionIndex = 0;
+  let lastPage = null;
+  let anyOverride = false;
+  const restartFor = (s2) => sectionConfigs.get(s2)?.numRestart ?? options.defaultRestart ?? "continuous";
+  const numStartFor = (s2) => sectionConfigs.get(s2)?.numStart ?? options.startCounter;
+  const numFmtFor = (s2) => sectionConfigs.get(s2)?.numFmt ?? options.defaultNumFmt;
+  let counter = numStartFor(0);
+  try {
+    editorState.doc?.descendants?.((node3) => {
+      const typeName = node3?.type?.name;
+      if (typeName === "sectionBreak") {
+        const nextSection = sectionIndex + 1;
+        const nextRestart = restartFor(nextSection);
+        if (nextRestart === "eachSect" || nextRestart === "eachPage") {
+          counter = numStartFor(nextSection);
+          lastPage = null;
+        }
+        sectionIndex = nextSection;
+        return;
+      }
+      if (typeName !== noteTypeName)
+        return;
+      const rawId = node3?.attrs?.id;
+      if (rawId == null)
+        return;
+      const key2 = String(rawId);
+      if (!key2 || seen.has(key2))
+        return;
+      seen.add(key2);
+      order$1.push(key2);
+      if (isCustomMarkFollows2(node3?.attrs?.customMarkFollows))
+        return;
+      if (refPageById && restartFor(sectionIndex) === "eachPage") {
+        const thisPage = refPageById.get(key2) ?? 0;
+        if (lastPage !== null && thisPage !== lastPage)
+          counter = numStartFor(sectionIndex);
+        lastPage = thisPage;
+      }
+      numberById[key2] = counter;
+      const fmt = numFmtFor(sectionIndex);
+      if (fmt) {
+        formatById[key2] = fmt;
+        if (sectionConfigs.has(sectionIndex) && sectionConfigs.get(sectionIndex)?.numFmt)
+          anyOverride = true;
+      }
+      counter += 1;
+    });
+  } catch (_$1) {}
+  return anyOverride ? {
+    numberById,
+    formatById,
+    order: order$1
+  } : {
+    numberById,
+    order: order$1
+  };
+}
+function isCustomMarkFollows2(value) {
+  if (value === true || value === 1)
+    return true;
+  if (typeof value !== "string")
+    return false;
+  const v = value.trim().toLowerCase();
+  return v === "1" || v === "true" || v === "on";
+}
 function buildFootnotesInput(editorState, converter, converterContext, themeColors, renderOverride = null, resolveTrackedChangeColor) {
   if (!editorState)
     return null;
   const footnoteNumberById = converterContext?.footnoteNumberById;
+  const footnoteNumberFormat = converterContext?.footnoteNumberFormat;
+  const footnoteFormatById = converterContext?.footnoteFormatById;
   const importedFootnotes = Array.isArray(converter?.footnotes) ? converter.footnotes : [];
   if (importedFootnotes.length === 0)
     return null;
   const refs = [];
   const idsInUse = /* @__PURE__ */ new Set;
+  const customMarkIds = /* @__PURE__ */ new Set;
   editorState.doc.descendants((node3, pos) => {
     if (node3.type?.name !== "footnoteReference")
       return;
@@ -277779,6 +278812,8 @@ function buildFootnotesInput(editorState, converter, converterContext, themeColo
       pos: insidePos
     });
     idsInUse.add(key2);
+    if (isCustomMarkFollows2(node3.attrs?.customMarkFollows))
+      customMarkIds.add(key2);
   });
   if (refs.length === 0)
     return null;
@@ -277801,7 +278836,10 @@ function buildFootnotesInput(editorState, converter, converterContext, themeColo
         resolveTrackedChangeColor
       });
       if (result?.blocks?.length) {
-        ensureFootnoteMarker(result.blocks, id2, footnoteNumberById);
+        if (!customMarkIds.has(id2)) {
+          const numFmtForId = footnoteFormatById?.[id2] ?? footnoteNumberFormat;
+          ensureFootnoteMarker(result.blocks, id2, footnoteNumberById, numFmtForId);
+        }
         blocksById.set(id2, result.blocks);
       }
     } catch (_$1) {}
@@ -277827,9 +278865,6 @@ function resolveDisplayNumber$1(id2, footnoteNumberById) {
     return num;
   return 1;
 }
-function resolveMarkerText(value) {
-  return String(value ?? "");
-}
 function resolveMarkerFontFamily$1(firstTextRun) {
   return typeof firstTextRun?.fontFamily === "string" ? firstTextRun.fontFamily : DEFAULT_MARKER_FONT_FAMILY$1;
 }
@@ -277841,18 +278876,12 @@ function resolveMarkerBaseFontSize$1(firstTextRun) {
 function buildMarkerRun$1(markerText, firstTextRun) {
   const markerRun = {
     kind: "text",
-    text: markerText,
+    text: `${markerText} `,
     dataAttrs: { [FOOTNOTE_MARKER_DATA_ATTR]: "true" },
     fontFamily: resolveMarkerFontFamily$1(firstTextRun),
     fontSize: resolveMarkerBaseFontSize$1(firstTextRun) * SUBSCRIPT_SUPERSCRIPT_SCALE,
     vertAlign: "superscript"
   };
-  if (typeof firstTextRun?.bold === "boolean")
-    markerRun.bold = firstTextRun.bold;
-  if (typeof firstTextRun?.italic === "boolean")
-    markerRun.italic = firstTextRun.italic;
-  if (typeof firstTextRun?.letterSpacing === "number" && Number.isFinite(firstTextRun.letterSpacing))
-    markerRun.letterSpacing = firstTextRun.letterSpacing;
   if (firstTextRun?.color != null)
     markerRun.color = firstTextRun.color;
   return markerRun;
@@ -277889,12 +278918,12 @@ function syncMarkerRun$1(target, source) {
   delete target.pmStart;
   delete target.pmEnd;
 }
-function ensureFootnoteMarker(blocks2, id2, footnoteNumberById) {
+function ensureFootnoteMarker(blocks2, id2, footnoteNumberById, footnoteNumberFormat) {
   const firstParagraph = blocks2.find((b$1) => b$1?.kind === "paragraph");
   if (!firstParagraph)
     return;
   const runs2 = Array.isArray(firstParagraph.runs) ? firstParagraph.runs : [];
-  const normalizedMarkerRun = buildMarkerRun$1(resolveMarkerText(resolveDisplayNumber$1(id2, footnoteNumberById)), runs2.find((run2) => typeof run2.text === "string" && !isFootnoteMarker(run2)));
+  const normalizedMarkerRun = buildMarkerRun$1(formatFootnoteCardinal(resolveDisplayNumber$1(id2, footnoteNumberById), footnoteNumberFormat), runs2.find((run2) => typeof run2.text === "string" && !isFootnoteMarker(run2)));
   const existingMarker = runs2.find(isFootnoteMarker);
   if (existingMarker) {
     syncMarkerRun$1(existingMarker, normalizedMarkerRun);
@@ -283847,11 +284876,14 @@ function buildEndnoteBlocks(editorState, converter, converterContext, themeColor
   if (!editorState)
     return [];
   const endnoteNumberById = converterContext?.endnoteNumberById;
+  const endnoteNumberFormat = converterContext?.endnoteNumberFormat;
+  const endnoteFormatById = converterContext?.endnoteFormatById;
   const importedEndnotes = Array.isArray(converter?.endnotes) ? converter.endnotes : [];
   if (importedEndnotes.length === 0)
     return [];
   const orderedEndnoteIds = [];
   const seen = /* @__PURE__ */ new Set;
+  const customMarkIds = /* @__PURE__ */ new Set;
   editorState.doc.descendants((node3) => {
     if (node3.type?.name !== "endnoteReference")
       return;
@@ -283863,6 +284895,8 @@ function buildEndnoteBlocks(editorState, converter, converterContext, themeColor
       return;
     seen.add(key2);
     orderedEndnoteIds.push(key2);
+    if (isCustomMarkFollows2(node3.attrs?.customMarkFollows))
+      customMarkIds.add(key2);
   });
   if (orderedEndnoteIds.length === 0)
     return [];
@@ -283885,7 +284919,10 @@ function buildEndnoteBlocks(editorState, converter, converterContext, themeColor
         resolveTrackedChangeColor
       });
       if (result?.blocks?.length) {
-        ensureEndnoteMarker(result.blocks, id2, endnoteNumberById);
+        if (!customMarkIds.has(id2)) {
+          const numFmtForId = endnoteFormatById?.[id2] ?? endnoteNumberFormat;
+          ensureEndnoteMarker(result.blocks, id2, endnoteNumberById, numFmtForId);
+        }
         blocks2.push(...result.blocks);
       }
     } catch {}
@@ -283917,18 +284954,12 @@ function resolveMarkerBaseFontSize(firstTextRun) {
 function buildMarkerRun(markerText, firstTextRun) {
   const markerRun = {
     kind: "text",
-    text: markerText,
+    text: `${markerText} `,
     dataAttrs: { [ENDNOTE_MARKER_DATA_ATTR]: "true" },
     fontFamily: resolveMarkerFontFamily(firstTextRun),
     fontSize: resolveMarkerBaseFontSize(firstTextRun) * SUBSCRIPT_SUPERSCRIPT_SCALE,
     vertAlign: "superscript"
   };
-  if (typeof firstTextRun?.bold === "boolean")
-    markerRun.bold = firstTextRun.bold;
-  if (typeof firstTextRun?.italic === "boolean")
-    markerRun.italic = firstTextRun.italic;
-  if (typeof firstTextRun?.letterSpacing === "number" && Number.isFinite(firstTextRun.letterSpacing))
-    markerRun.letterSpacing = firstTextRun.letterSpacing;
   if (firstTextRun?.color != null)
     markerRun.color = firstTextRun.color;
   return markerRun;
@@ -283965,14 +284996,14 @@ function resolveEndnoteDocJson(id2, importedEndnotes, renderOverride) {
     content: cloneNoteContentJson(content3)
   });
 }
-function ensureEndnoteMarker(blocks2, id2, endnoteNumberById) {
+function ensureEndnoteMarker(blocks2, id2, endnoteNumberById, endnoteNumberFormat) {
   const firstParagraph = blocks2.find((block) => block.kind === "paragraph");
   if (!firstParagraph)
     return;
   const runs2 = Array.isArray(firstParagraph.runs) ? firstParagraph.runs : [];
   firstParagraph.runs = runs2;
   const firstTextRun = runs2.find((run2) => isTextRun$12(run2) && !isEndnoteMarker(run2) && run2.text.length > 0);
-  const markerRun = buildMarkerRun(String(resolveDisplayNumber(id2, endnoteNumberById)), firstTextRun);
+  const markerRun = buildMarkerRun(formatFootnoteCardinal(resolveDisplayNumber(id2, endnoteNumberById), endnoteNumberFormat), firstTextRun);
   if (runs2[0] && isTextRun$12(runs2[0]) && isEndnoteMarker(runs2[0])) {
     syncMarkerRun(runs2[0], markerRun);
     return;
@@ -284192,6 +285223,22 @@ function ensureEditorMovableObjectInteractionStyles(doc$12) {
   doc$12.head?.appendChild(styleEl);
   movableObjectInteractionStylesInjected = true;
 }
+function serializeSectionConfigs(map$12) {
+  if (map$12.size === 0)
+    return "";
+  return [...map$12.entries()].sort((a2, b$1) => a2[0] - b$1[0]).map(([i4, c]) => `${i4}:${c.numFmt ?? ""}/${c.numStart ?? ""}/${c.numRestart ?? ""}`).join(";");
+}
+function serializePerIdNumbering(order$1, numberById, formatById) {
+  if (order$1.length === 0)
+    return "";
+  const parts = [];
+  for (const id2 of order$1) {
+    const n = numberById[id2];
+    const f2 = formatById?.[id2] ?? "";
+    parts.push(`${id2}:${n ?? ""}/${f2}`);
+  }
+  return parts.join(";");
+}
 function parseRenderedNoteTarget(blockId) {
   if (typeof blockId !== "string" || blockId.length === 0)
     return null;
@@ -305205,6 +306252,10 @@ menclose::after {
     markerEl.style.color = run2.color;
   if (run2.letterSpacing != null)
     markerEl.style.letterSpacing = `${run2.letterSpacing}px`;
+  if (run2.allCaps)
+    markerEl.style.textTransform = "uppercase";
+  else if (run2.smallCaps)
+    markerEl.style.fontVariant = "small-caps";
   markerContainer.appendChild(markerEl);
   if (sourceAnchor)
     applySourceAnchorDataset(markerEl, sourceAnchor);
@@ -313166,6 +314217,208 @@ menclose::after {
     this.constraintsHash = "";
     this.sectionMetadataHash = "";
   }
+}, DEFAULT_WINDOW_AHEAD = 3, DEFAULT_PREFERRED_DELTA_THRESHOLD_PX = 8, DEFAULT_MANDATORY_ONLY_TOLERANCE_PX = 2, DEFAULT_DEAD_RESERVE_BLOAT_THRESHOLD_PX = 128, DEFAULT_WHOLE_DOCUMENT_DEAD_RESERVE_BLOAT_THRESHOLD_PX = 128, FULL_ANCHOR_RENDER_SENTINEL, DEFAULT_TRIAL_TARGET_COUNT = 12, isMandatoryOnlyFootnotePage = (ledger, preferredDeltaThresholdPx = DEFAULT_PREFERRED_DELTA_THRESHOLD_PX, mandatoryOnlyTolerancePx = DEFAULT_MANDATORY_ONLY_TOLERANCE_PX) => {
+  if (ledger.anchorIds.length === 0)
+    return false;
+  return Math.abs(ledger.actualBandHeightPx - ledger.mandatoryReservePx) <= mandatoryOnlyTolerancePx && ledger.preferredReservePx - ledger.mandatoryReservePx > preferredDeltaThresholdPx && ledger.lastAnchorRenderedLines <= 1;
+}, isSplitLastAnchorFootnotePage = (ledger, preferredDeltaThresholdPx = DEFAULT_PREFERRED_DELTA_THRESHOLD_PX) => {
+  if (ledger.anchorIds.length === 0)
+    return false;
+  const lastAnchorId = ledger.anchorIds[ledger.anchorIds.length - 1];
+  if (!ledger.continuationOut.some((entry) => entry.id === lastAnchorId))
+    return false;
+  return ledger.preferredReservePx - ledger.mandatoryReservePx > preferredDeltaThresholdPx && ledger.actualBandHeightPx < ledger.preferredReservePx - preferredDeltaThresholdPx;
+}, getPreferredReserveCandidates = (ledgers, preferredDeltaThresholdPx = DEFAULT_PREFERRED_DELTA_THRESHOLD_PX, mandatoryOnlyTolerancePx = DEFAULT_MANDATORY_ONLY_TOLERANCE_PX) => {
+  return ledgers.filter((ledger) => isMandatoryOnlyFootnotePage(ledger, preferredDeltaThresholdPx, mandatoryOnlyTolerancePx) || isSplitLastAnchorFootnotePage(ledger, preferredDeltaThresholdPx)).map((ledger) => ({
+    pageIndex: ledger.pageIndex,
+    anchorIds: ledger.anchorIds.slice(),
+    mandatoryReservePx: ledger.mandatoryReservePx,
+    preferredReservePx: ledger.preferredReservePx,
+    reserveDeltaPx: ledger.preferredReservePx - ledger.mandatoryReservePx,
+    actualBandHeightPx: ledger.actualBandHeightPx,
+    lastAnchorRenderedLines: ledger.lastAnchorRenderedLines
+  }));
+}, getPreferredReserveTrialTargets = (candidate, currentReservePx, preferredDeltaThresholdPx = DEFAULT_PREFERRED_DELTA_THRESHOLD_PX, maxTargets = DEFAULT_TRIAL_TARGET_COUNT) => {
+  const current = Number.isFinite(currentReservePx) ? Math.max(0, currentReservePx) : 0;
+  const floor$1 = Math.max(current, candidate.mandatoryReservePx);
+  const ceiling = Math.max(floor$1, candidate.preferredReservePx);
+  const delta = ceiling - floor$1;
+  if (delta <= preferredDeltaThresholdPx)
+    return [];
+  const targets = /* @__PURE__ */ new Set;
+  const addTarget = (value) => {
+    if (!Number.isFinite(value))
+      return;
+    const rounded = Math.ceil(Math.max(floor$1, Math.min(ceiling, value)));
+    if (rounded - floor$1 > preferredDeltaThresholdPx)
+      targets.add(rounded);
+  };
+  [
+    1,
+    0.75,
+    0.5,
+    0.33,
+    0.25,
+    0.15
+  ].forEach((fraction) => addTarget(floor$1 + delta * fraction));
+  [
+    96,
+    72,
+    48,
+    24,
+    12
+  ].forEach((px) => addTarget(floor$1 + Math.min(delta, px)));
+  return Array.from(targets).sort((a2, b$1) => b$1 - a2).slice(0, Math.max(1, maxTargets));
+}, getWindowBounds = (layout, candidatePageIndex, windowAhead) => ({
+  windowStart: Math.max(0, candidatePageIndex),
+  windowEnd: Math.min(layout.pages.length - 1, candidatePageIndex + Math.max(0, windowAhead))
+}), getDocumentBounds = (layout) => ({
+  windowStart: 0,
+  windowEnd: Math.max(0, layout.pages.length - 1)
+}), isInWindow = (ledger, windowStart, windowEnd) => ledger.pageIndex >= windowStart && ledger.pageIndex <= windowEnd, getLastAnchorId = (ledger) => {
+  if (!ledger || ledger.anchorIds.length === 0)
+    return;
+  return ledger.anchorIds[ledger.anchorIds.length - 1];
+}, collectLedgerDiagnostics = (ledgers, windowStart, windowEnd, preferredDeltaThresholdPx, mandatoryOnlyTolerancePx) => {
+  const diagnostics = {
+    mandatoryOnlyCount: 0,
+    mandatoryOnlyAnchorIds: /* @__PURE__ */ new Set,
+    deadReserveSum: 0,
+    clusterSplitCount: 0,
+    clusterSplitAnchorIds: /* @__PURE__ */ new Set
+  };
+  for (const ledger of ledgers) {
+    if (!isInWindow(ledger, windowStart, windowEnd))
+      continue;
+    diagnostics.deadReserveSum += Math.max(0, ledger.deadReservePx);
+    if (isMandatoryOnlyFootnotePage(ledger, preferredDeltaThresholdPx, mandatoryOnlyTolerancePx)) {
+      diagnostics.mandatoryOnlyCount += 1;
+      const id2 = getLastAnchorId(ledger);
+      if (id2)
+        diagnostics.mandatoryOnlyAnchorIds.add(id2);
+    }
+    const anchorIds = new Set(ledger.anchorIds);
+    let splitsCurrentAnchorCluster = false;
+    for (const entry of ledger.continuationOut) {
+      if (!anchorIds.has(entry.id))
+        continue;
+      diagnostics.clusterSplitAnchorIds.add(entry.id);
+      splitsCurrentAnchorCluster = true;
+    }
+    if (splitsCurrentAnchorCluster)
+      diagnostics.clusterSplitCount += 1;
+  }
+  return diagnostics;
+}, hasNewId = (after2, before2) => {
+  for (const id2 of after2)
+    if (!before2.has(id2))
+      return true;
+  return false;
+}, getCandidateRenderedLines = (ledgers, candidateAnchorId) => {
+  if (!candidateAnchorId)
+    return;
+  const anchorLedger = ledgers.find((ledger) => ledger.anchorIds.includes(candidateAnchorId));
+  if (!anchorLedger)
+    return;
+  if (getLastAnchorId(anchorLedger) === candidateAnchorId)
+    return anchorLedger.lastAnchorRenderedLines;
+  return FULL_ANCHOR_RENDER_SENTINEL;
+}, candidateRenderedLinesImproved = (before2, after2) => typeof before2.candidateRenderedLines === "number" && typeof after2.candidateRenderedLines === "number" && after2.candidateRenderedLines > before2.candidateRenderedLines, summarizeFootnoteWindow = (layout, ledgers, candidatePageIndex, windowAhead = DEFAULT_WINDOW_AHEAD, preferredDeltaThresholdPx = DEFAULT_PREFERRED_DELTA_THRESHOLD_PX, mandatoryOnlyTolerancePx = DEFAULT_MANDATORY_ONLY_TOLERANCE_PX, candidateAnchorId) => {
+  const { windowStart, windowEnd } = getWindowBounds(layout, candidatePageIndex, windowAhead);
+  const diagnostics = collectLedgerDiagnostics(ledgers, windowStart, windowEnd, preferredDeltaThresholdPx, mandatoryOnlyTolerancePx);
+  return {
+    totalPages: layout.pages.length,
+    mandatoryOnlyCount: diagnostics.mandatoryOnlyCount,
+    deadReserveSum: diagnostics.deadReserveSum,
+    clusterSplitCount: diagnostics.clusterSplitCount,
+    candidateRenderedLines: getCandidateRenderedLines(ledgers, candidateAnchorId)
+  };
+}, scoreFootnoteWindow = (input2) => {
+  const windowAhead = input2.windowAhead ?? DEFAULT_WINDOW_AHEAD;
+  const preferredDeltaThresholdPx = input2.preferredDeltaThresholdPx ?? DEFAULT_PREFERRED_DELTA_THRESHOLD_PX;
+  const mandatoryOnlyTolerancePx = input2.mandatoryOnlyTolerancePx ?? DEFAULT_MANDATORY_ONLY_TOLERANCE_PX;
+  const deadReserveBloatThresholdPx = input2.deadReserveBloatThresholdPx ?? DEFAULT_DEAD_RESERVE_BLOAT_THRESHOLD_PX;
+  const wholeDocumentDeadReserveBloatThresholdPx = input2.wholeDocumentDeadReserveBloatThresholdPx ?? DEFAULT_WHOLE_DOCUMENT_DEAD_RESERVE_BLOAT_THRESHOLD_PX;
+  const beforeCandidateLedger = input2.beforeLedger.find((ledger) => ledger.pageIndex === input2.candidatePageIndex);
+  const candidateAnchorId = input2.candidateAnchorId ?? getLastAnchorId(beforeCandidateLedger);
+  const before2 = summarizeFootnoteWindow(input2.beforeLayout, input2.beforeLedger, input2.candidatePageIndex, windowAhead, preferredDeltaThresholdPx, mandatoryOnlyTolerancePx, candidateAnchorId);
+  const after2 = summarizeFootnoteWindow(input2.afterLayout, input2.afterLedger, input2.candidatePageIndex, windowAhead, preferredDeltaThresholdPx, mandatoryOnlyTolerancePx, candidateAnchorId);
+  const beforeBounds = getWindowBounds(input2.beforeLayout, input2.candidatePageIndex, windowAhead);
+  const afterBounds = getWindowBounds(input2.afterLayout, input2.candidatePageIndex, windowAhead);
+  const beforeWindowDiagnostics = collectLedgerDiagnostics(input2.beforeLedger, beforeBounds.windowStart, beforeBounds.windowEnd, preferredDeltaThresholdPx, mandatoryOnlyTolerancePx);
+  const afterWindowDiagnostics = collectLedgerDiagnostics(input2.afterLedger, afterBounds.windowStart, afterBounds.windowEnd, preferredDeltaThresholdPx, mandatoryOnlyTolerancePx);
+  const beforeDocumentBounds = getDocumentBounds(input2.beforeLayout);
+  const afterDocumentBounds = getDocumentBounds(input2.afterLayout);
+  const beforeDocumentDiagnostics = collectLedgerDiagnostics(input2.beforeLedger, beforeDocumentBounds.windowStart, beforeDocumentBounds.windowEnd, preferredDeltaThresholdPx, mandatoryOnlyTolerancePx);
+  const afterDocumentDiagnostics = collectLedgerDiagnostics(input2.afterLedger, afterDocumentBounds.windowStart, afterDocumentBounds.windowEnd, preferredDeltaThresholdPx, mandatoryOnlyTolerancePx);
+  const eliminatesSplitInWindow = beforeWindowDiagnostics.clusterSplitCount > afterWindowDiagnostics.clusterSplitCount;
+  const eliminatesSplitInDoc = beforeDocumentDiagnostics.clusterSplitCount > afterDocumentDiagnostics.clusterSplitCount;
+  if (after2.totalPages > before2.totalPages) {
+    if (!(after2.totalPages === before2.totalPages + 1 && eliminatesSplitInDoc))
+      return {
+        accept: false,
+        reason: "page-count-grew",
+        before: before2,
+        after: after2
+      };
+  }
+  if (after2.clusterSplitCount > before2.clusterSplitCount || hasNewId(afterWindowDiagnostics.clusterSplitAnchorIds, beforeWindowDiagnostics.clusterSplitAnchorIds))
+    return {
+      accept: false,
+      reason: "cluster-spill",
+      before: before2,
+      after: after2
+    };
+  if (afterDocumentDiagnostics.clusterSplitAnchorIds.size > beforeDocumentDiagnostics.clusterSplitAnchorIds.size || hasNewId(afterDocumentDiagnostics.clusterSplitAnchorIds, beforeDocumentDiagnostics.clusterSplitAnchorIds))
+    return {
+      accept: false,
+      reason: "cluster-spill",
+      before: before2,
+      after: after2
+    };
+  if (hasNewId(afterWindowDiagnostics.mandatoryOnlyAnchorIds, beforeWindowDiagnostics.mandatoryOnlyAnchorIds))
+    return {
+      accept: false,
+      reason: "new-mandatory-only",
+      before: before2,
+      after: after2
+    };
+  if (hasNewId(afterDocumentDiagnostics.mandatoryOnlyAnchorIds, beforeDocumentDiagnostics.mandatoryOnlyAnchorIds))
+    return {
+      accept: false,
+      reason: "new-mandatory-only",
+      before: before2,
+      after: after2
+    };
+  const windowDeadAllowance = eliminatesSplitInWindow ? deadReserveBloatThresholdPx * 2 : deadReserveBloatThresholdPx;
+  const docDeadAllowance = eliminatesSplitInDoc ? wholeDocumentDeadReserveBloatThresholdPx * 2 : wholeDocumentDeadReserveBloatThresholdPx;
+  if (after2.deadReserveSum > before2.deadReserveSum + windowDeadAllowance)
+    return {
+      accept: false,
+      reason: "dead-reserve-bloat",
+      before: before2,
+      after: after2
+    };
+  if (afterDocumentDiagnostics.deadReserveSum > beforeDocumentDiagnostics.deadReserveSum + docDeadAllowance)
+    return {
+      accept: false,
+      reason: "dead-reserve-bloat",
+      before: before2,
+      after: after2
+    };
+  if (!candidateRenderedLinesImproved(before2, after2))
+    return {
+      accept: false,
+      reason: "candidate-not-improved",
+      before: before2,
+      after: after2
+    };
+  return {
+    accept: true,
+    reason: "globally-safe",
+    before: before2,
+    after: after2
+  };
 }, measureCache, headerMeasureCache, headerFooterCacheState, layoutDebugEnabled$1, perfLog$1 = (...args$1) => {
   if (!layoutDebugEnabled$1)
     return;
@@ -313361,6 +314614,9 @@ menclose::after {
   const bottomWithReserve = normalizeMargin(page.margins?.bottom, DEFAULT_MARGINS$1.bottom);
   const baseReserveSafe = Number.isFinite(baseReserve) ? Math.max(0, baseReserve) : 0;
   const bottomMargin = Math.max(0, bottomWithReserve - baseReserveSafe);
+  const bodyMaxY = page.bodyMaxY;
+  if (typeof bodyMaxY === "number" && Number.isFinite(bodyMaxY) && bodyMaxY > topMargin)
+    return Math.max(0, pageSize.h - bottomMargin - bodyMaxY);
   const availableForBody = pageSize.h - topMargin - bottomMargin;
   if (!Number.isFinite(availableForBody))
     return 0;
@@ -313525,14 +314781,17 @@ menclose::after {
     toLine: splitLine,
     height: sumLineHeights$1(measure.lines, range.fromLine, splitLine)
   };
-  if (splitLine >= range.toLine)
-    return getRangeRenderHeight(fitted) <= availableHeight ? {
-      fitted,
-      remaining: null
-    } : {
+  if (splitLine >= range.toLine) {
+    if (fitted.height <= availableHeight)
+      return {
+        fitted,
+        remaining: null
+      };
+    return {
       fitted: null,
       remaining: range
     };
+  }
   return {
     fitted,
     remaining: {
@@ -313588,9 +314847,14 @@ menclose::after {
     }
     if (range.kind === "paragraph") {
       const split3 = splitRangeAtHeight(range, remainingSpace, measuresById);
-      if (split3.fitted && getRangeRenderHeight(split3.fitted) <= remainingSpace) {
-        fittedRanges.push(split3.fitted);
-        usedHeight += getRangeRenderHeight(split3.fitted);
+      if (split3.fitted) {
+        const fittedBodyHeight = split3.fitted.height;
+        const fittedFullHeight = getRangeRenderHeight(split3.fitted);
+        const charged = !split3.remaining ? fittedBodyHeight : fittedFullHeight;
+        if (charged <= remainingSpace) {
+          fittedRanges.push(split3.fitted);
+          usedHeight += charged;
+        }
       }
       if (split3.remaining)
         remainingRanges = [split3.remaining, ...inputRanges.slice(index2 + 1)];
@@ -319527,13 +320791,13 @@ menclose::after {
     return;
   console.log(...args$1);
 }, HEADER_FOOTER_INIT_BUDGET_MS = 200, MAX_ZOOM_WARNING_THRESHOLD = 10, MAX_SELECTION_RECTS_PER_USER = 100, SEMANTIC_RESIZE_DEBOUNCE_MS = 120, MIN_SEMANTIC_CONTENT_WIDTH_PX = 1, GLOBAL_PERFORMANCE, PresentationEditor, ICONS, TEXTS, tableActionsOptions, TRACKED_MARK_NAMES;
-var init_src_BrZa8lMN_es = __esm(() => {
+var init_src_iuHADPff_es = __esm(() => {
   init_rolldown_runtime_Bg48TavK_es();
-  init_SuperConverter_nmIRMGtB_es();
+  init_SuperConverter_LqX_f8x4_es();
   init_jszip_C49i9kUs_es();
   init_xml_js_CqGKpaft_es();
   init_uuid_qzgm05fK_es();
-  init_create_headless_toolbar_7bitVHMJ_es();
+  init_create_headless_toolbar_BOETXxAI_es();
   init_constants_D_X7xF4s_es();
   init_dist_B8HfvhaK_es();
   init_unified_Dsuw2be5_es();
@@ -346534,6 +347798,7 @@ function print() { __p += __j.call(arguments, '') }
     "odd"
   ];
   TWIPS_PER_PX$2 = 1440 / 96;
+  FULL_ANCHOR_RENDER_SENTINEL = Number.MAX_SAFE_INTEGER;
   init_dist4();
   measureCache = new MeasureCache;
   headerMeasureCache = new HeaderFooterLayoutCache;
@@ -347385,6 +348650,10 @@ function print() { __p += __j.call(arguments, '') }
     #flowBlockCache = new FlowBlockCache;
     #footnoteNumberSignature = null;
     #endnoteNumberSignature = null;
+    #warnedUnsupportedRestart = {
+      footnote: false,
+      endnote: false
+    };
     #painterAdapter = new PresentationPainterAdapter;
     #pageGeometryHelper = null;
     #dragDropManager = null;
@@ -347702,6 +348971,12 @@ function print() { __p += __j.call(arguments, '') }
         throw error3;
       }
     }
+    #warnUnsupportedNumberingRestart(kind) {
+      if (this.#warnedUnsupportedRestart[kind])
+        return;
+      this.#warnedUnsupportedRestart[kind] = true;
+      console.warn(`[PresentationEditor] ${kind} numRestart="eachPage" is not yet supported (requires a two-pass pagination handshake). Falling back to "continuous". Tracked for follow-up.`);
+    }
     #wrapOffscreenEditorFocus(editor) {
       const view = editor?.view;
       if (!view || !view.dom || typeof view.focus !== "function")
@@ -350778,58 +352053,84 @@ function print() { __p += __j.call(arguments, '') }
         let converterContext = undefined;
         try {
           const converter$1 = this.#editor.converter;
-          const footnoteNumberById = {};
-          const footnoteOrder = [];
-          try {
-            const seen = /* @__PURE__ */ new Set;
-            let counter = 1;
-            this.#editor?.state?.doc?.descendants?.((node3) => {
-              if (node3?.type?.name !== "footnoteReference")
-                return;
-              const rawId = node3?.attrs?.id;
-              if (rawId == null)
-                return;
-              const key2 = String(rawId);
-              if (!key2 || seen.has(key2))
-                return;
-              seen.add(key2);
-              footnoteNumberById[key2] = counter;
-              footnoteOrder.push(key2);
-              counter += 1;
-            });
-          } catch (e) {
-            if (typeof console !== "undefined" && console.warn)
-              console.warn("[PresentationEditor] Failed to compute footnote numbering:", e);
+          let defaultTableStyleId;
+          let footnoteNumberFormat;
+          let endnoteNumberFormat;
+          let footnoteNumberStart = 1;
+          let endnoteNumberStart = 1;
+          let footnoteNumberRestart;
+          let endnoteNumberRestart;
+          let footnotePosition;
+          let endnotePosition;
+          let footnoteSectionConfigs = /* @__PURE__ */ new Map;
+          let endnoteSectionConfigs = /* @__PURE__ */ new Map;
+          if (converter$1) {
+            const settingsRoot = readSettingsRoot(converter$1);
+            if (settingsRoot) {
+              defaultTableStyleId = readDefaultTableStyle(settingsRoot) ?? undefined;
+              footnoteNumberFormat = readFootnoteNumberFormat(settingsRoot) ?? undefined;
+              endnoteNumberFormat = readEndnoteNumberFormat(settingsRoot) ?? undefined;
+              footnoteNumberStart = readFootnoteNumberStart(settingsRoot) ?? 1;
+              endnoteNumberStart = readEndnoteNumberStart(settingsRoot) ?? 1;
+              footnoteNumberRestart = readFootnoteNumberRestart(settingsRoot) ?? undefined;
+              endnoteNumberRestart = readEndnoteNumberRestart(settingsRoot) ?? undefined;
+              footnotePosition = readFootnotePosition(settingsRoot) ?? undefined;
+              endnotePosition = readEndnotePosition(settingsRoot) ?? undefined;
+            }
+            const documentPart = converter$1.convertedXml?.["word/document.xml"];
+            if (documentPart) {
+              footnoteSectionConfigs = readSectionNoteConfigs(documentPart, "w:footnotePr");
+              endnoteSectionConfigs = readSectionNoteConfigs(documentPart, "w:endnotePr");
+            }
           }
-          const footnoteSignature = footnoteOrder.join("|");
+          if (footnoteNumberRestart === "eachPage") {
+            this.#warnUnsupportedNumberingRestart("footnote");
+            footnoteNumberRestart = "continuous";
+          }
+          if (endnoteNumberRestart === "eachPage") {
+            this.#warnUnsupportedNumberingRestart("endnote");
+            endnoteNumberRestart = "continuous";
+          }
+          for (const [secIndex, cfg] of footnoteSectionConfigs)
+            if (cfg.numRestart === "eachPage") {
+              footnoteSectionConfigs.set(secIndex, {
+                ...cfg,
+                numRestart: "continuous"
+              });
+              this.#warnUnsupportedNumberingRestart("footnote");
+            }
+          for (const [secIndex, cfg] of endnoteSectionConfigs)
+            if (cfg.numRestart === "eachPage") {
+              endnoteSectionConfigs.set(secIndex, {
+                ...cfg,
+                numRestart: "continuous"
+              });
+              this.#warnUnsupportedNumberingRestart("endnote");
+            }
+          const footnoteNumbering = computeNoteNumbering(this.#editor?.state, "footnoteReference", {
+            startCounter: footnoteNumberStart,
+            defaultNumFmt: footnoteNumberFormat,
+            defaultRestart: footnoteNumberRestart,
+            sectionConfigs: footnoteSectionConfigs
+          });
+          const footnoteNumberById = footnoteNumbering.numberById;
+          const footnoteFormatById = footnoteNumbering.formatById;
+          const footnoteOrder = footnoteNumbering.order;
+          const footnoteSignature = `${footnoteNumberStart}|${footnoteNumberFormat ?? ""}|${footnoteNumberRestart ?? ""}|${serializeSectionConfigs(footnoteSectionConfigs)}|${serializePerIdNumbering(footnoteOrder, footnoteNumberById, footnoteFormatById)}`;
           if (footnoteSignature !== this.#footnoteNumberSignature) {
             this.#flowBlockCache.clear();
             this.#footnoteNumberSignature = footnoteSignature;
           }
-          const endnoteNumberById = {};
-          const endnoteOrder = [];
-          try {
-            const seen = /* @__PURE__ */ new Set;
-            let counter = 1;
-            this.#editor?.state?.doc?.descendants?.((node3) => {
-              if (node3?.type?.name !== "endnoteReference")
-                return;
-              const rawId = node3?.attrs?.id;
-              if (rawId == null)
-                return;
-              const key2 = String(rawId);
-              if (!key2 || seen.has(key2))
-                return;
-              seen.add(key2);
-              endnoteNumberById[key2] = counter;
-              endnoteOrder.push(key2);
-              counter += 1;
-            });
-          } catch (e) {
-            if (typeof console !== "undefined" && console.warn)
-              console.warn("[PresentationEditor] Failed to compute endnote numbering:", e);
-          }
-          const endnoteSignature = endnoteOrder.join("|");
+          const endnoteNumbering = computeNoteNumbering(this.#editor?.state, "endnoteReference", {
+            startCounter: endnoteNumberStart,
+            defaultNumFmt: endnoteNumberFormat,
+            defaultRestart: endnoteNumberRestart,
+            sectionConfigs: endnoteSectionConfigs
+          });
+          const endnoteNumberById = endnoteNumbering.numberById;
+          const endnoteFormatById = endnoteNumbering.formatById;
+          const endnoteOrder = endnoteNumbering.order;
+          const endnoteSignature = `${endnoteNumberStart}|${endnoteNumberFormat ?? ""}|${endnoteNumberRestart ?? ""}|${serializeSectionConfigs(endnoteSectionConfigs)}|${serializePerIdNumbering(endnoteOrder, endnoteNumberById, endnoteFormatById)}`;
           if (endnoteSignature !== this.#endnoteNumberSignature) {
             this.#flowBlockCache.clear();
             this.#endnoteNumberSignature = endnoteSignature;
@@ -350840,16 +352141,16 @@ function print() { __p += __j.call(arguments, '') }
               converter$1["endnoteNumberById"] = endnoteNumberById;
             }
           } catch {}
-          let defaultTableStyleId;
-          if (converter$1) {
-            const settingsRoot = readSettingsRoot(converter$1);
-            if (settingsRoot)
-              defaultTableStyleId = readDefaultTableStyle(settingsRoot) ?? undefined;
-          }
           converterContext = converter$1 ? {
             docx: converter$1.convertedXml,
             ...Object.keys(footnoteNumberById).length ? { footnoteNumberById } : {},
             ...Object.keys(endnoteNumberById).length ? { endnoteNumberById } : {},
+            ...footnoteNumberFormat ? { footnoteNumberFormat } : {},
+            ...endnoteNumberFormat ? { endnoteNumberFormat } : {},
+            ...footnoteFormatById && Object.keys(footnoteFormatById).length ? { footnoteFormatById } : {},
+            ...endnoteFormatById && Object.keys(endnoteFormatById).length ? { endnoteFormatById } : {},
+            ...footnotePosition ? { footnotePosition } : {},
+            ...endnotePosition ? { endnotePosition } : {},
             translatedLinkedStyles: converter$1.translatedLinkedStyles,
             translatedNumbering: converter$1.translatedNumbering,
             ...defaultTableStyleId ? { defaultTableStyleId } : {}
@@ -353699,11 +355000,11 @@ function print() { __p += __j.call(arguments, '') }
   ]);
 });
 
-// ../../packages/superdoc/dist/chunks/create-super-doc-ui-DZGOzt3u.es.js
+// ../../packages/superdoc/dist/chunks/create-super-doc-ui-jemgYDso.es.js
 var MOD_ALIASES, ALT_ALIASES, CTRL_ALIASES, SHIFT_ALIASES, BUILTIN_CONTEXT_MENU_GROUPS, BUILTIN_GROUP_ORDER, RESERVED_PROXY_PROPERTY_NAMES, ALL_TOOLBAR_COMMAND_IDS, EMPTY_ACTIVE_IDS;
-var init_create_super_doc_ui_DZGOzt3u_es = __esm(() => {
-  init_SuperConverter_nmIRMGtB_es();
-  init_create_headless_toolbar_7bitVHMJ_es();
+var init_create_super_doc_ui_jemgYDso_es = __esm(() => {
+  init_SuperConverter_LqX_f8x4_es();
+  init_create_headless_toolbar_BOETXxAI_es();
   MOD_ALIASES = new Set([
     "Mod",
     "Meta",
@@ -353745,16 +355046,16 @@ var init_zipper_yaJVJ4z9_es = __esm(() => {
 
 // ../../packages/superdoc/dist/super-editor.es.js
 var init_super_editor_es = __esm(() => {
-  init_src_BrZa8lMN_es();
-  init_SuperConverter_nmIRMGtB_es();
+  init_src_iuHADPff_es();
+  init_SuperConverter_LqX_f8x4_es();
   init_jszip_C49i9kUs_es();
   init_xml_js_CqGKpaft_es();
-  init_create_headless_toolbar_7bitVHMJ_es();
+  init_create_headless_toolbar_BOETXxAI_es();
   init_constants_D_X7xF4s_es();
   init_dist_B8HfvhaK_es();
   init_unified_Dsuw2be5_es();
   init_DocxZipper_nv_KfOqb_es();
-  init_create_super_doc_ui_DZGOzt3u_es();
+  init_create_super_doc_ui_jemgYDso_es();
   init_ui_C5PAS9hY_es();
   init_eventemitter3_BnGqBE_Q_es();
   init_errors_CNaD6vcg_es();