postext 0.3.27 → 0.3.29

package/dist/pipeline/build.js

@@ -11,7 +11,7 @@ import { resolveBodyStyle, resolveBlockquoteStyle } from './styles';
 import { computeLevelIndentsPx, computeOrderedLevelIndentsPx, computeOrderedListRunMetrics, } from './lists';
 import { resetLinePositions, createPageWithColumns, currentColumn, advanceToNextColumn, advanceToNextPageBoundary, enforcePageParity, placeBlockInColumn, placeAtomicBlock, createPartPage, pageHasContent, pageIsOccupied, bandColumns, currentBand, isBandLevel, bandUsedBottom, closeBandAndInsertSpan, } from './placement';
 import { chooseParagraphSplit } from './orphanWidow';
-import { applyStyleAttrs, computePageMetrics, nextNonMarkerBlock, prevNonMarkerBlock, rollbackTrailingBlocks, } from './buildHelpers';
+import { applyStyleAttrs, computePageMetrics, isMarkerBlock, nextNonMarkerBlock, prevNonMarkerBlock, rollbackTrailingBlocks, } from './buildHelpers';
 import { measureContentBlock } from './measureContentBlock';
 import { planParagraphContainers } from './paragraphContainers';
 import { planParts, derivePartMeasureContext } from './parts';
