postext 1.27.1 → 1.28.1

package/dist/pipeline/build.js

@@ -8,6 +8,8 @@ import { buildPageLabels, computeHeadingNumbering, parseNumberFormat, } from '..
 import { extractFrontmatter, normalizeMetadata } from '../frontmatter';
 import { collectConfigWarnings } from '../configWarnings';
 import { initHyphenator } from '../measure';
+import { setHyphenationRules } from '../hyphenate';
+import { citedNames } from '../citations/names';
 import { getCjkLineBreak, setCjkLineBreak } from '../measure/cjkClasses';
 import { cjkCompositionOf, getCjkComposition, setCjkComposition } from '../measure/cjkPunctuation';
 import { getMeasureRegion, getMeasureUprightDigits, getMeasureWritingMode, measuringVertically, setMeasureUprightDigits, setMeasureWritingMode } from '../measure/vertical';
@@ -21,6 +23,7 @@ import { defaultFontSet, documentFontFaces, fontFallbacks } from '../fonts/faces
 import { syncFontSet } from '../fonts/fontSet';
 import { asciiDigits } from '../arabicNumerals';
 import { getMeasureArabicNumbers, getMeasureDirection, setMeasureArabicNumbers, setMeasureDirection, shiftLineX } from '../measure/bidiLines';
+import { getMeasureScriptContext, hanMarksOfLocale, scriptContextOfLocale, setMeasureScriptContext } from '../measure/script';
 import { createHeadingLevelResolver, deriveSectionGeometryConfig, sectionWritingMode, deriveSectionMeasureContext, headingIsHidden, headingIsNumbered, headingMarksFor, headingStyleOf, numberTitlesFor, planHeadingSections, } from './headingStyles';
 import { locateAnchors } from './anchors';
 import { applyCitations, citationLocale, processCitations, withBibliographyStyle } from './citations';
@@ -34,7 +37,7 @@ import { expandTocDirectives } from './toc';
 import { expandIndexDirectives, locateIndexMarks } from './indexDirective';
 import { resolveBodyStyle, resolveBlockquoteStyle, resolveParagraphStyle } from './styles';
 import { computeLevelIndentsPx, computeOrderedLevelIndentsPx, computeOrderedListRunMetrics, directListMarker, listBulletPosition, listItemGapPx, listItemSpacingPx, mirrorListMarker, } from './lists';
-import { resetLinePositions, createPageWithColumns, currentColumn, advanceToNextColumn, advanceToNextPageBoundary, enforcePageParity, placeBlockInColumn, placeAtomicBlock, createPartPage, pageHasContent, sideColumnOf, sideColumns, sideUsedBottom, pageIsOccupied, bandColumns, currentBand, isBandLevel, bandUsedBottom, closeBandAndInsertSpan, closeBandAt, pageLayoutOf, FIT_EPS, } from './placement';
+import { resetLinePositions, createPageWithColumns, currentColumn, advanceToNextColumn, columnClosesPage, flowColumnsAfter, advanceToNextPageBoundary, enforcePageParity, placeBlockInColumn, placeAtomicBlock, createPartPage, pageHasContent, sideColumnOf, sideColumns, sideUsedBottom, pageIsOccupied, bandColumns, currentBand, isBandLevel, bandUsedBottom, closeBandAndInsertSpan, closeBandAt, pageLayoutOf, FIT_EPS, } from './placement';
 import { chooseParagraphSplit } from './orphanWidow';
 import { layoutComicPage, comicPageLayoutWarnings } from '../comics/layoutPage';
 import { comicStripExtent, comicStripOffset, comicStripPlacement, comicStripWidth, layoutComicStrip } from '../comics/strip';
@@ -47,7 +50,7 @@ import { planParts, derivePartMeasureContext } from './parts';
 import { layoutCallout, offsetBlock, offsetCalloutToAbsolute, pickCalloutStyle, planCallouts, resolveCalloutAttrs, } from './calloutLayout';
 import { fillGalley, galleyBreaks } from './columnsGroup';
 import { chooseTableSlice, layoutCaptionText, layoutResourceBlock, MIN_TAIL_ROWS } from './resourceLayout';
-import { computeFloatPlan, floatedResourceIds, floatColumnCount, } from './floatPlacement';
+import { computeFloatPlan, floatedResourceIds, floatColumnCount, resolveResourcePlacement, } from './floatPlacement';
 import { enumerateCurrentPageSlots, measureFloatBand, floatGapAbove, floatGapBelow, measureSideStack, clearSideObstacles, columnHasFloatBand, fitsStrict, trueBottom, } from './floatSlots';
 import { computeHeadingContext, computeResourceNumberingState, } from './resourceNumbering';
 import { documentLocale, effectiveResourceTypes } from '../defaults/resourceTypes';
@@ -61,9 +64,9 @@ import { buildHeadersAndFooters, defaultOpenerTitle, headingDesignBoxes, measure
 import { flowColorValues } from './partPalette';
 import { chapterNumberCounter, leadingBoldText } from './placeholders';
 import { proposeBalanceLines, GRID_LINE_LEVERS, collectColumnGaps, firstDivergentColumn, gapLinesIn, boxRoomIn, boxLeverKeys, pageSegments, MAX_BALANCING_PASSES, MAX_BALANCING_PASSES_PER_DOCUMENT, balanceKey, candidateKey, flexFigureKey, flexFloatKey } from './columnBalancing';
-import { applyBandCap, uncapBand, columnBottom, bandCapLines, bandTop, bareBandTop, resolveBandCapsGen, drainPasses, resolveTrailingCapsGen, bandCapLinesAroundZone, } from './bandCaps';
+import { applyBandCap, uncapBand, columnBottom, bandCapLines, bandTop, bareBandTop, resolveBandCapsGen, drainPasses, resolveTrailingCapsGen, bandCapLinesAroundZone, bandLinePitch, capRetryLimit, } from './bandCaps';
 import { raggedLooseLines } from './raggedLines';
-import { cjkLooseLineWarnings, collectContentWarnings, designTruncationWarnings, dropCapWarnings, floatShrinkWarnings, joiningLetterSpacingWarnings, locateContentWarnings, wordOverflowWarnings } from './contentWarnings';
+import { cjkLooseLineWarnings, raggedLineWarnings, collectContentWarnings, designTruncationWarnings, dropCapWarnings, floatShrinkWarnings, joiningLetterSpacingWarnings, locateContentWarnings, wordOverflowWarnings } from './contentWarnings';
 import { dropCapSinkAfter } from './dropCap';
 import { mostlyJoiningScript } from '../measure/joining';
 import { composesAsCjk } from '../measure/cjkCompose';
@@ -236,10 +239,12 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
     const uprightDigits = getMeasureUprightDigits();
     const direction = getMeasureDirection();
     const arabicNumbers = getMeasureArabicNumbers();
+    const scriptContext = getMeasureScriptContext();
     try {
         return placeDocumentPass(content, config, cache, options, hints);
     }
     finally {
+        setMeasureScriptContext(scriptContext);
         setMeasureArabicNumbers(arabicNumbers);
         setCjkLineBreak(lineBreak);
         setCjkComposition(composition);
@@ -287,7 +292,10 @@ function placeDocumentPass(content, config, cache, options, hints) {
     // design text — and so do the words wider than their measure, divided at a
     // syllable even in ragged text. Left unset, a build would hyphenate with
     // whichever dictionary the previous one (or the default, en-us) chose.
-    initHyphenator(resolved.bodyText.hyphenation.locale);
+    // With the words the document keeps whole (#699); the names of the
+    // authors it cites join them below, once its references are read.
+    const hyphenationRules = { exceptions: resolved.bodyText.hyphenation.exceptions, capitalized: resolved.bodyText.hyphenation.capitalized };
+    initHyphenator(resolved.bodyText.hyphenation.locale, hyphenationRules);
     // CJK text breaks at the document's level wherever it is measured (body,
     // captions, cells, notes, boxes), as it hyphenates in its language.
     setCjkLineBreak(resolved.cjk.lineBreak);
@@ -306,6 +314,15 @@ function placeDocumentPass(content, config, cache, options, hints) {
     // And, in an Arabic-script book, read a number that opens a paragraph as
     // the numbers after its letters (#665).
     setMeasureArabicNumbers(arabicNumbersOf(resolved));
+    // A word with no letter is shaped in the script of the text around it,
+    // and with no letter near in the script of the document's language (#725).
+    // A Chinese or Japanese document sets its doubled ellipsis and dash as
+    // Han text wherever they are cited.
+    setMeasureScriptContext({
+        enabled: resolved.bodyText.scriptContext !== false,
+        script: scriptContextOfLocale(resolvedLocale(resolved)),
+        ...(hanMarksOfLocale(resolvedLocale(resolved)) ? { hanMarks: true } : {}),
+    });
     // Compute baseline grid
     const baselineGrid = computeBaselineGrid(resolved);
     // Create document
@@ -337,6 +354,19 @@ function placeDocumentPass(content, config, cache, options, hints) {
     // styled section with its own margins / layout — the section's.
     let contentArea = pageMetrics.contentArea;
     let geomResolved = resolved;
+    /** How many columns of a fresh page take body text, in the geometry
+     *  pages are opened with now (`hyphenateAcrossColumns: 'withinPage'`,
+     *  #701: every that many column ends, a page ends). */
+    let freshFlowColumnsOf;
+    let freshFlowColumns = 1;
+    const freshPageFlowColumns = () => {
+        if (freshFlowColumnsOf !== geomResolved) {
+            freshFlowColumnsOf = geomResolved;
+            const fresh = createPageWithColumns(doc.pages.length, geomResolved, contentArea, pageWidthPx, pageHeightPx, pageIndexOffset);
+            freshFlowColumns = Math.max(1, fresh.columns.filter((c) => c.kind !== 'side').length);
+        }
+        return freshFlowColumns;
+    };
     // Page/bleed frames for design elements anchored to `'page'` / `'bleed'`,
     // in the frame of the page's flow: the sheet's, or on a vertical page
     // (`page.flow`) the flow frame, where "the top of the page" is the
@@ -382,6 +412,11 @@ function placeDocumentPass(content, config, cache, options, hints) {
     const parsedBody = numberTitlesFor(headingMarksFor(tashkilFor(literalBreaksFor(parseMarkdownMemo(markdownBody, codeParseOptions(resolved)), resolved), resolved.bodyText.tashkil), resolved), resolved);
     const citationContext = content.citations
         ?? (needsCitationContext(parsedBody, frontmatterMeta) ? bookCitationContexts([{ metadata: frontmatterMeta, blocks: parsedBody }], content.resources)[0] : undefined);
+    // `citations.hyphenateNames: false`: the cited authors' names are never
+    // divided, in a citation, in the text or in the bibliography (#699).
+    if (citationContext && !resolved.citations.hyphenateNames) {
+        setHyphenationRules({ ...hyphenationRules, names: citedNames(citationContext.items) });
+    }
     const citationsApplied = citationContext
         ? applyCitations(parsedBody, citationContext, processCitations(citationContext, resolved, citationLocale(resolved, resolvedLocale(resolved))), resolved, resolvedLocale(resolved))
         : undefined;
@@ -543,6 +578,30 @@ function placeDocumentPass(content, config, cache, options, hints) {
     /** The flow segment has ended and its floats and side boxes are taking
      *  pages after the text (see `drainPendingFloats`, #639). */
     let drainingAfterText = false;
+    /** Opener pages (`layout.openerFloats`, #749): the page a part opens,
+     *  the page a heading opens with its own break, and the first page of a
+     *  document that starts with a heading. Under `'avoid'` they offer a
+     *  float no slot (see `placeFloatInColumns`), so it takes the first one
+     *  after them; under `'warn'` each float set on one is reported. */
+    const openerPages = new Set();
+    const openerFloatRule = resolved.layout.openerFloats;
+    /** The `openerFloat` warnings of this pass, and the floats they name. */
+    const openerFloatNotes = [];
+    const openerFloatsNoted = new Set();
+    const noteOpenerFloat = (page, f) => {
+        if (openerFloatRule !== 'warn' || !openerPages.has(page) || openerFloatsNoted.has(f.resourceId))
+            return;
+        openerFloatsNoted.add(f.resourceId);
+        const box = f.callout ? calloutFloats.get(f.callout.startIdx) : undefined;
+        const first = contentBlocks[box ? f.callout.startIdx : f.firstBlockIdx];
+        const last = contentBlocks[box ? box.plan.endIdx : f.firstBlockIdx];
+        openerFloatNotes.push({
+            kind: 'openerFloat',
+            ...(box ? {} : { resourceId: f.resourceId }),
+            ...(first && last ? { sourceStart: first.sourceStart + bodyOffset, sourceEnd: last.sourceEnd + bodyOffset } : {}),
+            pageIndex: page.index,
+        });
+    };
     /** `span: 'side'` boxes of a style with `sideAtColumnEnd: 'after'`
      *  (EF-161), and the side boxes fenced behind them, waiting for the text
      *  after their fence to land (see `settleAwaitingSideBoxes`). Each keeps
@@ -1496,6 +1555,10 @@ function placeDocumentPass(content, config, cache, options, hints) {
         return { measure, ...band, cap, fits: excessOf(measure, band) <= 0.01 };
     };
     const placeFloatInColumns = (page, f, targetCols, position, pageSpan, mode, anchorToCap = false, side = false, refY) => {
+        // An opener page takes no float (`layout.openerFloats: 'avoid'`, #749):
+        // it waits for the page the flow opens next.
+        if (openerFloatRule === 'avoid' && openerPages.has(page))
+            return 'defer';
         const first = targetCols[0];
         const probe = probeFloatBand(page, f, targetCols, position, pageSpan, anchorToCap, side, refY);
         if (!probe)
@@ -1568,6 +1631,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
                 return 'skip';
             first.availableHeight = Math.max(0, first.availableHeight - need);
             commitFloatBlock(page, first, built, xLeft, y, width, f.firstBlockIdx);
+            noteOpenerFloat(page, f);
             if (drainingAfterText && !calloutFloatOf(f.resourceId)) {
                 const citing = contentBlocks[f.firstBlockIdx];
                 setAfterText.set(built.block, {
@@ -1843,6 +1907,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
             }
         }
         commitFloatBlock(page, first, built, xLeft, y, width, f.firstBlockIdx);
+        noteOpenerFloat(page, f);
         floatsPlaced++;
         return rest ? { rest } : 'placed';
     };
@@ -2067,8 +2132,10 @@ function placeDocumentPass(content, config, cache, options, hints) {
         const cursorCol = page.columns[cursor.columnIndex];
         if (!cursorCol)
             return false;
+        // (A short list set whole stays under what introduces it: only the
+        // cursor's column counts for it, #749.)
         const candidates = bandColumns(page, currentBand(page, cursor))
-            .filter((c) => c.kind !== 'span' && c.index >= cursorCol.index && (c === cursorCol || c.blocks.length === 0));
+            .filter((c) => c.kind !== 'span' && c.index >= cursorCol.index && (c === cursorCol || (!box.stays && c.blocks.length === 0)));
         const fitsIn = (c, available) => available >= box.heightAt(c.bbox.width) - 0.01;
         if (!candidates.some((c) => fitsIn(c, c.availableHeight)))
             return false;
@@ -2083,12 +2150,13 @@ function placeDocumentPass(content, config, cache, options, hints) {
      *  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.
      *  `nextBlockIdx` is that block: a keep-together box it opens holds the
-     *  slots that would starve it (see `slotStarvesBox`). */
+     *  slots that would starve it (see `slotStarvesBox`), and so does a
+     *  short list set whole (`shortListBoxAt`). */
     const tryPlacePendingFloatsOnCurrentPage = (preferTop = false, nextBlockIdx, anyPosition = false) => {
         if (pendingFloats.length === 0)
             return;
         const page = doc.pages[cursor.pageIndex];
-        const box = nextBlockIdx !== undefined ? keepTogetherBoxAt(nextBlockIdx) : null;
+        const box = nextBlockIdx !== undefined ? (keepTogetherBoxAt(nextBlockIdx) ?? shortListBoxAt(nextBlockIdx)) : null;
         for (let i = 0; i < pendingFloats.length;) {
             if (heldBack(i)) {
                 i++;
@@ -2848,6 +2916,8 @@ function placeDocumentPass(content, config, cache, options, hints) {
                     // setting it one line shorter, #662): painted with it too.
                     if (m.letterSpacingPx !== undefined)
                         blk.letterSpacing = m.letterSpacingPx;
+                    if (m.runtTracking !== undefined)
+                        blk.runtFix = { tracking: m.runtTracking };
                     blk.lines = resetLinePositions(raggedLooseLines(m.measured.lines, noteStyle.textAlign), noteStyle.lineHeightPx).map((line) => ({
                         ...line,
                         bbox: createBoundingBox(line.bbox.x + x, line.bbox.y + y, line.bbox.width, line.bbox.height),
@@ -2979,6 +3049,70 @@ function placeDocumentPass(content, config, cache, options, hints) {
     let inlineGapOwed = null;
     /** The pending spacing a heading, a display formula or a box at `idx`
      *  collapses its top margin with (see `inlineGapOwed`). */
+    /**
+     * What a heading that opens a column keeps of its space above (#706),
+     * 0 when it keeps none. `s0` is the space it takes above it after a
+     * paragraph of body text, `S` its height plus its bottom margin as the
+     * snap reads them, `u` the column's used height:
+     *
+     *     kept = s0 − (snap(u + s0 + S) − snap(u + S))
+     *
+     * the whole grid lines the column head saves are dropped and the rest
+     * stays. `kept` is less than a grid line and `u + kept + S` never passes
+     * `snap(u + S)`, so the box's foot stays on its grid line. A run of
+     * headings (the first does not snap because a heading follows it) reads
+     * as one block: `S` runs from the first heading's top to the last one's
+     * foot plus its bottom margin, the margins between them collapsed as the
+     * placement loop collapses them, and `kept` goes above the first. A run
+     * with a designed, page-span, hidden or `lineSpan` heading in it, or one
+     * whose last heading does not snap, keeps today's placement; so does a
+     * heading whose snapped box does not fit the column.
+     */
+    const columnHeadKept = (blockIdx, rawBlock, usedHeight, height, style, snaps, col, ctx) => {
+        let S;
+        if (snaps) {
+            S = height + style.marginBottomPx;
+        }
+        else {
+            const own = headingLevels.forBlock(rawBlock);
+            const ownSnaps = own?.snapToGrid ?? resolved.headings.snapToGrid;
+            if (!own || !ownSnaps || own.advancedDesign.enabled || nextNonMarkerBlock(contentBlocks, blockIdx)?.type !== 'heading')
+                return 0;
+            let run = height;
+            let pending = style.marginBottomPx;
+            let closed;
+            for (let j = blockIdx + 1; j < contentBlocks.length; j++) {
+                const b = contentBlocks[j];
+                if (isMarkerBlock(b))
+                    continue;
+                const lvl = b.type === 'heading' ? headingLevels.forBlock(b) : undefined;
+                if (!lvl || lvl.span === 'page' || lvl.advancedDesign.enabled || headingIsHidden(b, lvl))
+                    return 0;
+                const m = measureContentBlock(b, j, col.bbox.width, ctx);
+                if (!m || m.kind.vdtType !== 'heading' || m.kind.style.lineSpan !== undefined)
+                    return 0;
+                const st = m.kind.style;
+                run += Math.max(pending, st.marginTopPx) + m.measured.lines.length * st.lineHeightPx;
+                if (nextNonMarkerBlock(contentBlocks, j)?.type === 'heading') {
+                    pending = st.marginBottomPx;
+                    continue;
+                }
+                if (lvl.snapToGrid ?? resolved.headings.snapToGrid)
+                    closed = run + st.marginBottomPx;
+                break;
+            }
+            if (closed === undefined)
+                return 0;
+            S = closed;
+        }
+        const snap = (x) => Math.ceil((x - 0.01) / baselineGrid) * baselineGrid;
+        const s0 = Math.max(ctx.bodyStyle.marginBottomPx, style.marginTopPx);
+        const foot = snap(usedHeight + S);
+        if (foot > col.bbox.height + FIT_EPS)
+            return 0;
+        const kept = s0 - (snap(usedHeight + s0 + S) - foot);
+        return kept > 0.01 ? kept : 0;
+    };
     const pendingBeforeSelfSnapping = (idx) => inlineGapOwed && inlineGapOwed.afterIdx === idx - 1 && pendingSpacing === inlineGapOwed.pending
         ? inlineGapOwed.exact
         : pendingSpacing;
@@ -3324,7 +3458,8 @@ function placeDocumentPass(content, config, cache, options, hints) {
             // The cut is measured from under the float bands the proposing pass
             // had at the band's head, which may not have landed yet.
             const top = Math.max(bandTop(cols), bareBandTop(cols, floatHeadOf) + (cap.headPx ?? 0));
-            applyBandCap(cols, cap.lines * baselineGrid, uncappedBottoms, cap.zone, cap.kind === 'trailing', top);
+            // (A trailing cap counts the lines of its band's own leading, #711.)
+            applyBandCap(cols, cap.lines * (cap.pitchPx ?? baselineGrid), uncappedBottoms, cap.zone, cap.kind === 'trailing', top);
             cappedBandColumns.set(spanIndex, cols);
             activeCap = { spanIndex, pageIndex: page.index, band };
             bandCapsApplied.add(spanIndex);
@@ -3349,7 +3484,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
      * the displaced text (see {@link bandCapLinesAroundZone}) — the box then
      * fits on the page, under its columns, rather than opening a page alone.
      */
-    const proposeTrailingCap = (boundaryIndex, zone) => {
+    const proposeTrailingCap = (boundaryIndex, zone, closeLevel = false) => {
         const balancingCfg = resolved.headings.balancing;
         if (!balancingCfg.enabled || !balancingCfg.trailing)
             return;
@@ -3385,9 +3520,25 @@ function placeDocumentPass(content, config, cache, options, hints) {
         if (!bandStart || !registeredBand || registeredBand.pageIndex !== page.index || registeredBand.band !== band)
             return;
         const bottoms = cols.map((c) => c.bbox.y + (c.bbox.height - c.availableHeight));
-        const aroundZone = zone ? bandCapLinesAroundZone(cols, baselineGrid, zone, (c) => columnBottom(c, uncappedBottoms)) : null;
-        if (aroundZone === null && Math.max(...bottoms) - Math.min(...bottoms) <= baselineGrid + 0.5)
+        // The cut counts lines of the band's own text (#711,
+        // `trailingStep: 'lines'`): an index or a list of references set on a
+        // leading of its own is cut, and retried, by whole lines of that
+        // leading, where a cut on the body grid lets a line more into one
+        // column and each retry lowers it by more than a line of the band. A
+        // band of body text has the grid for its pitch.
+        const pitch = balancingCfg.trailingStep === 'grid' ? baselineGrid : bandLinePitch(cols, baselineGrid);
+        const aroundZone = zone ? bandCapLinesAroundZone(cols, pitch, zone, (c) => columnBottom(c, uncappedBottoms)) : null;
+        if (aroundZone === null && Math.max(...bottoms) - Math.min(...bottoms) <= baselineGrid + 0.5) {
+            // A band that is level already needs no cap and no second pass, but
+            // it ends here all the same: where the boundary closes the flow of
+            // its page, its columns are cut on the grid line under its text, as
+            // a delivered cap would leave them, so the column rule stops with
+            // the text and not at the page foot (#713). Nothing is to be filled
+            // up to the cut, so the columns are not flagged `trailingCap`.
+            if (closeLevel)
+                closeLevelBand(cols, bottoms);
             return;
+        }
         // Float bands reserved at the columns' feet are the band's content too:
         // the level cut must leave them room under the text (a figure placed
         // before a span box then anchors to the cut, see `anchorToCap`). A band
@@ -3405,24 +3556,43 @@ function placeDocumentPass(content, config, cache, options, hints) {
         const top = bandTop(cols);
         const floatHeads = cols
             .filter((c) => c.blocks.length === 0 && reservedOf(c).top > 0)
-            .map((c) => Math.ceil((c.bbox.y - top - 0.01) / baselineGrid));
+            .map((c) => Math.ceil((c.bbox.y - top - 0.01) / pitch));
         // So does one set under a page-span opener at the head of the opener's
         // own column (#639).
         for (const c of cols) {
             if (c.headFloatFoot !== undefined)
-                floatHeads.push(Math.ceil((c.headFloatFoot - top - 0.01) / baselineGrid));
+                floatHeads.push(Math.ceil((c.headFloatFoot - top - 0.01) / pitch));
         }
         bandCapProposals.set(boundaryIndex, {
             kind: 'trailing',
             startContentIndex: bandStart.contentIndex,
             startPart: bandStart.part,
             ...(bandStart.visit > 0 ? { startVisit: bandStart.visit } : {}),
-            lines: aroundZone ?? Math.max(bandCapLines(cols, baselineGrid, footBands), ...floatHeads),
+            lines: aroundZone ?? Math.max(bandCapLines(cols, pitch, footBands), ...floatHeads),
+            ...(pitch !== baselineGrid ? { pitchPx: pitch, retryLimit: capRetryLimit(pitch, baselineGrid) } : {}),
             retries: 0,
             ...(aroundZone !== null ? { zone } : {}),
             ...capHeadPx(cols),
         });
     };
+    /** Cut the columns of a closing band that ends level on the grid line
+     *  under its lowest text (#713). What a column paints below its used
+     *  height counts too (a tail whose negative margin snapped the flow back
+     *  above its last line): the renderers clip a column to its box. The true
+     *  bottoms go to `uncappedBottoms`, as under a delivered cap, so notes and
+     *  floats keep reading the page's foot. */
+    const closeLevelBand = (cols, bottoms) => {
+        const top = bandTop(cols);
+        let lowest = Math.max(...bottoms);
+        for (const c of cols) {
+            for (const b of c.blocks) {
+                if (!b.hidden)
+                    lowest = Math.max(lowest, paintedBottom(b), b.bbox.y + b.bbox.height);
+            }
+        }
+        const lines = Math.ceil((lowest - top - 0.01) / baselineGrid);
+        applyBandCap(cols, lines * baselineGrid, uncappedBottoms, undefined, false, top);
+    };
     /** Close the flow at a chapter-level boundary (block `boundaryIndex`):
      *  floats take the page's free slots, the closing band is levelled, the
      *  page is marked as an explicit break, and every float still pending is
@@ -3458,7 +3628,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
             pendingFloats.splice(i, 1);
         }
         tryPlacePendingFloatsOnCurrentPage();
-        proposeTrailingCap(boundaryIndex);
+        proposeTrailingCap(boundaryIndex, undefined, true);
         markForcedBreak();
         hugClosingText();
         drainPendingFloats();
@@ -3613,6 +3783,60 @@ function placeDocumentPass(content, config, cache, options, hints) {
             n++;
         return n;
     };
+    /**
+     * An index group divided between two columns keeps at least
+     * `index.groups.splitMinEntries` entries on each side (#712). `entry` is
+     * the entry block about to leave `col` (it does not fit, or would be
+     * divided between its lines); `k` entries of its group already close the
+     * column and `r` are still to place, this one included. Too few behind
+     * (`k < min`): the `k` go on with it. Too few ahead (`r < min`): enough of
+     * them go on for the next column to open with `min`, and all of them when
+     * that would leave too few behind. The blocks taken off the column are
+     * returned in column order (the caller rewinds to the first), with the
+     * run of headings they would strand; empty when the rule asks for
+     * nothing or cannot be met: the group's entries are all the column holds
+     * under its headings (they would open the next column as they open this
+     * one), or the entry that would lead the move is the rest of one begun
+     * in the column before.
+     */
+    const rollbackIndexGroup = (col, entry, min) => {
+        const info = entry.index;
+        if (!info || min <= 1 || info.groupIndex === undefined || info.groupPlace === undefined || info.groupSize === undefined)
+            return [];
+        const sameGroup = (b) => {
+            const raw = b.contentIndex !== undefined ? contentBlocks[b.contentIndex] : undefined;
+            return raw?.index !== undefined && raw.index.groupIndex === info.groupIndex && raw.sourceStart === entry.sourceStart;
+        };
+        let k = 0;
+        for (let j = col.blocks.length - 1; j >= 0 && sameGroup(col.blocks[j]); j--)
+            k++;
+        if (k === 0)
+            return [];
+        const r = info.groupSize - info.groupPlace;
+        let take = 0;
+        if (k < min)
+            take = k;
+        else if (r < min)
+            take = k - (min - r) < min ? k : min - r;
+        if (take === 0)
+            return [];
+        // Nothing but the group under the column's headings: it stays.
+        const above = col.blocks.slice(0, col.blocks.length - k);
+        if (take === k && above.every((b) => isFreeHeading(b) || b.hidden))
+            return [];
+        // The rest of an entry begun in the column before cannot move back.
+        if (col.blocks[col.blocks.length - take].id.includes('-cont-'))
+            return [];
+        let left = take;
+        const popped = rollbackTrailingBlocks(col, doc.blocks, () => left-- > 0);
+        // The headings the group stood under go with it.
+        const heads = take === k ? rollbackHeadings(col) : [];
+        // The space above the blocks taken off is the column's again.
+        const last = col.blocks[col.blocks.length - 1];
+        if (last)
+            col.availableHeight = col.bbox.y + col.bbox.height - (last.bbox.y + last.bbox.height);
+        return [...heads, ...popped];
+    };
     /** 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
@@ -4090,6 +4314,9 @@ function placeDocumentPass(content, config, cache, options, hints) {
          * to the head or foot of a page, the bands it was floated to.
          */
         const placeSpanFloatsAtCut = (page, capActiveHere) => {
+            // Not on an opener page that takes no float (#749).
+            if (openerFloatRule === 'avoid' && openerPages.has(page))
+                return false;
             let placedAny = false;
             for (let i = 0; i < pendingFloats.length;) {
                 const f = pendingFloats[i];
@@ -4135,6 +4362,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
                     offsetResourceBlockToAbsolute(built.block.resourceBlock, 0, built.block.bbox.y);
                 built.block.contentIndex = f.firstBlockIdx;
                 doc.blocks.push(built.block);
+                noteOpenerFloat(page, f);
                 floatsPlaced++;
                 placedAny = true;
                 pendingFloats.splice(i, 1);
@@ -4393,8 +4621,9 @@ function placeDocumentPass(content, config, cache, options, hints) {
                 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);
+                    // stretching its last column to the page bottom meanwhile. A band
+                    // that is level already is closed at its text (#713).
+                    proposeTrailingCap(startIdx, undefined, true);
                     markForcedBreak();
                 }
                 else if (capActive && cap?.kind === 'trailing') {
@@ -4921,6 +5150,65 @@ function placeDocumentPass(content, config, cache, options, hints) {
             return true;
         }
     };
+    /** Whether a resource set in the text asks for its caption in the side
+     *  column (#729): `placement.captionSide` on a `span: 'column'` embed,
+     *  `layout.inlineCaptionSide` on, a horizontal page, and no text wrapped
+     *  round it. The side column and its room are looked at where the block
+     *  is placed ({@link measureInlineAside}). */
+    const inlineAsideWanted = (resource, type, page) => {
+        if (!resource || !resolved.layout.inlineCaptionSide || pageIsVertical(page))
+            return false;
+        const placement = resolveResourcePlacement(resource, type);
+        if (!placement.captionSide || placement.span !== 'column')
+            return false;
+        return resolveResourceWrap(resource, type, resolved.layout.wrap) === undefined;
+    };
+    /** Whether the side column `sc` is free over the band a caption
+     *  `asideHeight` tall takes beside an embed placed next in `c`: the side
+     *  stack ends above the embed's top, the band ends inside the side
+     *  column, and no obstacle (a heading design, another embed's caption)
+     *  stands in it or within the float gap of it. */
+    const inlineAsideFree = (c, sc, spacing, asideHeight) => {
+        const top = c.bbox.y + (c.bbox.height - c.availableHeight) + (c.blocks.length === 0 ? 0 : spacing);
+        const bottom = top + asideHeight;
+        if (sideUsedBottom(sc) > top + 0.5)
+            return false;
+        if (bottom > sc.bbox.y + sc.bbox.height + 0.5)
+            return false;
+        return !(sideObstacles.get(sc) ?? []).some((o) => o.bottom + floatGapPx > top + 0.5 && o.top - floatGapPx < bottom - 0.5);
+    };
+    /** The embed measured for column `c` with its caption and note in the
+     *  band's float-only side column, level with the body's top (#729), or
+     *  `null` when the band has no such column or it is not free there: the
+     *  caption then stays under the body. */
+    const measureInlineAside = (raw, blockIdx, c, page, ctx, base, spacing) => {
+        if (c.kind === 'span' || c.kind === 'side')
+            return null;
+        const sideCol = sideColumnOf(page, c.band ?? 0);
+        if (!sideCol || sideCol.bbox.width <= 0.5)
+            return null;
+        const opts = { captionAside: { dx: sideCol.bbox.x - c.bbox.x, width: sideCol.bbox.width } };
+        const block = measureContentBlock(raw, blockIdx, c.bbox.width, ctx, { ...base, ...opts });
+        if (!block?.resourceBlock || block.asideHeight === undefined || block.resourceBlock.rotation)
+            return null;
+        if (!inlineAsideFree(c, sideCol, spacing, block.asideHeight))
+            return null;
+        return { block, opts, sideCol, col: c };
+    };
+    /** The band an embed's side caption takes in the side column, recorded
+     *  as an obstacle of its stack: side floats and side boxes set later go
+     *  above it when they fit there, else under it. */
+    const markInlineAside = (blk, sideCol, asideHeight) => {
+        if (!(asideHeight > 0))
+            return;
+        const mark = { owner: blk, top: blk.bbox.y, bottom: blk.bbox.y + asideHeight };
+        const list = sideObstacles.get(sideCol);
+        if (list)
+            list.push(mark);
+        else
+            sideObstacles.set(sideCol, [mark]);
+        sideObstacleColumn.set(blk, sideCol);
+    };
     /**
      * An inline table (`::resource` placed `here`) that does not fit the room
      * left in its column (#634), by its style's `overflow` when
@@ -4937,10 +5225,12 @@ function placeDocumentPass(content, config, cache, options, hints) {
      * table is placed as one block by the caller (it fits, or the rule does
      * not apply), `'dropped'`, or `'placed'`: every slice is placed and the
      * cursor sits in the column of the last one, which the caller snaps
-     * under. `blk` is the first slice's block, filled in here.
+     * under. `blk` is the first slice's block, filled in here. With
+     * `asideWanted` the first slice sets its caption in the side column when
+     * that is free beside it (#729); the continuations are set as ever.
      */
     const MIN_HEAD_ROWS = 2;
-    const placeInlineTableSlices = (raw, blockIdx, blk, ctx, styleOverride, resource, wholeHeight, spacingBefore) => {
+    const placeInlineTableSlices = (raw, blockIdx, blk, ctx, styleOverride, resource, wholeHeight, spacingBefore, asideWanted = false) => {
         const style = pickTableStyle(resolved, resource.table?.styleId);
         if (!style.splitInline || pageIsVertical(doc.pages[cursor.pageIndex]))
             return 'whole';
@@ -4988,6 +5278,8 @@ function placeDocumentPass(content, config, cache, options, hints) {
         let part = 0;
         let moves = 0;
         let block = blk;
+        /** Columns where the first slice's caption found no room at the side. */
+        const asideRefused = new Set();
         for (;;) {
             enterBand(blockIdx, part);
             let col = currentColumn(doc, cursor);
@@ -4999,8 +5291,15 @@ function placeDocumentPass(content, config, cache, options, hints) {
             const metrics = metricsAt(width) ?? firstMetrics;
             const spacing = part === 0 && col.blocks.length > 0 ? spacingBefore : 0;
             const avail = col.availableHeight - spacing;
+            // The first slice with its caption in the side column (#729).
+            const asideHere = asideWanted && startRow === 0 && !asideRefused.has(col)
+                ? measureInlineAside(raw, blockIdx, col, doc.pages[cursor.pageIndex], ctx, { styleOverride }, spacing)
+                : null;
+            const sliceAt = (s) => (asideHere
+                ? measureContentBlock(raw, blockIdx, width, ctx, { styleOverride, ...(s ? { tableSlice: s } : {}), ...asideHere.opts })
+                : measureAt(width, s));
             const restSlice = startRow > 0 ? { startRow, endRow: rowCount, continues: false } : undefined;
-            const rest = measureAt(width, restSlice);
+            const rest = sliceAt(restSlice);
             if (!rest?.resourceBlock)
                 return part === 0 ? 'whole' : 'placed';
             let placed = rest;
@@ -5014,7 +5313,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
                     continue;
                 }
                 const firstBody = startRow > 0 ? Math.max(startRow, headerRows) : headerRows;
-                const probe = measureAt(width, { startRow, endRow: firstBody + 1, continues: true });
+                const probe = sliceAt({ startRow, endRow: firstBody + 1, continues: true });
                 const overhead = probe?.resourceBlock ? probe.measured.totalHeight - probe.resourceBlock.bodyRect.height : 0;
                 // An empty column of full height (or a run of short ones behind)
                 // takes the smallest slice even when it overflows: a fresh page
@@ -5024,7 +5323,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
                     floor: floorOf(startRow),
                     force,
                     split: overflow === 'split',
-                    fits: (s) => (measureAt(width, s)?.measured.totalHeight ?? Infinity) <= avail + FIT_EPS,
+                    fits: (s) => (sliceAt(s)?.measured.totalHeight ?? Infinity) <= avail + FIT_EPS,
                 });
                 if (!slice) {
                     // Not even the head rows fit: the (rest of the) table starts in
@@ -5034,11 +5333,17 @@ function placeDocumentPass(content, config, cache, options, hints) {
                     advanceToNextColumn(doc, cursor, geomResolved, contentArea, pageWidthPx, pageHeightPx, onAtomicNewPage(minHeightAt(width, startRow)));
                     continue;
                 }
-                const m = measureAt(width, slice);
+                const m = sliceAt(slice);
                 if (!m?.resourceBlock)
                     return part === 0 ? 'whole' : 'placed';
                 placed = m;
             }
+            // The slice's caption (a line longer with its continuation suffix,
+            // perhaps) must still find the side column free.
+            if (asideHere && (placed.asideHeight === undefined || !inlineAsideFree(col, asideHere.sideCol, spacing, placed.asideHeight))) {
+                asideRefused.add(col);
+                continue;
+            }
             // The slice's block: the first one is the caller's.
             if (part > 0) {
                 block = createVDTBlock(`block-${blockIdCounter++}`, 'resource', blk.fontString, blk.color, blk.textAlign);
@@ -5065,6 +5370,8 @@ function placeDocumentPass(content, config, cache, options, hints) {
                 col.availableHeight -= spacing;
             placeBlockInColumn(block, height, col, cursor);
             offsetResourceBlockToAbsolute(rb, block.bbox.x, block.bbox.y);
+            if (asideHere && placed.asideHeight !== undefined)
+                markInlineAside(block, asideHere.sideCol, placed.asideHeight);
             doc.blocks.push(block);
             enterBand(blockIdx, part);
             if (!slice?.continues)
@@ -5316,6 +5623,188 @@ function placeDocumentPass(content, config, cache, options, hints) {
             slackWeight: body.slackWeight,
         }).splitAt > 0;
     };
+    // --- Short lists kept whole (`bodyText.shortListSplit`, #749) -------------
+    const shortListRule = resolved.bodyText.shortListSplit;
+    /** The short lists of the running text by the content index of their
+     *  first item (`null`: a block that opens none). */
+    const shortLists = new Map();
+    /**
+     * The short list content block `idx` opens: a run of list items (seen
+     * through container markers, its nested lists included) of up to
+     * `bodyText.shortListMaxItems` items, `idx` being its first. Not the
+     * entries of the contents or of an index, which are set as list items.
+     */
+    const shortListFrom = (idx) => {
+        const known = shortLists.get(idx);
+        if (known !== undefined)
+            return known ?? undefined;
+        const isItem = (b) => b?.type === 'listItem' && b.toc === undefined && b.index === undefined;
+        let found = null;
+        if (isItem(contentBlocks[idx]) && prevNonMarkerBlock(contentBlocks, idx)?.type !== 'listItem') {
+            const items = [];
+            let i = idx;
+            for (; i < contentBlocks.length; i++) {
+                const b = contentBlocks[i];
+                if (isMarkerBlock(b))
+                    continue;
+                if (!isItem(b))
+                    break;
+                items.push(i);
+                if (items.length > resolved.bodyText.shortListMaxItems)
+                    break;
+            }
+            if (items.length <= resolved.bodyText.shortListMaxItems)
+                found = { items };
+        }
+        shortLists.set(idx, found);
+        return found ?? undefined;
+    };
+    /** The room a short list takes in a column `width` wide, from the top of
+     *  its first line to the foot of its last (the space above it aside),
+     *  and its lines, for the notes they cite. Undefined when an item
+     *  cannot be measured. */
+    const shortListNeed = (list, width, ctx) => {
+        let height = 0;
+        const lines = [];
+        let prev;
+        for (const idx of list.items) {
+            const raw = contentBlocks[idx];
+            const item = measureContentBlock(raw, idx, width, ctx);
+            if (!item)
+                return undefined;
+            if (prev) {
+                height += listItemGapPx({ spacingPx: listItemSpacingPx(prev, ctx.resolved), depth: prev.depth ?? 1 }, { spacingPx: listItemSpacingPx(raw, ctx.resolved), depth: raw.depth ?? 1 });
+            }
+            height += item.measured.lines.length * item.kind.style.lineHeightPx;
+            lines.push(...item.measured.lines);
+            prev = raw;
+        }
+        return { height, lines };
+    };
+    /**
+     * The room the floats text block `blockIdx` cites would take from the
+     * foot of `col` once their citing lines are placed: for each one still
+     * held back for it, the band of its first slot on the page, when that is
+     * a foot band over `col` that the room the block leaves under it
+     * (`roomAfter`) still holds. Read before the block is placed, so an
+     * estimate: the colon line of a short list set whole counts it, since
+     * the figure that line cites takes the foot of the column right after
+     * it, where the list would have gone.
+     */
+    const citedFootTake = (blockIdx, col, roomAfter) => {
+        const page = doc.pages[cursor.pageIndex];
+        if (openerFloatRule === 'avoid' && openerPages.has(page))
+            return 0;
+        let take = 0;
+        for (const [id, gate] of citationGates) {
+            if (gate.blockIdx !== blockIdx)
+                continue;
+            const f = pendingFloats.find((p) => p.resourceId === id);
+            const slot = f ? enumerateCurrentPageSlots(page, cursor.columnIndex, f, capKindOf, openerHeadOf)[0] : undefined;
+            if (!f || !slot || slot.side || slot.position !== 'bottom' || !slot.cols.includes(col))
+                continue;
+            const probe = probeFloatBand(page, f, slot.cols, slot.position, slot.pageSpan, false);
+            if (!probe)
+                continue;
+            const band = col.availableHeight - availableAfterBand(col, 'bottom', probe, false);
+            if (band <= roomAfter + FIT_EPS)
+                take = Math.max(take, band);
+        }
+        return take;
+    };
+    /** The short list item `idx` belongs to, and its place in it. */
+    const shortListItemAt = (idx) => {
+        if (contentBlocks[idx]?.type !== 'listItem')
+            return undefined;
+        let start = idx;
+        for (let i = idx - 1, seen = 0; i >= 0 && seen <= resolved.bodyText.shortListMaxItems; i--) {
+            const b = contentBlocks[i];
+            if (isMarkerBlock(b))
+                continue;
+            if (b.type !== 'listItem')
+                break;
+            start = i;
+            seen++;
+        }
+        const list = shortListFrom(start);
+        const item = list ? list.items.indexOf(idx) : -1;
+        return list && item >= 0 ? { list, item } : undefined;
+    };
+    /**
+     * Under `'avoid'`, the short list content block `idx` opens or goes on
+     * with, as the floats offered a slot right before it see a keep-together
+     * box (`slotStarvesBox`): its height at a column width, from that item
+     * on. A float yields to it when the cursor's column holds the list whole
+     * and would not with the float: the figure a list's own lead-in cites
+     * would otherwise take the foot of the column once its citing line is
+     * placed, and cut the list under it.
+     */
+    const shortListBoxAt = (idx) => {
+        if (shortListRule !== 'avoid')
+            return null;
+        const at = shortListItemAt(idx);
+        if (!at)
+            return null;
+        const ctx = partPlan.byBlock[idx] ? partMeasureCtx : sectionMeasureCtx(sectionPlan.byBlock[idx]);
+        const rest = { items: at.list.items.slice(at.item) };
+        const heights = new Map();
+        return {
+            stays: true,
+            heightAt: (width) => {
+                const key = Math.round(width * 100);
+                let h = heights.get(key);
+                if (h === undefined) {
+                    const need = shortListNeed(rest, width, ctx);
+                    h = need ? need.height + pendingSpacing : 0;
+                    heights.set(key, h);
+                }
+                return h;
+            },
+        };
+    };
+    /** A `shortListSplit` warning for each short list whose items the pass
+     *  set in more than one column: all of them under `'warn'`, under
+     *  `'avoid'` the ones no column could hold whole. */
+    const shortListWarnings = () => {
+        if (shortListRule === 'allow')
+            return [];
+        // Where each list item of the running text landed (a box's children
+        // carry `containerId`).
+        const placed = new Map();
+        for (const page of doc.pages) {
+            for (const c of page.columns) {
+                for (const b of c.blocks) {
+                    if (b.type !== 'listItem' || b.containerId !== undefined || b.contentIndex === undefined)
+                        continue;
+                    const at = placed.get(b.contentIndex) ?? { pageIndex: page.index, columns: new Set() };
+                    at.columns.add(`${page.index}:${c.index}`);
+                    placed.set(b.contentIndex, at);
+                }
+            }
+        }
+        const out = [];
+        for (let idx = 0; idx < contentBlocks.length; idx++) {
+            const list = placed.has(idx) ? shortListFrom(idx) : undefined;
+            if (!list)
+                continue;
+            const columns = new Set();
+            for (const item of list.items)
+                for (const key of placed.get(item)?.columns ?? [])
+                    columns.add(key);
+            if (columns.size < 2)
+                continue;
+            const first = contentBlocks[list.items[0]];
+            const last = contentBlocks[list.items[list.items.length - 1]];
+            out.push({
+                kind: 'shortListSplit',
+                items: list.items.length,
+                sourceStart: first.sourceStart + bodyOffset,
+                sourceEnd: last.sourceEnd + bodyOffset,
+                pageIndex: placed.get(idx).pageIndex,
+            });
+        }
+        return out;
+    };
     /** The page break into a page of the parity `even` asks (a spread opens
      *  on a verso, an even page): the page the cursor stands on, an empty
      *  one, is marked a parity blank and passed while its number is odd. Even
@@ -5433,6 +5922,9 @@ function placeDocumentPass(content, config, cache, options, hints) {
         inlineGapOwed = pendingSpacing > 0 ? { afterIdx: blockIdx, pending: pendingSpacing, exact: owed } : null;
         return undefined;
     };
+    /** The first block of the document that sets something: a heading there
+     *  opens the document's first page (`openerPages`, #749). */
+    const firstFlowBlockIdx = contentBlocks.findIndex((b) => !isMarkerBlock(b) && b.type !== 'directive');
     for (let blockIdx = 0; blockIdx < contentBlocks.length; blockIdx++) {
         if (options?.shouldCancel?.())
             throw new BuildCancelledError();
@@ -5606,6 +6098,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
                     titleSourceStart,
                     titleSourceEnd,
                 }, pageIndexOffset);
+                openerPages.add(doc.pages[cursor.pageIndex]);
                 flushPendingNumberingAtBoundary();
                 continue;
             }
@@ -5774,6 +6267,9 @@ function placeDocumentPass(content, config, cache, options, hints) {
         if (rawBlock.type === 'heading' && rawBlock.level) {
             const level = headingLevels.forBlock(rawBlock);
             const bb = level?.breakBefore;
+            /** The heading opens its page (#749): with its own break, or as the
+             *  first block of the document. */
+            let opensPage = blockIdx === firstFlowBlockIdx;
             if (bb && bb.enabled) {
                 pendingSpacing = 0;
                 closeFlowSegment(blockIdx);
@@ -5782,6 +6278,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
                     enforcePageParity(doc, cursor, geomResolved, contentArea, pageWidthPx, pageHeightPx, bb.parity);
                 }
                 flushPendingNumberingAtBoundary();
+                opensPage = true;
             }
             // `span: 'page'` headings open a chapter band across the full content
             // width. Always start on a fresh page boundary so the band sits at the
@@ -5795,7 +6292,10 @@ function placeDocumentPass(content, config, cache, options, hints) {
                 advanceToNextPageBoundary(doc, cursor, geomResolved, contentArea, pageWidthPx, pageHeightPx);
                 cursor.columnIndex = 0;
                 flushPendingNumberingAtBoundary();
+                opensPage = true;
             }
+            if (opensPage)
+                openerPages.add(doc.pages[cursor.pageIndex]);
         }
         const id = `block-${blockIdCounter++}`;
         // Enclosing `:::paragraphs` container (if any). Its last paragraph — the
@@ -5828,8 +6328,9 @@ function placeDocumentPass(content, config, cache, options, hints) {
          *  block keeps its own space in its snap, and the container's
          *  `marginBottom` follows as pending spacing from the closing marker. */
         const containerTail = isContainerTail && rawBlock.type === 'paragraph' ? paragraphContainer : undefined;
+        // (A paragraph style may set the rule for its own containers, #715.)
         const collapseTail = containerTail !== undefined
-            && resolved.bodyText.paragraphContainerSpacing === 'collapse'
+            && (containerTail.spacing ?? resolved.bodyText.paragraphContainerSpacing) === 'collapse'
             && containerTail.tailStyle.marginBottomPx >= 0;
         const tailStyle = collapseTail && blockMeasureCtx.bodyStyle.marginBottomPx > containerTail.tailStyle.marginBottomPx
             ? { ...containerTail.tailStyle, marginBottomPx: blockMeasureCtx.bodyStyle.marginBottomPx }
@@ -5872,6 +6373,18 @@ function placeDocumentPass(content, config, cache, options, hints) {
         let measuredBlock = tryLoose
             ? measureLooseParagraph(rawBlock, blockIdx, col.bbox.width, blockMeasureCtx, styleOverride, looseLines, trackingLadder, looseOutcome, looseOffGrid)
             : measureContentBlock(rawBlock, blockIdx, measureWidth, blockMeasureCtx, { styleOverride, ...upright, ...figureDelta });
+        // A resource set in the text with `captionSide` (#729): its caption and
+        // note go to the band's side column when that is free beside it, and
+        // the block is as tall as the body alone. Decided again in every
+        // column the block is tried in (see the resource branch below).
+        const asideWanted = measuredBlock?.kind.vdtType === 'resource' && rawBlock.type === 'resourceBlock'
+            && inlineAsideWanted(measuredBlock.kind.resource, measuredBlock.kind.resourceType, blockPage);
+        let inlineAside = asideWanted
+            ? measureInlineAside(rawBlock, blockIdx, col, blockPage, blockMeasureCtx, { styleOverride, ...figureDelta }, Math.max(pendingSpacing, floatGapPx))
+            : null;
+        if (inlineAside)
+            measuredBlock = inlineAside.block;
+        const asideOpts = inlineAside?.opts;
         // An inline picture with a safe area a little too tall for the room
         // left in its column is cropped within its safe area to stay there
         // rather than move on and leave the column short (#442).
@@ -5881,7 +6394,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
             const over = measuredBlock.measured.totalHeight - room;
             if (over > 0.01 && room > 0 && over <= flex.shrink + 0.01) {
                 const cropped = measureContentBlock(rawBlock, blockIdx, measureWidth, blockMeasureCtx, {
-                    styleOverride, ...upright, figureHeightDelta: flex.delta - over,
+                    styleOverride, ...upright, ...asideOpts, figureHeightDelta: flex.delta - over,
                 });
                 if (cropped && cropped.measured.totalHeight <= room + 0.01)
                     measuredBlock = cropped;
@@ -5905,7 +6418,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
                     width = current.bodyRect.width * Math.min(scale, 0.99);
                     if (width < rb.bodyRect.width * MIN_INLINE_FIGURE_SCALE)
                         break;
-                    const smaller = measureContentBlock(rawBlock, blockIdx, col.bbox.width, blockMeasureCtx, { styleOverride, figureMaxBodyWidth: width });
+                    const smaller = measureContentBlock(rawBlock, blockIdx, col.bbox.width, blockMeasureCtx, { styleOverride, ...asideOpts, figureMaxBodyWidth: width });
                     if (!smaller)
                         break;
                     measuredBlock = smaller;
@@ -5915,10 +6428,13 @@ function placeDocumentPass(content, config, cache, options, hints) {
                 // Still too tall at the smallest acceptable size: back to full size
                 // and on to the next column, as without the option.
                 if (measuredBlock.measured.totalHeight > room + FIT_EPS) {
-                    measuredBlock = measureContentBlock(rawBlock, blockIdx, col.bbox.width, blockMeasureCtx, { styleOverride });
+                    measuredBlock = measureContentBlock(rawBlock, blockIdx, col.bbox.width, blockMeasureCtx, { styleOverride, ...asideOpts });
                 }
             }
         }
+        // The fits above keep the caption at the side: they work on the body.
+        if (inlineAside)
+            inlineAside = measuredBlock?.asideHeight !== undefined ? { ...inlineAside, block: measuredBlock } : null;
         if (tryLoose && budget !== undefined && knownOutcome === undefined && typeof looseOutcome.get(blockIdx) === 'number') {
             looseGained.set(budget.group, (looseGained.get(budget.group) ?? 0) + 1);
         }
@@ -5931,7 +6447,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
         let capInfo = measuredBlock.dropCap;
         /** Tracking the block's lines are set with; a paragraph moved whole into
          *  a column of another width is measured again, and may change it. */
-        let { letterSpacingPx } = measuredBlock;
+        let { letterSpacingPx, runtTracking } = measuredBlock;
         const { vdtType, headingLevel, numberPrefix, numberSeparator, headingNumber, listBullet, listDepth, listKind, bulletXOffsetInColumn, strikethroughText } = kind;
         // A structural heading (`hidden`) is placed like any heading — its
         // break, keep-with-next and grid snap apply — but with no line height
@@ -5950,8 +6466,8 @@ function placeDocumentPass(content, config, cache, options, hints) {
         // --- Resource blocks (image / svg / table + caption) -----------------
         // Placed atomically (kept-together) — no mid-content split for v1.
         if (vdtType === 'resource') {
-            const resourceBlock = measuredBlock.resourceBlock;
-            const groupHeight = measured.totalHeight;
+            let resourceBlock = measuredBlock.resourceBlock;
+            let groupHeight = measured.totalHeight;
             const blk = createVDTBlock(id, 'resource', style.fontString, style.color, style.textAlign);
             blk.contentIndex = blockIdx;
             stampBlockExtras(blk, rawBlock);
@@ -6010,7 +6526,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
             // An inline table that does not fit the room left in its column is
             // cut between rows (#634), by the rules of a floated one.
             const sliced = !wraps && !resourceBlock.rotation && resourceBlock.table && kind.resource
-                ? placeInlineTableSlices(rawBlock, blockIdx, blk, blockMeasureCtx, styleOverride, kind.resource, groupHeight, spacingBefore)
+                ? placeInlineTableSlices(rawBlock, blockIdx, blk, blockMeasureCtx, styleOverride, kind.resource, groupHeight, spacingBefore, asideWanted)
                 : 'whole';
             if (sliced === 'dropped') {
                 flushPendingNumberingAtBoundary();
@@ -6019,6 +6535,44 @@ function placeDocumentPass(content, config, cache, options, hints) {
             const columnBefore = col;
             if (sliced === 'whole') {
                 enterBand(blockIdx, 0);
+                // A side caption is decided where the block is placed (#729): an
+                // embed that does not fit its column moves on by the rule of
+                // `placeAtomicBlock`, and in each column it reaches its caption
+                // goes to the side when the side column is free there, else under
+                // the body.
+                if (asideWanted) {
+                    let decidedFor = col;
+                    let plain = inlineAside ? undefined : measuredBlock;
+                    for (let guard = 0;; guard++) {
+                        const c = currentColumn(doc, cursor);
+                        if (c !== decidedFor) {
+                            decidedFor = c;
+                            inlineAside = measureInlineAside(rawBlock, blockIdx, c, doc.pages[cursor.pageIndex], blockMeasureCtx, { styleOverride, ...figureDelta }, spacingBefore);
+                            if (!inlineAside && plain === undefined) {
+                                plain = measureContentBlock(rawBlock, blockIdx, measureWidth, blockMeasureCtx, { styleOverride, ...figureDelta });
+                            }
+                            const next = inlineAside?.block ?? plain;
+                            if (next?.resourceBlock) {
+                                resourceBlock = next.resourceBlock;
+                                groupHeight = next.measured.totalHeight;
+                            }
+                            else {
+                                inlineAside = null;
+                            }
+                        }
+                        const available = c.availableHeight - (c.blocks.length === 0 ? 0 : spacingBefore);
+                        if (groupHeight <= available + FIT_EPS)
+                            break;
+                        if (c.blocks.length === 0 && c.availableHeight >= 0.5 && groupHeight > contentArea.height + FIT_EPS)
+                            break;
+                        if (guard >= 8)
+                            break;
+                        advanceToNextColumn(doc, cursor, geomResolved, contentArea, pageWidthPx, pageHeightPx, onAtomicNewPage(groupHeight));
+                    }
+                    blk.resourceBlock = resourceBlock;
+                    blk.lines[0].bbox = { x: 0, y: 0, width: resourceBlock.bodyRect.width, height: groupHeight };
+                }
+                const decidedColumn = currentColumn(doc, cursor);
                 placeAtomicBlock(blk, groupHeight, spacingBefore, cursor, doc, geomResolved, contentArea, pageWidthPx, pageHeightPx, onAtomicNewPage(groupHeight));
                 enterBand(blockIdx, 0);
                 // Too tall for the room left in its column, a wrapped picture moved
@@ -6033,6 +6587,9 @@ function placeDocumentPass(content, config, cache, options, hints) {
                 // resource's own caption/table lines live on `resourceBlock` and must be
                 // offset to absolute page coordinates here using the placed bbox origin.
                 offsetResourceBlockToAbsolute(resourceBlock, blk.bbox.x, blk.bbox.y);
+                if (inlineAside && inlineAside.block.asideHeight !== undefined && currentColumn(doc, cursor) === decidedColumn) {
+                    markInlineAside(blk, inlineAside.sideCol, inlineAside.block.asideHeight);
+                }
                 const grown = figureGrowPx > 0 ? resourceBlock.bodyFlex?.delta ?? 0 : 0;
                 if (grown > 0.01) {
                     blk.balancing = { levers: ['flexFigure'], spaceAbove: 0, bodyGrowth: grown };
@@ -6219,6 +6776,23 @@ function placeDocumentPass(content, config, cache, options, hints) {
         /** Whether the paragraph was already re-broken to keep a hyphen off
          *  the last line of a column (`bodyText.hyphenateAcrossColumns`). */
         let columnEndHyphenRetried = false;
+        /** The lines (1-based, counted from the first line still to place) the
+         *  guard keeps a hyphen off: the line the split falls after and one
+         *  every full column after it, or, under `'withinPage'` (#701), those
+         *  of them that close a page — the j-th column end from here does when
+         *  the `rest` columns left on this page that still take a line of this
+         *  text are used up and a whole number of fresh pages, of `perPage`
+         *  flow columns each, has gone by. */
+        const guardedColumnEnds = (mode, splitAt, lineCount, fullColumn, page, columnIndex) => {
+            const ends = [];
+            const rest = mode === false ? 0 : flowColumnsAfter(page, columnIndex, style.lineHeightPx);
+            const perPage = mode === false ? 1 : freshPageFlowColumns();
+            for (let n = splitAt, j = 0; n < lineCount; n += fullColumn, j++) {
+                if (j >= rest && (j - rest) % perPage === 0)
+                    ends.push(n);
+            }
+            return ends;
+        };
         /** `hyphenateAcrossColumns: false`: the paragraph's lines as set now
          *  (a re-break replaces them) and where the breaker broke them, the
          *  lines (1-based) its last re-break kept a hyphen off, and the part
@@ -6288,6 +6862,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
                         laterWidths = [];
                         wrapInsets = [];
                         letterSpacingPx = again.letterSpacingPx;
+                        runtTracking = again.runtTracking;
                         remainingLines = [...raggedLooseLines(again.measured.lines, style.textAlign)];
                         paragraphLines = remainingLines;
                         paragraphBreaks = again.measured.breaks;
@@ -6462,6 +7037,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
                         if (placed === 0) {
                             capInfo = again.dropCap;
                             letterSpacingPx = again.letterSpacingPx;
+                            runtTracking = again.runtTracking;
                             guardedEnds = [];
                             columnEndHyphenRetried = false;
                         }
@@ -6493,7 +7069,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
             // block fits when its lines and all their notes do, and a split
             // keeps the lines whose notes fit under them.
             const noteCosts = vdtType === 'mathDisplay' ? undefined : notesPrefixCost(curCol, remainingLines);
-            const effectiveAvailable = curCol.availableHeight - spacingBefore - (noteCosts ? noteCosts[noteCosts.length - 1] : 0);
+            let effectiveAvailable = curCol.availableHeight - spacingBefore - (noteCosts ? noteCosts[noteCosts.length - 1] : 0);
             // A hair of tolerance: room of exactly N lines (grid arithmetic in
             // floats — a column cut by a band cap, a balancing extra line) must
             // hold N lines, not N - 1.
@@ -6567,6 +7143,28 @@ function placeDocumentPass(content, config, cache, options, hints) {
                     headingDesign = { lvl, info };
                 }
             }
+            // With `headings.columnHeadSpace: 'remainder'` (#706) a heading that
+            // opens a column drops its space above in whole grid lines only: what is
+            // left of a line stays above it, so its text starts as far under it
+            // as under the same heading set after a paragraph. The foot of its
+            // box stays on the grid line the snap puts it on, and no line of body
+            // text moves. A heading the grid does not snap, a hidden one, a
+            // `lineSpan` band, a page-span opener and a heading painted from its
+            // own design (its band is the design's, drawn from the column's head)
+            // keep the head of the column; so does the first block of a column
+            // under an opener band, which is set level with the first block
+            // under the opener (`openerHead`).
+            if (vdtType === 'heading' && partIndex === 0 && !hiddenHeading && lineSpan === undefined
+                && resolved.headings.columnHeadSpace === 'remainder'
+                && (isFirstInColumn || underOpenerHeadFloat(curCol)) && openerHead === undefined
+                && !headingSetsOwnBand(headingLevels.forBlock(rawBlock))) {
+                const usedHeight = curCol.bbox.height - curCol.availableHeight;
+                const kept = columnHeadKept(blockIdx, rawBlock, usedHeight, effectiveRemainHeight, style, shouldSnapToGrid, curCol, blockMeasureCtx);
+                if (kept > 0) {
+                    spacingBefore += kept;
+                    effectiveAvailable -= kept;
+                }
+            }
             // Keep-with-list: if this colon-paragraph would fit but would leave no
             // room for the first list item, split off the colon line (or push the
             // whole paragraph when it is a single line or the split would leave a
@@ -6595,6 +7193,17 @@ function placeDocumentPass(content, config, cache, options, hints) {
                     effectiveGap = Math.ceil((paragraphBottom + effectiveGap - 0.01) / baselineGrid) * baselineGrid - paragraphBottom;
                 }
                 const minSpaceForList = effectiveGap + bodyStyle.lineHeightPx;
+                // A short list set whole (`shortListSplit: 'avoid'`, #749) needs
+                // all its room under the colon line, when a column can hold the
+                // line and the list at all — less what a figure this paragraph
+                // cites will take from the column's foot (`citedFootTake`).
+                let listIdx = blockIdx + 1;
+                while (listIdx < contentBlocks.length && isMarkerBlock(contentBlocks[listIdx]))
+                    listIdx++;
+                const wholeList = shortListRule === 'avoid' ? shortListFrom(listIdx) : undefined;
+                const wholeNeed = wholeList ? shortListNeed(wholeList, curCol.bbox.width, blockMeasureCtx) : undefined;
+                const keepsListWhole = wholeNeed !== undefined
+                    && style.lineHeightPx + effectiveGap + wholeNeed.height <= contentArea.height + FIT_EPS;
                 // A line of room is not always enough (EF-110): with
                 // `colonListRoom: 'item'` the first item has to be able to start
                 // there, by the rules that split it — a two-line item the orphan
@@ -6602,7 +7211,8 @@ function placeDocumentPass(content, config, cache, options, hints) {
                 // check, one line.
                 if (availableAfter < minSpaceForList - FIT_EPS
                     || (resolved.bodyText.colonListRoom === 'item'
-                        && !firstListItemStarts(blockIdx, availableAfter - effectiveGap, curCol.bbox.width, blockMeasureCtx))) {
+                        && !firstListItemStarts(blockIdx, availableAfter - effectiveGap, curCol.bbox.width, blockMeasureCtx))
+                    || (keepsListWhole && availableAfter - effectiveGap - citedFootTake(blockIdx, curCol, availableAfter) < wholeNeed.height - FIT_EPS)) {
                     const effectiveWidowMin = resolved.bodyText.avoidWidows
                         ? Math.max(1, resolved.bodyText.widowMinLines)
                         : 1;
@@ -6615,6 +7225,8 @@ function placeDocumentPass(content, config, cache, options, hints) {
                         applyStyleAttrs(blk, style);
                         if (letterSpacingPx !== undefined)
                             blk.letterSpacing = letterSpacingPx;
+                        if (runtTracking !== undefined)
+                            blk.runtFix = { tracking: runtTracking };
                         blk.contentIndex = blockIdx;
                         stampBlockExtras(blk, rawBlock);
                         blk.headingLevel = headingLevel;
@@ -6719,6 +7331,8 @@ function placeDocumentPass(content, config, cache, options, hints) {
                         applyStyleAttrs(blk, style);
                         if (letterSpacingPx !== undefined)
                             blk.letterSpacing = letterSpacingPx;
+                        if (runtTracking !== undefined)
+                            blk.runtFix = { tracking: runtTracking };
                         blk.contentIndex = blockIdx;
                         stampBlockExtras(blk, rawBlock);
                         blk.lines = resetLinePositions(splitLines, style.lineHeightPx);
@@ -6759,6 +7373,40 @@ function placeDocumentPass(content, config, cache, options, hints) {
                     }
                 }
             }
+            // A short list is set whole (`bodyText.shortListSplit: 'avoid'`,
+            // #749): when its items do not all fit under what the column holds
+            // and an empty column would hold them, the list opens the next
+            // column, with the headings right above it. Not a list a colon line
+            // introduces: that line already took the list's room into account,
+            // and the two stay together. Nor one that opens its column, or
+            // stands under nothing but headings: it cannot do better anywhere.
+            if (vdtType === 'listItem' && partIndex === 0 && shortListRule === 'avoid' && curCol.blocks.length > 0) {
+                const list = shortListFrom(blockIdx);
+                const headingRun = trailingHeadingRun(curCol);
+                const lead = list ? prevNonMarkerBlock(contentBlocks, blockIdx) : undefined;
+                const colonLed = lead?.type === 'paragraph' && resolved.bodyText.keepColonWithList && /[:：︰﹕]\s*$/.test(lead.text);
+                const need = list && !colonLed && headingRun < curCol.blocks.length
+                    ? shortListNeed(list, curCol.bbox.width, blockMeasureCtx)
+                    : undefined;
+                if (need && need.height <= contentArea.height + FIT_EPS) {
+                    const listNotes = notesPrefixCost(curCol, need.lines);
+                    const room = curCol.availableHeight - spacingBefore - (listNotes ? listNotes[listNotes.length - 1] : 0);
+                    if (need.height > room + FIT_EPS) {
+                        if (resolved.headings.keepWithNext && headingRun > 0) {
+                            const rolledBack = rollbackHeadings(curCol);
+                            if (rolledBack.length > 0) {
+                                blockIdx = (rolledBack[0].contentIndex ?? blockIdx - rolledBack.length) - 1;
+                                pendingSpacing = 0;
+                                advanceToNextColumn(doc, cursor, geomResolved, contentArea, pageWidthPx, pageHeightPx, onNewPage);
+                                break;
+                            }
+                        }
+                        pendingSpacing = 0;
+                        advanceToNextColumn(doc, cursor, geomResolved, contentArea, pageWidthPx, pageHeightPx, onNewPage);
+                        continue;
+                    }
+                }
+            }
             // 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:
@@ -6833,6 +7481,8 @@ function placeDocumentPass(content, config, cache, options, hints) {
                 applyStyleAttrs(blk, style);
                 if (letterSpacingPx !== undefined)
                     blk.letterSpacing = letterSpacingPx;
+                if (runtTracking !== undefined)
+                    blk.runtFix = { tracking: runtTracking };
                 blk.contentIndex = blockIdx;
                 stampBlockExtras(blk, rawBlock);
                 if (partIndex === 0) {
@@ -6911,6 +7561,21 @@ function placeDocumentPass(content, config, cache, options, hints) {
                 if (vdtType === 'heading' && effectiveRemainHeight > totalRemainHeight && h > curCol.availableHeight + FIT_EPS) {
                     h = Math.max(effectiveRemainHeight, curCol.availableHeight);
                 }
+                // A block whose lines fit, and whose snap would reach the grid line
+                // under the column's foot (a foot the notes reserved there took off
+                // the grid, or a bottom margin on the column's last line), ends at
+                // the foot (#716): its box stays inside its column and the room left
+                // reads 0, not a negative height. The space it still owed is dropped,
+                // as pending spacing is at any column's end. A column cut by a band
+                // cap keeps the overrun: there it is how the block's bottom margin
+                // reaches the page-span box under the cut (`bandUsedBottomWithSide`).
+                if (shouldSnapToGrid && partIndex === 0
+                    && !uncappedBottoms.has(curCol)
+                    && h > curCol.availableHeight + FIT_EPS
+                    && effectiveRemainHeight <= curCol.availableHeight + FIT_EPS) {
+                    h = Math.max(effectiveRemainHeight, curCol.availableHeight);
+                    tailOwed = 0;
+                }
                 placeBlockInColumn(blk, h, curCol, cursor);
                 citedLinesPlaced(blockIdx, blk);
                 finalizeListItem(blk, partIndex === 0);
@@ -6942,6 +7607,18 @@ function placeDocumentPass(content, config, cache, options, hints) {
                 }
                 break;
             }
+            // An index entry that leaves the column takes the entries of its
+            // group the keep rule does not let stay with it (#712): the roll-back
+            // comes before any cut between its own lines.
+            if (rawBlock.index && partIndex === 0 && curCol.blocks.length > 0) {
+                const rolledBack = rollbackIndexGroup(curCol, rawBlock, blockMeasureCtx.resolved.index.groups.splitMinEntries);
+                if (rolledBack.length > 0) {
+                    blockIdx = (rolledBack[0].contentIndex ?? blockIdx - rolledBack.length) - 1;
+                    pendingSpacing = 0;
+                    advanceToNextColumn(doc, cursor, geomResolved, contentArea, pageWidthPx, pageHeightPx, onNewPage);
+                    break;
+                }
+            }
             // Block doesn't fit — try to split (orphan/widow-aware)
             const inList = vdtType === 'listItem';
             const effectiveAvoidOrphans = resolved.bodyText.avoidOrphans
@@ -6999,19 +7676,23 @@ function placeDocumentPass(content, config, cache, options, hints) {
                 // placement then starts over with its lines. Only a paragraph set
                 // from its first line here — its earlier lines are not placed yet —
                 // and never one the balancing is running long.
+                //
+                // `'withinPage'` (#701) guards only the ends that close a page: this
+                // column's when no later column of its page takes text, and then
+                // one every page of full columns. With none in the paragraph,
+                // nothing is measured again.
+                const hyphenGuard = resolved.bodyText.hyphenateAcrossColumns;
                 if (choice.splitAt > 0
-                    && !resolved.bodyText.hyphenateAcrossColumns
+                    && hyphenGuard !== true
                     && !columnEndHyphenRetried
                     && partIndex === 0
                     && looseLines === undefined) {
                     const fullColumn = Math.max(1, Math.floor((contentArea.height + 0.01) / style.lineHeightPx));
-                    const ends = [];
-                    for (let n = choice.splitAt; n < remainingLines.length; n += fullColumn)
-                        ends.push(n);
+                    const ends = guardedColumnEnds(hyphenGuard, choice.splitAt, remainingLines.length, fullColumn, doc.pages[cursor.pageIndex], cursor.columnIndex);
                     /** How a setting ends its guarded lines: whether this column's
                      *  last line is hyphenated, and how many guarded lines are. */
                     const columnEndHyphens = (lines) => ({
-                        first: lines[choice.splitAt - 1]?.hyphenated === true,
+                        first: ends[0] === choice.splitAt && lines[choice.splitAt - 1]?.hyphenated === true,
                         count: ends.filter((n) => lines[n - 1]?.hyphenated).length,
                     });
                     const natural = columnEndHyphens(remainingLines);
@@ -7050,18 +7731,19 @@ function placeDocumentPass(content, config, cache, options, hints) {
                 // this column's end (or fewer at the ends still to come). The
                 // placed lines are checked again all the same: a break trace from
                 // the other measuring path cannot keep them.
+                // Under `'withinPage'` only from a column that closes its page.
                 if (choice.splitAt > 0
-                    && !resolved.bodyText.hyphenateAcrossColumns
+                    && hyphenGuard !== true
                     && partIndex > 0
                     && columnEndHyphenPart !== partIndex
                     && looseLines === undefined
-                    && remainingLines[choice.splitAt - 1]?.hyphenated === true) {
+                    && remainingLines[choice.splitAt - 1]?.hyphenated === true
+                    && (hyphenGuard === false || columnClosesPage(doc.pages[cursor.pageIndex], cursor.columnIndex, style.lineHeightPx))) {
                     columnEndHyphenPart = partIndex;
                     const placed = paragraphLines.length - remainingLines.length;
                     const fullColumn = Math.max(1, Math.floor((contentArea.height + 0.01) / style.lineHeightPx));
-                    const later = [];
-                    for (let n = choice.splitAt; n < remainingLines.length; n += fullColumn)
-                        later.push(placed + n);
+                    const later = guardedColumnEnds(hyphenGuard, choice.splitAt, remainingLines.length, fullColumn, doc.pages[cursor.pageIndex], cursor.columnIndex)
+                        .map((n) => placed + n);
                     // The ends already placed keep their guard; the later ones the
                     // last re-break assumed give way to where the columns now end.
                     const ends = [...guardedEnds.filter((n) => n <= placed), ...later];
@@ -7123,6 +7805,8 @@ function placeDocumentPass(content, config, cache, options, hints) {
                     applyStyleAttrs(blk, style);
                     if (letterSpacingPx !== undefined)
                         blk.letterSpacing = letterSpacingPx;
+                    if (runtTracking !== undefined)
+                        blk.runtFix = { tracking: runtTracking };
                     blk.contentIndex = blockIdx;
                     stampBlockExtras(blk, rawBlock);
                     if (partIndex === 0) {
@@ -7226,6 +7910,8 @@ function placeDocumentPass(content, config, cache, options, hints) {
             applyStyleAttrs(blk, style);
             if (letterSpacingPx !== undefined)
                 blk.letterSpacing = letterSpacingPx;
+            if (runtTracking !== undefined)
+                blk.runtFix = { tracking: runtTracking };
             blk.contentIndex = blockIdx;
             stampBlockExtras(blk, rawBlock);
             // Stamp the prefix as the other placement branches do: a full-page
@@ -7444,6 +8130,10 @@ function placeDocumentPass(content, config, cache, options, hints) {
         floatShrinkWarningsByDoc.set(doc, shrunk);
     if (textWrapNotes.length > 0 || columnsNotes.length > 0)
         textWrapWarningsByDoc.set(doc, [...textWrapNotes, ...columnsNotes]);
+    // The composition rules (#749): short lists cut, floats on opener pages.
+    const ruleNotes = [...shortListWarnings(), ...openerFloatNotes];
+    if (ruleNotes.length > 0)
+        compositionWarningsByDoc.set(doc, ruleNotes);
     const { proposals: citingPageProposals, refused: citingPageRefused } = settleCitingPageFloats();
     return { doc, forcedBreakPages, bandCapProposals, spanPlacedInBand, bandCapsApplied, looseOutcome, looseOffGrid, captionUnderProposals, citingPageProposals, citingPageRefused };
 }
@@ -7514,7 +8204,7 @@ export function* buildDocumentGen(content, config, cache, options) {
     // cap; words of a joining script that run past their line, and styles
     // whose letter-spacing such words do not take.
     // Line numbers set over a float of the side column (#621).
-    const loose = [...cjkLooseLineWarnings(doc), ...wordOverflowWarnings(doc), ...(joiningSpacingWarnings.get(doc) ?? []), ...(dropCapWarningsByDoc.get(doc) ?? []), ...lineNumberWarnings(doc), ...codeOverflowWarnings(doc), ...(floatShrinkWarningsByDoc.get(doc) ?? []), ...(textWrapWarningsByDoc.get(doc) ?? [])];
+    const loose = [...cjkLooseLineWarnings(doc), ...raggedLineWarnings(doc), ...wordOverflowWarnings(doc), ...(joiningSpacingWarnings.get(doc) ?? []), ...(dropCapWarningsByDoc.get(doc) ?? []), ...lineNumberWarnings(doc), ...codeOverflowWarnings(doc), ...(floatShrinkWarningsByDoc.get(doc) ?? []), ...(textWrapWarningsByDoc.get(doc) ?? []), ...(compositionWarningsByDoc.get(doc) ?? [])];
     // Side boxes and side floats set on pages after the text, and what the
     // layout could place nowhere (#639).
     loose.push(...afterTextWarnings(doc), ...(unplacedByDoc.get(doc) ?? []));
@@ -7573,6 +8263,9 @@ const floatShrinkWarningsByDoc = new WeakMap();
 /** The `textWrap` warnings of a build (#627) and its `columnsTooNarrow`
  *  ones (#634), found by its last pass. */
 const textWrapWarningsByDoc = new WeakMap();
+/** The `shortListSplit` and `openerFloat` warnings of a build (#749),
+ *  found by its last pass. */
+const compositionWarningsByDoc = new WeakMap();
 /** What a pass set in the side column of a page opened after the text of
  *  its chapter (#639): a side box's frame, a side float's block, with the
  *  source range an `afterText` warning points at. Read from the finished
@@ -8017,16 +8710,25 @@ citing = { hints: new Map(), refused: new Set() }) {
             return false;
         if (newLines.length === 0 && newLoose.length === 0)
             return false;
+        // Where the headings hold lines back for the loose paragraphs (#707),
+        // a pass that tried both in the columns at fault blames the paragraphs
+        // first: run a line long, they are what moves text across a column
+        // break, and a heading blacklisted with them could never take the lines
+        // it took alone up to 1.27. The spacing levers are tried again without
+        // them, and blacklisted in their turn if the cascade is theirs.
+        const looseFirst = balancing.maxLinesBeforeLoose < balancing.maxLinesPerHeading;
         const blacklist = (cands) => {
             let hit = false;
-            for (const k of newLines)
+            for (const k of newLoose)
                 if (!cands || cands.has(k)) {
-                    s.failedLines.add(k);
+                    s.failedLoose.add(k);
                     hit = true;
                 }
-            for (const k of newLoose)
+            if (hit && looseFirst)
+                return true;
+            for (const k of newLines)
                 if (!cands || cands.has(k)) {
-                    s.failedLoose.add(k);
+                    s.failedLines.add(k);
                     hit = true;
                 }
             return hit;
@@ -8056,10 +8758,13 @@ citing = { hints: new Map(), refused: new Set() }) {
             }
             const proposal = proposeBalanceLines(best.doc, best.forcedBreakPages, applied, {
                 maxLinesPerHeading: balancing.maxLinesPerHeading,
+                maxLinesBeforeLoose: balancing.maxLinesBeforeLoose,
                 stretchAfterLists: balancing.stretchAfterLists,
                 maxLinesAfterList: balancing.maxLinesAfterList,
+                stretchAfterDisplays: balancing.stretchAfterDisplays,
                 stretchAfterFloats: balancing.stretchAfterFloats,
                 maxLinesAfterFloat: balancing.maxLinesAfterFloat,
+                stretchAfterWideFloats: balancing.stretchAfterWideFloats,
                 looseParagraphs: balancing.looseParagraphs,
                 maxLooseParagraphs: balancing.maxLooseParagraphs,
                 optimalLineBreaking: best.doc.config.bodyText.optimalLineBreaking,