@@ -22,7 +22,7 @@ import { enumerateCurrentPageSlots, measureFloatBand, columnHasFloatBand, fitsSt
 import { computeHeadingContext, computeResourceNumbering, } from './resourceNumbering';
 import { defaultResourceTypes } from '../defaults/resourceTypes';
 import { buildHeadersAndFooters, measureHeadingAdvancedDesignHeight } from './headerFooter';
-import { totalGapLines, proposeBalanceLines, MAX_BALANCING_PASSES } from './columnBalancing';
+import { totalGapLines, proposeBalanceLines, collectColumnGaps, firstDivergentColumn, MAX_BALANCING_PASSES } from './columnBalancing';
 import { applyBandCap, uncapBand, columnBottom, bandCapLines, bandTop, resolveBandCaps, resolveTrailingCaps, bandCapLinesAroundZone, } from './bandCaps';
 import { raggedUrlLines } from './raggedUrl';
 export class BuildCancelledError extends Error {
@@ -115,6 +115,10 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
         doc.pageIndexOffset = pageIndexOffset;
     if (continuation?.headings && continuation.headings.h1 > 0)
         doc.chapterOrdinalOffset = continuation.headings.h1;
+    // The part the preceding chapters left open: running heads and palette
+    // overrides apply from the first page until this document opens its own.
+    if (continuation?.part)
+        doc.partStart = continuation.part;
     const pageMetrics = computePageMetrics(resolved);
     const { pageWidthPx, pageHeightPx, trimOffset, contentArea } = pageMetrics;
     // Page/bleed frames for design elements anchored to `'page'` / `'bleed'`.
@@ -299,6 +303,9 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
      *  sends single-column floats to the least reserved column). */
     const floatReserved = new Map();
     const reservedOf = (col) => floatReserved.get(col) ?? { top: 0, bottom: 0 };
+    /** Content index of the block that first referenced the latest float
+     *  reserved at the head of each column. */
+    const topFloatRefOf = new Map();
     /** Kind of cap the column is under (`undefined` when uncapped). A cap that
      *  cannot be attributed to the active band is treated as a span cap — the
      *  conservative reading, which keeps the column's bottom off the slot list. */
@@ -362,6 +369,7 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
                 col.bbox.height = Math.max(0, col.bbox.height - need);
                 col.availableHeight = Math.max(0, col.availableHeight - need);
                 r.top += need;
+                topFloatRefOf.set(col, Math.max(topFloatRefOf.get(col) ?? -1, f.firstBlockIdx));
             }
             else {
                 const capped = uncappedBottoms.get(col);
@@ -436,14 +444,21 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
      *  cursor (bottom of the referencing column, top / bottom of the next
      *  empty columns; the band bottom for page-span floats). Runs before each
      *  block is placed, so a float lands in the first gap after its reference. */
-    const tryPlacePendingFloatsOnCurrentPage = () => {
+    const tryPlacePendingFloatsOnCurrentPage = (preferTop = false) => {
         if (pendingFloats.length === 0)
             return;
         const page = doc.pages[cursor.pageIndex];
         for (let i = 0; i < pendingFloats.length;) {
             const f = pendingFloats[i];
             let r = 'defer';
-            for (const slot of enumerateCurrentPageSlots(page, cursor.columnIndex, f, capKindOf)) {
+            let slots = enumerateCurrentPageSlots(page, cursor.columnIndex, f, capKindOf);
+            // A page-span box comes next: the head of an empty column keeps the
+            // band cuttable under the float (the box then sits below both the
+            // text and the figure), where the referencing column's foot would
+            // wall the box off the page.
+            if (preferTop)
+                slots = [...slots.filter((s) => s.position === 'top'), ...slots.filter((s) => s.position !== 'top')];
+            for (const slot of slots) {
                 r = placeFloatInColumns(page, f, slot.cols, slot.position, slot.pageSpan, 'strict');
                 if (r !== 'defer')
                     break;
@@ -457,6 +472,20 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
     /** Reserve floats on each freshly opened content page. Passed only to the
      *  content-flow column advances — parity / force-blank pages never get it. */
     const onNewPage = (page) => flushFloatsIntoPage(page);
+    /** Whether content block `idx` opens a callout that will span the page
+     *  in the current (multi-column) band — the floats placed right before
+     *  it prefer the head of an empty column. */
+    const spanBoxAt = (idx) => {
+        const b = contentBlocks[idx];
+        if (!b || b.type !== 'containerStart' || b.containerName !== 'callout')
+            return false;
+        const plan = calloutPlan.get(idx);
+        const style = plan ? pickCalloutStyle(resolved.calloutStyles, plan.attrs.type) : undefined;
+        if (!style || style.span !== 'page' || style.placement === 'fixed')
+            return false;
+        const page = doc.pages[cursor.pageIndex];
+        return bandColumns(page, currentBand(page, cursor)).length > 1;
+    };
     /** Chapter barrier: place every pending float before the boundary — in
      *  the current page's free slots, then on fresh pages opened ahead of it
      *  (each force-places at least one float). The cursor is left on the last
@@ -527,6 +556,19 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
     let activeCap = null;
     /** True bottoms of capped columns (restored when the span block cuts). */
     const uncappedBottoms = new Map();
+    /** Column balancing: height (px) the levers added inside each column so
+     *  far — extra grid lines above headings / list ends and lines gained by
+     *  loose paragraphs. Balancing only ever fills a column's bottom gap, so
+     *  a placement rule that needs slack *after* a block (keep-colon-with-
+     *  list) must see the column as it was before the levers filled it:
+     *  otherwise the block that closed the column in the plain pass moves to
+     *  the next column, the flow shifts on every later page, and the pass is
+     *  discarded as a regression. */
+    const balanceExtraInColumn = new Map();
+    const addBalanceExtra = (col, px) => {
+        if (px > 0)
+            balanceExtraInColumn.set(col, (balanceExtraInColumn.get(col) ?? 0) + px);
+    };
     const bandCapProposals = new Map();
     const spanPlacedInBand = new Set();
     const bandCapsApplied = new Set();
@@ -663,22 +705,26 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
      *  keep-with-next rollbacks may pull along (a callout is one unbreakable
      *  unit; its children never leave it). */
     const isFreeHeading = (b) => b.type === 'heading' && b.containerId === undefined;
-    /** Shared tail of callout placement: stamp the frame's source range,
-     *  convert the laid-out box to absolute coordinates at the frame's placed
-     *  origin, and push frame + children — in that order — to `doc.blocks`
-     *  and to the column the frame landed in. */
-    /** Stamp a callout frame's content index and source range (the whole
-     *  fence, opening to closing marker). */
-    const stampCalloutSource = (frame, startIdx, plan) => {
+    /** Stamp a callout frame's content index and source range: the whole
+     *  fence (opening to closing marker) for an unsplit box; for a fragment
+     *  of a split box, from the fence start (first fragment) or the first
+     *  child it holds, to the fence end (last fragment) or the last child. */
+    const stampCalloutSource = (frame, startIdx, plan, range) => {
         const startBlock = contentBlocks[startIdx];
         const endBlock = contentBlocks[plan.endIdx];
         frame.contentIndex = startIdx;
-        frame.sourceStart = startBlock.sourceStart + bodyOffset;
-        frame.sourceEnd = endBlock.sourceEnd + bodyOffset;
+        const first = range && range.firstChildIdx > startIdx + 1 ? contentBlocks[range.firstChildIdx] : startBlock;
+        const last = range && range.lastChildIdx < plan.endIdx - 1 ? contentBlocks[range.lastChildIdx] : endBlock;
+        frame.sourceStart = first.sourceStart + bodyOffset;
+        frame.sourceEnd = last.sourceEnd + bodyOffset;
     };
-    const commitCallout = (result, startIdx, plan, col) => {
+    /** Shared tail of callout placement: stamp the frame's source range,
+     *  convert the laid-out box to absolute coordinates at the frame's placed
+     *  origin, and push frame + children — in that order — to `doc.blocks`
+     *  and to the column the frame landed in. */
+    const commitCallout = (result, startIdx, plan, col, range) => {
         const frame = result.frame;
-        stampCalloutSource(frame, startIdx, plan);
+        stampCalloutSource(frame, startIdx, plan, range);
         offsetCalloutToAbsolute(result, frame.bbox.x, frame.bbox.y);
         doc.blocks.push(frame);
         for (const child of result.children) {
@@ -688,6 +734,77 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
             doc.blocks.push(child);
         }
     };
+    const makeCalloutLayouter = (startIdx, plan, style) => {
+        const children = contentBlocks.slice(startIdx + 1, plan.endIdx);
+        const realAt = [];
+        children.forEach((c, k) => {
+            if (c.type !== 'directive' && !isMarkerBlock(c))
+                realAt.push(k);
+        });
+        const layoutRange = (from, to, width, frameId, continuation) => {
+            let n = 0;
+            return layoutCallout({
+                style,
+                attrs: plan.attrs,
+                continuation,
+                children: children.slice(from, to),
+                childStartIdx: startIdx + 1 + from,
+                width,
+                ctx: measureCtx,
+                resolved,
+                containerId: plan.containerId,
+                frameId,
+                nextChildId: () => `${frameId}-c${n++}`,
+                paragraphStyleFor: (idx) => paragraphContainers.byBlock[idx]?.style,
+            });
+        };
+        return { children, childBase: startIdx + 1, realAt, layoutRange };
+    };
+    /** The longest leading fragment of the children from `from` on whose box
+     *  is at most `roomPx` tall — at least one child, and at least one left
+     *  for the rest. The full layout's child geometry picks the candidate
+     *  (box bottom = child bottom + the box's tail below its last child);
+     *  the candidate is then laid out for real and shortened while it does
+     *  not fit. `null` when not even the first child fits. */
+    const splitCalloutFragment = (L, from, width, roomPx, frameId, continuation) => {
+        const starts = L.realAt.filter((k) => k >= from);
+        if (starts.length < 2)
+            return null;
+        const full = L.layoutRange(from, L.children.length, width, frameId, continuation);
+        const lastChild = full.children[full.children.length - 1];
+        if (!lastChild)
+            return null;
+        const tail = full.totalHeight - (lastChild.bbox.y + lastChild.bbox.height);
+        /** Frame-relative bottom of the last laid-out child before position `to`. */
+        const bottomBefore = (to) => {
+            let bottom = 0;
+            for (const c of full.children) {
+                if (c.contentIndex !== undefined && c.contentIndex < L.childBase + to) {
+                    bottom = Math.max(bottom, c.bbox.y + c.bbox.height);
+                }
+            }
+            return bottom;
+        };
+        let j = starts.length - 1;
+        while (j >= 1 && bottomBefore(starts[j]) + tail > roomPx + 0.01)
+            j--;
+        for (; j >= 1; j--) {
+            const to = starts[j];
+            const result = L.layoutRange(from, to, width, frameId, continuation);
+            if (result.totalHeight <= roomPx + 0.01)
+                return { to, result };
+        }
+        return null;
+    };
+    /** Absolute content indices of the children in `[from, to)` of `L`, for
+     *  the fragment's source range. */
+    const fragmentRange = (L, from, to) => ({ firstChildIdx: L.childBase + from, lastChildIdx: L.childBase + to - 1 });
+    const markFragment = (result, part, continued) => {
+        if (result.frame.callout) {
+            result.frame.callout.part = part;
+            result.frame.callout.continued = continued;
+        }
+    };
     /**
      * Place a `span: 'page'` `:::callout` in a multi-column layout as a span
      * block (stage 1): the box is laid out at the page's content width and
@@ -716,6 +833,26 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
      * overflowed instead (the box arrives elsewhere), the driver grows or
      * drops the cap.
      *
+     * Leaving level (`headings.balancing.beforeSpan`): a box that does not
+     * fit even after a level cut proposes a TRAILING cap instead — the band
+     * it leaves is cut level, the way a chapter's closing band is, and the
+     * page is marked as a forced break in that pass so balancing does not
+     * stretch its last column back to the page bottom. The cap is resolved
+     * after balancing (`resolveTrailingCaps`); when the box reaches the
+     * capped band it counts as delivered whether it fits there or moves on,
+     * and the cut columns stay cut (the polish round fills a column ending a
+     * line under the cap).
+     *
+     * Splitting (`keepTogether: false`): a box that does not fit a level (or
+     * capped, or nearly level — within one grid line) band breaks between
+     * its children: the longest fragment that fits closes the page flush
+     * with the band bottom, the rest opens the next page in a box without
+     * the title or icon, and splits again if it is still too tall. Such a box that
+     * fits whole only flush with the page bottom (no text below) is placed
+     * whole. When the band is uneven, the cap that levels it (span cap when
+     * the whole box fits after the cut, trailing cap otherwise) comes first;
+     * the fragment is cut in the capped pass.
+     *
      * Geometry stays on the baseline grid: the cut line is the band's used
      * bottom snapped UP to the next grid line (anchored at the content-area
      * top, like every column start), and the span column's height is the
@@ -724,69 +861,197 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
      * stay in the outer page bands: the band inherits the float-reduced top
      * / bottom of the page's columns, so a span column never overlaps a float.
      */
-    const placeCalloutSpan = (startIdx, plan, layoutAt) => {
-        let page = doc.pages[cursor.pageIndex];
-        let result = layoutAt(page.contentArea.width);
+    const placeCalloutSpan = (startIdx, plan, style, L, firstFrameId) => {
+        const splittable = !style.keepTogether;
+        const balancingCfg = resolved.headings.balancing;
+        const levelBefore = balancingCfg.enabled && balancingCfg.beforeSpan;
         const minLines = resolved.bodyText.avoidWidows ? Math.max(1, resolved.bodyText.widowMinLines) : 1;
         const minRoomPx = minLines * bodyStyle.lineHeightPx;
-        /** Where the box would cut the current band, and whether it fits (room
-         *  is measured against the columns' TRUE bottoms — a capped band keeps
-         *  its slack below the cap). Null when the band is not level (or the
-         *  cursor sits on a span column with no band below it) and
-         *  `requireLevel` is set. */
-        const measureBand = (requireLevel) => {
-            const cols = bandColumns(page, currentBand(page, cursor));
-            if (cols.length === 0 || (requireLevel && !isBandLevel(cols)))
-                return null;
-            const usedBottom = bandUsedBottom(cols);
-            const cutY = page.contentArea.y
-                + Math.ceil((usedBottom - page.contentArea.y - 0.01) / baselineGrid) * baselineGrid;
-            const bandHasContent = cols.some((c) => c.blocks.length > 0);
-            const spacing = bandHasContent ? Math.max(pendingSpacing, result.marginTopPx) : 0;
-            const need = Math.ceil((spacing + result.totalHeight + result.marginBottomPx - 0.01) / baselineGrid) * baselineGrid;
-            const bandBottom = Math.min(...cols.map((c) => columnBottom(c, uncappedBottoms)));
-            const room = cutY + need + minRoomPx <= bandBottom + 0.01;
-            return { cols, cutY, need, spacing, room };
+        const gridUp = (page, v) => page.contentArea.y + Math.ceil((v - page.contentArea.y - 0.01) / baselineGrid) * baselineGrid;
+        const needFor = (spacing, height, margin) => Math.ceil((spacing + height + margin - 0.01) / baselineGrid) * baselineGrid;
+        const nearlyLevel = (cols) => {
+            const bottoms = cols.map((c) => c.bbox.y + (c.bbox.height - c.availableHeight));
+            return Math.max(...bottoms) - Math.min(...bottoms) <= baselineGrid + 0.5;
         };
-        // Is this band capped for this very box? Then it cuts at the band's
-        // used bottom (at most the cap) even when the last column is short.
-        const cap = bandCaps?.get(startIdx);
-        const capActive = cap !== undefined
-            && activeCap !== null
-            && activeCap.spanIndex === startIdx
-            && activeCap.pageIndex === page.index
-            && activeCap.band === currentBand(page, cursor);
-        let fit = measureBand(!capActive);
-        if (fit?.room && capActive) {
-            uncapBand(fit.cols, uncappedBottoms);
-            spanPlacedInBand.add(startIdx);
-        }
-        if (!fit && cap === undefined && bandStart && registeredBand
-            && registeredBand.pageIndex === page.index
-            && registeredBand.band === currentBand(page, cursor)) {
-            // Uneven band, no cap yet: propose one when a level cut would leave
-            // room for the box plus the widow minimum of body lines below it.
-            const cols = bandColumns(page, currentBand(page, cursor));
-            const lines = bandCapLines(cols, baselineGrid);
-            const capBottom = bandTop(cols) + lines * baselineGrid;
-            const spacing = Math.max(pendingSpacing, result.marginTopPx);
-            const need = Math.ceil((spacing + result.totalHeight + result.marginBottomPx - 0.01) / baselineGrid) * baselineGrid;
-            const bandBottom = Math.min(...cols.map((c) => columnBottom(c, uncappedBottoms)));
-            if (capBottom + need + minRoomPx <= bandBottom + 0.01) {
-                bandCapProposals.set(startIdx, {
-                    kind: 'span',
-                    startContentIndex: bandStart.contentIndex,
-                    startPart: bandStart.part,
-                    lines,
-                    retries: 0,
-                });
+        /** Level for the box: the text columns end level, and a column holding
+         *  only a float band (a figure at its head, no text yet) counts as level
+         *  when a band cap could not level it either — the figure was first
+         *  referenced by the very block before the box, so a cut that spills
+         *  that block into the figure's column leaves the figure no slot after
+         *  its reference (it would fall off the page, and the box with it). The
+         *  box then cuts under the text and the figure alike, the slack under
+         *  the figure being the compositor's usual trade; a figure referenced
+         *  earlier keeps the cap route, which flows text under it. */
+        const lastBlockBefore = () => {
+            let j = startIdx - 1;
+            while (j >= 0 && isMarkerBlock(contentBlocks[j]))
+                j--;
+            return j;
+        };
+        const levelForBox = (cols) => {
+            if (isBandLevel(cols))
+                return true;
+            const textCols = cols.filter((c) => c.blocks.length > 0);
+            const floatOnly = cols.filter((c) => c.blocks.length === 0 && reservedOf(c).top > 0);
+            if (textCols.length === 0 || textCols.length + floatOnly.length !== cols.length)
+                return false;
+            if (!isBandLevel(textCols))
+                return false;
+            const textBottom = bandUsedBottom(textCols);
+            const before = lastBlockBefore();
+            return floatOnly.every((c) => c.bbox.y <= textBottom + baselineGrid + 0.5 && topFloatRefOf.get(c) === before);
+        };
+        /** Position in the children the fragment to place starts at, and its
+         *  0-based index among the fragments (0 = the box, or its head). */
+        let from = 0;
+        let part = 0;
+        let frameId = firstFrameId;
+        /** The box already moved to a fresh page (or sits on an empty one):
+         *  whatever does not fit there is force-placed and overflows. */
+        let forceHere = false;
+        for (;;) {
+            let page = doc.pages[cursor.pageIndex];
+            const continuation = part > 0;
+            const layoutAt = (width) => L.layoutRange(from, L.children.length, width, frameId, continuation);
+            const result = layoutAt(page.contentArea.width);
+            /** Where the box would cut the current band, and whether it fits (room
+             *  is measured against the columns' TRUE bottoms — a capped band keeps
+             *  its slack below the cap). Null when the band is not level (or the
+             *  cursor sits on a span column with no band below it) and
+             *  `requireLevel` is set. */
+            const measureBand = (requireLevel) => {
+                const cols = bandColumns(page, currentBand(page, cursor));
+                if (cols.length === 0 || (requireLevel && !levelForBox(cols)))
+                    return null;
+                const cutY = gridUp(page, bandUsedBottom(cols));
+                const bandHasContent = cols.some((c) => c.blocks.length > 0);
+                const spacing = bandHasContent ? Math.max(pendingSpacing, result.marginTopPx) : 0;
+                const need = needFor(spacing, result.totalHeight, result.marginBottomPx);
+                const bandBottom = Math.min(...cols.map((c) => columnBottom(c, uncappedBottoms)));
+                const room = cutY + need + minRoomPx <= bandBottom + 0.01;
+                const needFlush = needFor(spacing, result.totalHeight, 0);
+                const roomFlush = cutY + needFlush <= bandBottom + 0.01;
+                return { cols, cutY, spacing, need, room, needFlush, roomFlush, roomPx: bandBottom - cutY };
+            };
+            // Is this band capped for this very box? Then it cuts at the band's
+            // used bottom (at most the cap) even when the last column is short.
+            const cap = part === 0 ? bandCaps?.get(startIdx) : undefined;
+            const capActive = cap !== undefined
+                && activeCap !== null
+                && activeCap.spanIndex === startIdx
+                && activeCap.pageIndex === page.index
+                && activeCap.band === currentBand(page, cursor);
+            const fit = forceHere ? (measureBand(true) ?? measureBand(false)) : measureBand(!capActive);
+            let action = null;
+            if (fit) {
+                if (fit.room)
+                    action = { kind: 'whole', fit, need: fit.need, result };
+                else if (splittable && fit.roomFlush)
+                    action = { kind: 'whole', fit, need: fit.needFlush, result };
+            }
+            if (!action && splittable) {
+                // A band uneven by no more than a grid line still takes a fragment
+                // cut at its used bottom: balancing fills the line the short column
+                // is left under the cut.
+                let band = fit;
+                if (!band) {
+                    const cols = bandColumns(page, currentBand(page, cursor));
+                    if (cols.length > 0 && nearlyLevel(cols))
+                        band = measureBand(false);
+                }
+                if (band) {
+                    const fragment = splitCalloutFragment(L, from, page.contentArea.width, band.roomPx - band.spacing, frameId, continuation);
+                    if (fragment) {
+                        action = { kind: 'split', fit: band, need: needFor(band.spacing, fragment.result.totalHeight, 0), fragment };
+                    }
+                }
+            }
+            if (!action && forceHere && fit)
+                action = { kind: 'whole', fit, need: fit.need, result };
+            if (action) {
+                if (capActive) {
+                    uncapBand(action.fit.cols, uncappedBottoms);
+                    spanPlacedInBand.add(startIdx);
+                }
+                const placed = action.kind === 'whole' ? action.result : action.fragment.result;
+                const to = action.kind === 'whole' ? L.children.length : action.fragment.to;
+                if (part > 0 || action.kind === 'split')
+                    markFragment(placed, part, action.kind === 'split');
+                const spanCol = closeBandAndInsertSpan(page, action.fit.cols, action.fit.cutY, placed.frame, action.need, cursor, action.fit.spacing, placed.totalHeight);
+                commitCallout(placed, startIdx, plan, spanCol, part > 0 || action.kind === 'split' ? fragmentRange(L, from, to) : undefined);
+                // Floats first-referenced inside the box enqueue once its head is
+                // committed, in reading order (same as the inline path).
+                if (part === 0)
+                    for (let i = startIdx + 1; i <= plan.endIdx; i++)
+                        enqueueFloatsFor(i);
+                // The new band starts on the grid right below the span column; nothing
+                // to snap — `need` already bakes in `marginBottom`.
+                pendingSpacing = 0;
+                if (action.kind === 'whole')
+                    return true;
+                // The rest opens the next page.
+                from = to;
+                part++;
+                frameId = `block-${blockIdCounter++}`;
+                const startPageIndex = cursor.pageIndex;
+                do {
+                    advanceToNextColumn(doc, cursor, resolved, contentArea, pageWidthPx, pageHeightPx, onNewPage);
+                } while (cursor.pageIndex === startPageIndex);
+                forceHere = true;
+                continue;
+            }
+            // Nothing of the box lands in this band.
+            if (part === 0) {
+                let proposedSpan = false;
+                if (!fit && cap === undefined && bandStart && registeredBand
+                    && registeredBand.pageIndex === page.index
+                    && registeredBand.band === currentBand(page, cursor)) {
+                    // Uneven band, no cap yet: propose one when a level cut would leave
+                    // room for the box plus the widow minimum of body lines below it
+                    // (or, for a splittable box, for the whole box flush with the
+                    // band bottom).
+                    const cols = bandColumns(page, currentBand(page, cursor));
+                    const lines = bandCapLines(cols, baselineGrid);
+                    const capBottom = bandTop(cols) + lines * baselineGrid;
+                    const spacing = Math.max(pendingSpacing, result.marginTopPx);
+                    const need = needFor(spacing, result.totalHeight, result.marginBottomPx);
+                    const bandBottom = Math.min(...cols.map((c) => columnBottom(c, uncappedBottoms)));
+                    const fitsAfterCut = capBottom + need + minRoomPx <= bandBottom + 0.01
+                        || (splittable && capBottom + needFor(spacing, result.totalHeight, 0) <= bandBottom + 0.01);
+                    if (fitsAfterCut) {
+                        bandCapProposals.set(startIdx, {
+                            kind: 'span',
+                            startContentIndex: bandStart.contentIndex,
+                            startPart: bandStart.part,
+                            lines,
+                            retries: 0,
+                        });
+                        proposedSpan = true;
+                    }
+                }
+                if (levelBefore && !capActive && !proposedSpan) {
+                    // The box leaves an uncapped band: level it behind the box (a
+                    // trailing cap, resolved after balancing) and keep balancing from
+                    // stretching its last column to the page bottom meanwhile.
+                    proposeTrailingCap(startIdx);
+                    markForcedBreak();
+                }
+                else if (capActive && cap.kind === 'trailing') {
+                    // Reached inside the band cut level for it: delivered even though
+                    // the box moves on — the columns stay cut.
+                    spanPlacedInBand.add(startIdx);
+                }
             }
-        }
-        if (!fit || !fit.room) {
             // Open the next page (flushing pending floats into its bands). A page
             // holding only floats counts as occupied here — its float band is what
             // left no room — but a truly empty page is kept: the box then simply
             // does not fit a page and is force-placed (overflowing, like inline).
+            // On a fresh page the whole box is force-placed above whenever the
+            // page has a text column to cut; reaching this point there means it
+            // has none — leave the box to the inline path (its head, if any, is
+            // already committed: `true` keeps the rest from being placed twice).
+            if (forceHere)
+                return part > 0;
             const curPage = doc.pages[cursor.pageIndex];
             if (pageIsOccupied(curPage)) {
                 pendingSpacing = 0;
@@ -795,26 +1060,13 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
                     advanceToNextColumn(doc, cursor, resolved, contentArea, pageWidthPx, pageHeightPx, onNewPage);
                 } while (cursor.pageIndex === startPageIndex);
                 page = doc.pages[cursor.pageIndex];
-                if (Math.abs(page.contentArea.width - result.width) > 0.01) {
-                    result = layoutAt(page.contentArea.width);
-                }
             }
-            // A freshly opened page is level; force-place (overflow) when the box
-            // is taller than the page.
-            fit = measureBand(true) ?? measureBand(false);
-            if (!fit)
+            // A freshly opened (or empty) page is level; force-place (overflow)
+            // when the box is taller than the page.
+            if (bandColumns(page, currentBand(page, cursor)).length === 0)
                 return false; // no text column to cut — leave it to the inline path
+            forceHere = true;
         }
-        const spanCol = closeBandAndInsertSpan(page, fit.cols, fit.cutY, result.frame, fit.need, cursor, fit.spacing, result.totalHeight);
-        commitCallout(result, startIdx, plan, spanCol);
-        // Floats first-referenced inside the box enqueue once it is committed,
-        // in reading order (same as the inline path).
-        for (let i = startIdx + 1; i <= plan.endIdx; i++)
-            enqueueFloatsFor(i);
-        // The new band starts on the grid right below the span column; nothing
-        // to snap — `need` already bakes in `marginBottom`.
-        pendingSpacing = 0;
-        return true;
     };
     /** Whether the flow ends at a chapter-level boundary right after block
      *  `from` (skipping container markers): a chapter opener, a `:::part`, a
@@ -992,8 +1244,12 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
      * baked into the post-box grid snap. A box that does not fit moves to the
      * next column/page (like a resource), pulling a run of trailing headings
      * along (keep-with-next); a box taller than an empty column is placed
-     * anyway and overflows (the sandbox warns). Returns the content index to
-     * rewind the main loop to when headings were rolled back, else `undefined`.
+     * anyway and overflows (the sandbox warns). A splittable box
+     * (`keepTogether: false`) instead leaves the longest run of its children
+     * that fits in the column and continues — in a box of its own, without
+     * the title or icon — at the top of the next one, splitting again if needed.
+     * Returns the content index to rewind the main loop to when headings
+     * were rolled back, else `undefined`.
      *
      * `span: 'page'` boxes in multi-column layouts take the span-block path
      * (`placeCalloutSpan`) instead; `placement: 'top' | 'bottom'` (floating
@@ -1002,25 +1258,10 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
      */
     const placeCalloutInline = (startIdx, plan) => {
         const style = pickCalloutStyle(resolved.calloutStyles, plan.attrs.type);
-        const children = contentBlocks.slice(startIdx + 1, plan.endIdx);
-        const frameId = `block-${blockIdCounter++}`;
+        const firstFrameId = `block-${blockIdCounter++}`;
         const { span, placement } = resolveCalloutAttrs(style, plan.attrs);
-        const layoutAt = (width) => {
-            let n = 0;
-            return layoutCallout({
-                style,
-                attrs: plan.attrs,
-                children,
-                childStartIdx: startIdx + 1,
-                width,
-                ctx: measureCtx,
-                resolved,
-                containerId: plan.containerId,
-                frameId,
-                nextChildId: () => `${frameId}-c${n++}`,
-                paragraphStyleFor: (idx) => paragraphContainers.byBlock[idx]?.style,
-            });
-        };
+        const L = makeCalloutLayouter(startIdx, plan, style);
+        const layoutAt = (width) => L.layoutRange(0, L.children.length, width, firstFrameId, false);
         // Fixed boxes leave the flow entirely.
         if (placement === 'fixed') {
             placeCalloutFixed(startIdx, plan, style, layoutAt);
@@ -1033,61 +1274,88 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
             if (span === 'page'
                 && placement === 'here'
                 && bandColumns(page, currentBand(page, cursor)).length > 1
-                && placeCalloutSpan(startIdx, plan, layoutAt)) {
+                && placeCalloutSpan(startIdx, plan, style, L, firstFrameId)) {
                 return undefined;
             }
         }
-        let curCol = currentColumn(doc, cursor);
-        let result = layoutAt(curCol.bbox.width);
-        if (curCol.blocks.length > 0) {
-            const spacingBefore = Math.max(pendingSpacing, result.marginTopPx);
-            if (result.totalHeight > curCol.availableHeight - spacingBefore) {
-                // Keep-with-next: a run of headings at the column's tail travels
-                // with the box. Skipped when the column holds nothing else (rolling
-                // back again would loop) — the headings stay, orphaned.
-                let run = 0;
-                for (let j = curCol.blocks.length - 1; j >= 0; j--) {
-                    if (isFreeHeading(curCol.blocks[j]))
-                        run++;
-                    else
-                        break;
-                }
-                pendingSpacing = 0;
-                if (resolved.headings.keepWithNext && run > 0 && run < curCol.blocks.length) {
-                    const rolledBack = rollbackTrailingBlocks(curCol, doc.blocks, isFreeHeading);
+        const splittable = !style.keepTogether;
+        let from = 0;
+        let part = 0;
+        let frameId = firstFrameId;
+        for (;;) {
+            let curCol = currentColumn(doc, cursor);
+            const continuation = part > 0;
+            const result = L.layoutRange(from, L.children.length, curCol.bbox.width, frameId, continuation);
+            const spacing = curCol.blocks.length === 0 ? 0 : Math.max(pendingSpacing, result.marginTopPx);
+            const roomPx = curCol.availableHeight - spacing;
+            let fragment = null;
+            if (result.totalHeight > roomPx + 0.01) {
+                // The (rest of the) box does not fit the column: a splittable box
+                // leaves the head that fits here…
+                if (splittable)
+                    fragment = splitCalloutFragment(L, from, curCol.bbox.width, roomPx, frameId, continuation);
+                if (!fragment && curCol.blocks.length > 0) {
+                    // …otherwise it moves whole to the next column. Keep-with-next: a
+                    // run of headings at the column's tail travels with the box.
+                    // Skipped when the column holds nothing else (rolling back again
+                    // would loop) — the headings stay, orphaned. Only the head of a
+                    // box can roll headings back: a continuation always lands in a
+                    // fresh column.
+                    let run = 0;
+                    for (let j = curCol.blocks.length - 1; j >= 0; j--) {
+                        if (isFreeHeading(curCol.blocks[j]))
+                            run++;
+                        else
+                            break;
+                    }
+                    pendingSpacing = 0;
+                    if (part === 0 && resolved.headings.keepWithNext && run > 0 && run < curCol.blocks.length) {
+                        const rolledBack = rollbackTrailingBlocks(curCol, doc.blocks, isFreeHeading);
+                        advanceToNextColumn(doc, cursor, resolved, contentArea, pageWidthPx, pageHeightPx, onNewPage);
+                        return (rolledBack[0].contentIndex ?? startIdx - rolledBack.length) - 1;
+                    }
                     advanceToNextColumn(doc, cursor, resolved, contentArea, pageWidthPx, pageHeightPx, onNewPage);
-                    return (rolledBack[0].contentIndex ?? startIdx - rolledBack.length) - 1;
-                }
-                advanceToNextColumn(doc, cursor, resolved, contentArea, pageWidthPx, pageHeightPx, onNewPage);
-                curCol = currentColumn(doc, cursor);
-                // Columns of different widths (oneAndHalf): re-lay out for the new one.
-                if (Math.abs(curCol.bbox.width - result.width) > 0.01 && style.width !== 'auto') {
-                    result = layoutAt(curCol.bbox.width);
+                    curCol = currentColumn(doc, cursor);
+                    // Columns of different widths (oneAndHalf): re-lay out for the new one.
+                    if (Math.abs(curCol.bbox.width - result.width) > 0.01 && style.width !== 'auto') {
+                        continue;
+                    }
                 }
+                // An empty column that is still too short: placed anyway, overflowing.
             }
+            // Floats first-referenced inside the box still enqueue in reading order
+            // (only once the box is committed, so a keep-with-next replay does not
+            // enqueue them twice).
+            if (part === 0)
+                for (let i = startIdx + 1; i <= plan.endIdx; i++)
+                    enqueueFloatsFor(i);
+            const placed = fragment ? fragment.result : result;
+            const to = fragment ? fragment.to : L.children.length;
+            if (part > 0 || fragment)
+                markFragment(placed, part, fragment !== null);
+            const spacingBefore = curCol.blocks.length === 0 ? 0 : Math.max(pendingSpacing, placed.marginTopPx);
+            enterBand(startIdx, 0);
+            placeAtomicBlock(placed.frame, placed.totalHeight, spacingBefore, cursor, doc, resolved, contentArea, pageWidthPx, pageHeightPx);
+            enterBand(startIdx, 0);
+            curCol = currentColumn(doc, cursor);
+            commitCallout(placed, startIdx, plan, curCol, part > 0 || fragment ? fragmentRange(L, from, to) : undefined);
+            // Snap the flow after the box to the baseline grid, baking in at least
+            // `marginBottom` (grid wins, margin is a minimum — the resource rule).
+            {
+                const usedHeight = curCol.bbox.height - curCol.availableHeight;
+                const naturalBottom = usedHeight + placed.marginBottomPx;
+                const snappedBottom = Math.ceil((naturalBottom - 0.01) / baselineGrid) * baselineGrid;
+                curCol.availableHeight = Math.max(0, curCol.bbox.height - snappedBottom);
+            }
+            pendingSpacing = 0;
+            if (!fragment)
+                return undefined;
+            // The rest continues at the top of the next column.
+            from = to;
+            part++;
+            frameId = `block-${blockIdCounter++}`;
+            advanceToNextColumn(doc, cursor, resolved, contentArea, pageWidthPx, pageHeightPx, onNewPage);
         }
-        // Floats first-referenced inside the box still enqueue in reading order
-        // (only once the box is committed, so a keep-with-next replay does not
-        // enqueue them twice).
-        for (let i = startIdx + 1; i <= plan.endIdx; i++)
-            enqueueFloatsFor(i);
-        const frame = result.frame;
-        const spacing = curCol.blocks.length === 0 ? 0 : Math.max(pendingSpacing, result.marginTopPx);
-        enterBand(startIdx, 0);
-        placeAtomicBlock(frame, result.totalHeight, spacing, cursor, doc, resolved, contentArea, pageWidthPx, pageHeightPx);
-        enterBand(startIdx, 0);
-        curCol = currentColumn(doc, cursor);
-        commitCallout(result, startIdx, plan, curCol);
-        // Snap the flow after the box to the baseline grid, baking in at least
-        // `marginBottom` (grid wins, margin is a minimum — the resource rule).
-        {
-            const usedHeight = curCol.bbox.height - curCol.availableHeight;
-            const naturalBottom = usedHeight + result.marginBottomPx;
-            const snappedBottom = Math.ceil((naturalBottom - 0.01) / baselineGrid) * baselineGrid;
-            curCol.availableHeight = Math.max(0, curCol.bbox.height - snappedBottom);
-        }
-        pendingSpacing = 0;
-        return undefined;
     };
     for (let blockIdx = 0; blockIdx < contentBlocks.length; blockIdx++) {
         if (options?.shouldCancel?.())
@@ -1099,7 +1367,7 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
         // order. Then enqueue the floats first-referenced in this block, so the
         // next page opened while placing it (or any later block) reserves their
         // band and the next iteration offers them the slots that follow.
-        tryPlacePendingFloatsOnCurrentPage();
+        tryPlacePendingFloatsOnCurrentPage(spanBoxAt(blockIdx));
         enqueueFloatsFor(blockIdx);
         // --- Directives ----------------------------------------------------
         if (rawBlock.type === 'directive') {
@@ -1183,6 +1451,7 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
                 createPartPage(doc.pages[cursor.pageIndex], pageMetrics, resolved, {
                     number: plan.number,
                     title: plan.title,
+                    palette: plan.palette,
                     titleSourceStart,
                     titleSourceEnd,
                 }, pageIndexOffset);
@@ -1218,7 +1487,7 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
                 // slots, else on pages opened ahead of it — so no float escapes
                 // past it. The page stays balanceable (no forced break).
                 if (pickCalloutStyle(resolved.calloutStyles, plan.attrs.type).floatBarrier) {
-                    tryPlacePendingFloatsOnCurrentPage();
+                    tryPlacePendingFloatsOnCurrentPage(spanBoxAt(blockIdx));
                     drainPendingFloats();
                 }
                 // `span: 'page'` boxes in multi-column layouts branch to the
@@ -1411,6 +1680,10 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
         // A justified line a link leaves with too few spaces is set ragged.
         let remainingLines = [...raggedUrlLines(measured.lines, style.textAlign, rawBlock.text)];
         let partIndex = 0;
+        /** Times this block left an EMPTY short column (see `shortColumn`) —
+         *  bounded so a page whose columns are all short (footnotes, design
+         *  bands) cannot make it wander forever. */
+        let shortColumnMoves = 0;
         // "Keep with next" for colon-introduced lists: a paragraph ending in `:`
         // followed directly by a list acts as a lead-in title — the colon-bearing
         // line must share a column with the first list item. Only checked for the
@@ -1439,8 +1712,10 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
                     // page top.
                     if (vdtType === 'heading') {
                         const extraPx = balanceExtraPx?.get(blockIdx);
-                        if (extraPx)
+                        if (extraPx) {
                             spacingBefore += extraPx;
+                            addBalanceExtra(curCol, extraPx);
+                        }
                     }
                 }
                 else if (vdtType === 'listItem') {
@@ -1454,10 +1729,26 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
                 // handled inside the heading branch above (after margin collapsing).
                 if (vdtType !== 'heading' && vdtType !== 'mathDisplay' && partIndex === 0) {
                     const extraPx = balanceExtraPx?.get(blockIdx);
-                    if (extraPx)
+                    if (extraPx) {
                         spacingBefore += extraPx;
+                        addBalanceExtra(curCol, extraPx);
+                    }
+                }
+            }
+            else if (partIndex === 0 && reservedOf(curCol).top > 0) {
+                // Column balancing: extra grid lines between the float band at the
+                // head of this column and its first block (the after-float lever).
+                const extraPx = balanceExtraPx?.get(blockIdx);
+                if (extraPx) {
+                    spacingBefore += extraPx;
+                    addBalanceExtra(curCol, extraPx);
                 }
             }
+            // A loose paragraph's extra line is balancing height too (it lands
+            // whole in this column — loose candidates are never split parts).
+            if (partIndex === 0 && tryLoose && looseLines !== undefined && typeof looseOutcome.get(blockIdx) === 'number') {
+                addBalanceExtra(curCol, looseLines * style.lineHeightPx);
+            }
             const effectiveAvailable = curCol.availableHeight - spacingBefore;
             const linesPerAvailable = Math.floor(effectiveAvailable / style.lineHeightPx);
             // Math display blocks carry their natural pixel height on the single
@@ -1501,7 +1792,9 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
                 && curCol.blocks.length > 0) {
                 const usedHeight = (curCol.bbox.height - curCol.availableHeight) + spacingBefore;
                 const paragraphBottom = usedHeight + totalRemainHeight;
-                const availableAfter = curCol.bbox.height - paragraphBottom;
+                // Slack after the paragraph as the plain pass saw it: the height
+                // balancing added above in this column is not room the list lost.
+                const availableAfter = curCol.bbox.height - paragraphBottom + (balanceExtraInColumn.get(curCol) ?? 0);
                 const nextListKind = nextBlock?.listKind ?? 'unordered';
                 const nextListMarginDim = nextListKind === 'ordered'
                     ? resolved.orderedLists.marginTop
@@ -1581,6 +1874,16 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
                     // headingRunCount === curCol.blocks.length: fall through to place.
                 }
             }
+            // A block opening a column normally stays (no column can take it any
+            // better), except in a column at least a line shorter than the content
+            // area — the band under a page-span box, or a column cut by a float:
+            // a heading that fits there alone, or a block that does not fit there
+            // but would fit a full column, opens the next column instead (the move
+            // count is bounded besides). A column cut by a band cap is short on
+            // purpose — its content is meant to end at the cut.
+            const shortColumn = shortColumnMoves < 4
+                && !uncappedBottoms.has(curCol)
+                && curCol.bbox.height < contentArea.height - baselineGrid;
             // Block fits in current column
             if (effectiveRemainHeight <= effectiveAvailable) {
                 // Heading keep-with-next: never leave a heading as the last block of a
@@ -1597,7 +1900,7 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
                     && resolved.headings.keepWithNext
                     && !nextIsHeading
                     && nextBlock !== null
-                    && curCol.blocks.length > 0) {
+                    && (curCol.blocks.length > 0 || shortColumn)) {
                     const wouldUsedHeight = (curCol.bbox.height - curCol.availableHeight) + spacingBefore;
                     const naturalBottom = wouldUsedHeight + effectiveRemainHeight + style.marginBottomPx;
                     const snappedBottom = shouldSnapToGrid
@@ -1609,6 +1912,8 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
                         : 1;
                     const minSpaceAfter = minLinesNeeded * bodyStyle.lineHeightPx;
                     if (remainAfterHeading < minSpaceAfter) {
+                        if (curCol.blocks.length === 0)
+                            shortColumnMoves++;
                         // Roll back any immediately-preceding heading blocks in this
                         // column so they travel with this one.
                         const rolledBack = rollbackTrailingBlocks(curCol, doc.blocks, isFreeHeading);
@@ -1772,8 +2077,11 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
                 }
                 // choice.splitAt === 0: fall through to push whole paragraph to next column
             }
-            // Cannot split — advance to next column if current has content
-            if (curCol.blocks.length > 0) {
+            // Cannot split — advance to next column if current has content (or
+            // the column is a short band that cannot hold the block at all).
+            if (curCol.blocks.length > 0 || (shortColumn && effectiveRemainHeight <= contentArea.height)) {
+                if (curCol.blocks.length === 0)
+                    shortColumnMoves++;
                 // Heading keep-with-next (no-fit variant): when a heading can't fit
                 // in the current column and the column's tail is a run of headings,
                 // pull those headings along so they don't remain stranded as orphans
@@ -1896,17 +2204,67 @@ export function buildDocument(content, config, cache, options) {
     let bestScore = totalGapLines(best.doc, best.forcedBreakPages);
     let applied = { lines: new Map(), loose: new Map() };
     const failedLoose = new Set();
+    const failedLines = new Set();
     let converged = bestScore === 0;
+    /**
+     * A rejected pass moved content across a column break somewhere (a
+     * split paragraph whose head no longer fits, a float that lost its slot,
+     * a lead-in that left with its list…): every page after that point is
+     * re-flowed, gaps open elsewhere and a span cap may miss its band. The
+     * levers are meant to be local, so contain the damage: find the first
+     * column whose content changed and blacklist the levers this pass newly
+     * applied there (failing that, on its page; failing that, everywhere), so
+     * the next proposal keeps the working levers before it and tries again
+     * without the one that cascaded. Returns whether anything was blacklisted.
+     */
+    const containCascade = (next, proposal) => {
+        const div = firstDivergentColumn(best.doc, next.doc);
+        if (!div)
+            return false;
+        const newLines = [...proposal.lines].filter(([k, n]) => n > (applied.lines.get(k) ?? 0)).map(([k]) => k);
+        const newLoose = [...proposal.loose.keys()].filter((k) => !applied.loose.has(k));
+        if (newLines.length === 0 && newLoose.length === 0)
+            return false;
+        const gaps = collectColumnGaps(best.doc, best.forcedBreakPages);
+        const blacklist = (cands) => {
+            let hit = false;
+            for (const k of newLines)
+                if (!cands || cands.has(k)) {
+                    failedLines.add(k);
+                    hit = true;
+                }
+            for (const k of newLoose)
+                if (!cands || cands.has(k)) {
+                    failedLoose.add(k);
+                    hit = true;
+                }
+            return hit;
+        };
+        const inColumn = gaps
+            .filter((g) => g.pageIndex === div.pageIndex && g.columnIndex === div.columnIndex)
+            .flatMap((g) => g.candidates.map((c) => c.contentIndex));
+        if (blacklist(new Set(inColumn)))
+            return true;
+        const onPage = gaps
+            .filter((g) => g.pageIndex === div.pageIndex)
+            .flatMap((g) => g.candidates.map((c) => c.contentIndex));
+        if (blacklist(new Set(onPage)))
+            return true;
+        return blacklist(null);
+    };
     const balance = () => {
         while (!converged && passCount < MAX_BALANCING_PASSES) {
             const proposal = proposeBalanceLines(best.doc, best.forcedBreakPages, applied, {
                 maxLinesPerHeading: balancing.maxLinesPerHeading,
                 stretchAfterLists: balancing.stretchAfterLists,
                 maxLinesAfterList: balancing.maxLinesAfterList,
+                stretchAfterFloats: balancing.stretchAfterFloats,
+                maxLinesAfterFloat: balancing.maxLinesAfterFloat,
                 looseParagraphs: balancing.looseParagraphs,
                 maxLooseParagraphs: balancing.maxLooseParagraphs,
                 optimalLineBreaking: best.doc.config.bodyText.optimalLineBreaking,
                 failedLoose,
+                failedLines,
             });
             if (!proposal.changed) {
                 // No stretch point can absorb the remaining gaps — stable.
@@ -1950,11 +2308,16 @@ export function buildDocument(content, config, cache, options) {
                 converged = score === 0;
             }
             else {
-                // Plateau or regression. Retry when a loose candidate was just
-                // blacklisted (the proposer falls through to the next one), or when
-                // the new loose paragraphs gained their lines yet the layout did not
-                // improve (the gain landed elsewhere — drop them too). A pure spacing
-                // plateau means we're done: keep the best layout found so far.
+                // Plateau or regression. First contain a cascade: a lever that
+                // moved content across a column break is blacklisted and the loop
+                // retries without it. Otherwise retry when a loose candidate was
+                // just blacklisted (the proposer falls through to the next one), or
+                // when the new loose paragraphs gained their lines yet the layout
+                // did not improve (the gain landed elsewhere — drop them too). A
+                // pure spacing plateau means we're done: keep the best layout found
+                // so far.
+                if (containCascade(next, proposal))
+                    continue;
                 if (looseFailed.length > 0 || looseWon.length > 0) {
                     for (const k of looseWon)
                         failedLoose.add(k);