postext 1.15.1 → 1.16.0

package/dist/pipeline/build.js

@@ -30,20 +30,20 @@ import { resetLinePositions, createPageWithColumns, currentColumn, advanceToNext
 import { chooseParagraphSplit } from './orphanWidow';
 import { applyStyleAttrs, computePageMetrics, flowPageMirrored, sheetRectToFlow, isMarkerBlock, nextNonMarkerBlock, spaceLinesAfter, prevNonMarkerBlock, rollbackTrailingBlocks, } from './buildHelpers';
 import { measureContentBlock } from './measureContentBlock';
-import { paragraphStyleIdOf, planParagraphContainers } from './paragraphContainers';
+import { containerStyle, paragraphStyleIdOf, planParagraphContainers } from './paragraphContainers';
 import { appendChapterEndNotes, footnoteIdsOfLines, footnoteParagraphStyle, noteContentBlock, noteNumberPositionOf, numberFootnotes, numberFootnotesByPlacement, sameFootnoteNumbers, splitFootnoteDefinitions, withFootnoteStyle, } from './footnotes';
 import { planParts, derivePartMeasureContext } from './parts';
-import { layoutCallout, offsetCalloutToAbsolute, pickCalloutStyle, planCallouts, resolveCalloutAttrs, } from './calloutLayout';
+import { layoutCallout, offsetBlock, offsetCalloutToAbsolute, pickCalloutStyle, planCallouts, resolveCalloutAttrs, } from './calloutLayout';
 import { layoutResourceBlock, planTableSlice } from './resourceLayout';
 import { computeFloatPlan, floatedResourceIds, } from './floatPlacement';
 import { enumerateCurrentPageSlots, measureFloatBand, floatGapAbove, measureSideStack, clearSideObstacles, columnHasFloatBand, fitsStrict, trueBottom, } from './floatSlots';
 import { computeHeadingContext, computeResourceNumbering, } from './resourceNumbering';
-import { defaultResourceTypes, documentLocale } from '../defaults/resourceTypes';
+import { documentLocale, effectiveResourceTypes } from '../defaults/resourceTypes';
 import { pickTableStyle } from '../defaults/tableStyle';
 import { buildHeadersAndFooters, defaultOpenerTitle, headingDesignBoxes, headingTitleText, measureDefaultOpenerHeight, measureHeadingDesign } from './headerFooter';
 import { flowColorValues } from './partPalette';
 import { chapterNumberCounter, leadingBoldText } from './placeholders';
-import { proposeBalanceLines, collectColumnGaps, firstDivergentColumn, gapLinesIn, boxRoomIn, boxLeverKeys, pageSegments, MAX_BALANCING_PASSES, MAX_BALANCING_PASSES_PER_DOCUMENT, balanceKey } from './columnBalancing';
+import { proposeBalanceLines, 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 { raggedLooseLines } from './raggedLines';
 import { cjkLooseLineWarnings, collectContentWarnings, joiningLetterSpacingWarnings, locateContentWarnings, wordOverflowWarnings } from './contentWarnings';
@@ -54,6 +54,7 @@ import { tashkilFor } from './tashkil';
 import { overlineEmphasis } from '../emphasisOverline';
 import { withBookTitleBrackets } from './annotations';
 import { paperByBlock, stampPagePaper } from './paper';
+import { headingLineSpanBand } from './lineSpan';
 /** Tolerance for "does this block fit" checks against a column's free
  *  height, absorbing floating-point drift between grid multiples. */
 const FIT_EPS = 0.01;
@@ -322,7 +323,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
     }
     const chapterEndNotes = resolved.footnotes.placement === 'chapterEnd' && footnoteNumbering.numbers.size > 0;
     const parsedBlocks = chapterEndNotes
-        ? appendChapterEndNotes(footnoteSplit.blocks, footnoteNumbering, footnoteDefs, noteNumberPositionOf(resolved.footnotes))
+        ? appendChapterEndNotes(footnoteSplit.blocks, footnoteNumbering, footnoteDefs, noteNumberPositionOf(resolved.footnotes, resolved.layout.writingMode === 'vertical-rl'), resolved.footnotes.numberGap)
         : footnoteSplit.blocks;
     const headingStart = continuation?.headings;
     // `:::toc` expands into the entries of the book's outline — the one the
@@ -354,10 +355,10 @@ function placeDocumentPass(content, config, cache, options, hints) {
     // captions and inline `:ref`s can resolve their rendered number strings
     // before measurement. Numbering follows order of first reference in the
     // document.
-    const resourceTypes = config?.resourceTypes ?? defaultResourceTypes(documentLocale(config));
     const resources = content.resources ?? [];
+    const resourceTypes = effectiveResourceTypes(config, resources);
     const headingContext = computeHeadingContext(contentBlocks, headingStart, isNumbered);
-    const resourceNumbering = computeResourceNumbering(contentBlocks, resourceTypes, resources, headingContext, continuation ? { counters: continuation.resourceCounters, numbered: continuation.resourceNumbers } : undefined, resolved.numerals);
+    const resourceNumbering = computeResourceNumbering(contentBlocks, resourceTypes, resources, headingContext, continuation ? { counters: continuation.resourceCounters, numbered: continuation.resourceNumbers } : undefined, resolved.numerals, documentLocale(config));
     // Lookups threaded into block-kind resolution + measurement.
     const resourceById = new Map();
     for (const r of resources)
@@ -672,6 +673,9 @@ function placeDocumentPass(content, config, cache, options, hints) {
         const resource = resourceById.get(resourceId);
         if (!resource)
             return null;
+        // Column balancing: a picture with a safe area grown by whole lines
+        // (`flexFigure`, #442).
+        const flexPx = balanceExtraPx?.get(flexFloatKey(resourceId)) ?? 0;
         return layoutResourceBlock({
             resource,
             resourceType: resourceTypeById.get(resource.typeId),
@@ -684,6 +688,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
             ...(slice ? { slice } : {}),
             ...(rotated ? (rotated.upright ? { upright: { maxLength: rotated.length } } : { rotate: rotated.direction, rotatedLength: rotated.length }) : {}),
             ...(aside ? { captionAside: aside } : {}),
+            ...(flexPx > 0 ? { bodyHeightDelta: flexPx } : {}),
         });
     };
     /** The rotation of a pending float on a band whose columns keep `avail`
@@ -812,6 +817,9 @@ function placeDocumentPass(content, config, cache, options, hints) {
         blk.dirty = false;
         blk.snappedToGrid = false;
         blk.bbox = createBoundingBox(x, 0, width, totalHeight);
+        if ((rb.bodyFlex?.delta ?? 0) > 0.01 && balanceExtraPx?.has(flexFloatKey(resourceId))) {
+            blk.balancing = { levers: ['flexFigure'], spaceAbove: 0, bodyGrowth: rb.bodyFlex.delta };
+        }
         blk.lines = [];
         if (rb.rotation) {
             // The upright frame's origin: for a counter-clockwise turn the frame's
@@ -835,6 +843,8 @@ function placeDocumentPass(content, config, cache, options, hints) {
     /** Float bands reserved per column in this pass (the fresh-page flush
      *  sends single-column floats to the least reserved column). */
     const floatReserved = new Map();
+    /** Pages a `:::pagebreak{center}` opened (#424). */
+    const centredPages = new Set();
     const reservedOf = (col) => floatReserved.get(col) ?? { top: 0, bottom: 0 };
     const floatHeadOf = (col) => reservedOf(col).top;
     /** `BandCap.headPx` for a cap proposed on `cols`: how far the float bands
@@ -1640,7 +1650,21 @@ function placeDocumentPass(content, config, cache, options, hints) {
     // places lines (`notesPrefixCost`), so the line citing a note and the note
     // share a column. The notes are set in their reserved room once the pass
     // is placed (`setColumnNotes`).
-    const columnNotes = resolved.footnotes.placement === 'column' && footnoteNumbering.numbers.size > 0;
+    //
+    // Sidenotes on the spread (`placement: 'spread'`, 傍注, JLReq §4.2.6; a
+    // vertical document's: a horizontal one resolves to `'column'`) use the
+    // same room, at the foot of the flow, which on a vertical page is its
+    // left end, the fore edge of a right-bound book's odd page. A spread is
+    // an even book page and the odd page after it. The notes cited on the
+    // odd page are reserved there as column notes; the ones cited on the
+    // even page wait for the odd page (`spreadDeferred`) and are reserved at
+    // the foot of its first column of text before anything it cites. A note
+    // that would leave the odd page without room for a line of its own text
+    // stays on the even page, at its foot (the overflow JLReq sends there);
+    // a line on the odd page whose notes no longer fit moves on, as any
+    // line with column notes does, to the next spread.
+    const spreadNotes = resolved.footnotes.placement === 'spread' && footnoteNumbering.numbers.size > 0;
+    const columnNotes = (resolved.footnotes.placement === 'column' || spreadNotes) && footnoteNumbering.numbers.size > 0;
     const noteStyle = columnNotes ? resolveParagraphStyle(footnoteParagraphStyle(resolved), resolved) : bodyStyle;
     const noteSpaceAbovePx = dimensionToPx(resolved.footnotes.spaceAbove, dpi, bodyStyle.fontSizePx);
     const noteSpaceBelowRulePx = dimensionToPx(resolved.footnotes.spaceBelowRule, dpi, bodyStyle.fontSizePx);
@@ -1658,7 +1682,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
         let m = noteMeasures.get(key);
         if (m === undefined) {
             const number = footnoteNumbering.numbers.get(id) ?? '?';
-            m = measureContentBlock(noteContentBlock(footnoteDefs.get(id), id, number, noteNumberPositionOf(resolved.footnotes)), 0, width, measureCtx, { styleOverride: noteStyle });
+            m = measureContentBlock(noteContentBlock(footnoteDefs.get(id), id, number, noteNumberPositionOf(resolved.footnotes, resolved.layout.writingMode === 'vertical-rl'), resolved.footnotes.numberGap), 0, width, measureCtx, { styleOverride: noteStyle });
             noteMeasures.set(key, m);
         }
         return m;
@@ -1682,6 +1706,11 @@ function placeDocumentPass(content, config, cache, options, hints) {
         });
         return h;
     };
+    /** Sidenotes cited on the even page of a spread, waiting for its odd
+     *  page (`spreadDeferredPage`, a page index) or the first page after it
+     *  the flow sets text on. */
+    const spreadDeferred = [];
+    let spreadDeferredPage = -1;
     /** Notes cited by blocks set outside the flow (the paragraphs of a box,
      *  inline, floated or fixed): they wait for the next text the flow
      *  places, and go to the foot of its column, in citation order. */
@@ -1691,11 +1720,47 @@ function placeDocumentPass(content, config, cache, options, hints) {
     const collectPendingNotes = () => {
         for (; notesScanned < doc.blocks.length; notesScanned++) {
             for (const id of footnoteIdsOfLines(doc.blocks[notesScanned].lines)) {
-                if (!placedNotes.has(id) && !pendingNotes.includes(id))
+                if (!placedNotes.has(id) && !pendingNotes.includes(id) && !spreadDeferred.includes(id))
                     pendingNotes.push(id);
             }
         }
     };
+    /** Whether the page at `pageIndex` opens its spread (an even book page),
+     *  so the notes it cites go to the next page. */
+    const opensSpread = (pageIndex) => spreadNotes && (pageIndex + pageIndexOffset + 1) % 2 === 0;
+    /** The sidenotes waiting for the page at `pageIndex`, if any. */
+    const deferredFor = (pageIndex) => (spreadDeferred.length > 0 && pageIndex >= spreadDeferredPage ? spreadDeferred : []);
+    /** Height `ids` take at the foot of a column of `width` with no note
+     *  yet: the separator zone, the notes and the gaps between. */
+    const freshNotesCost = (ids, width) => {
+        let h = ids.length > 0 ? noteHeadPx : 0;
+        ids.forEach((id, i) => { h += (i > 0 ? noteGapPx : 0) + noteHeight(id, width); });
+        return h;
+    };
+    /** On the even page of a spread (`pageIndex`), `col` holding the text:
+     *  which of `ids` (cited there, in order) wait for the odd page and which
+     *  stay at this column's foot. Each waits while the notes waiting with it
+     *  leave the odd page room for a line of text — measured on this column,
+     *  which the odd page's matches; a note that does not stays here, and so
+     *  do the ones after it. */
+    const splitSpreadNotes = (pageIndex, col, ids) => {
+        const already = spreadDeferredPage > pageIndex ? spreadDeferred : [];
+        const wait = [...already];
+        const here = [];
+        const room = col.bbox.height + reservedHeight(col) - bodyStyle.lineHeightPx;
+        for (const id of ids) {
+            if (here.length === 0 && freshNotesCost([...wait, id], col.bbox.width) <= room + 0.01)
+                wait.push(id);
+            else
+                here.push(id);
+        }
+        return { wait: wait.slice(already.length), here };
+    };
+    /** What the notes reserved at `col`'s foot took from it. */
+    const reservedHeight = (col) => {
+        const entry = columnNotesOf.get(col);
+        return entry ? entry.slots.reduce((h, slot) => h + slot.height, 0) : 0;
+    };
     /** `cost[k]`: the notes the first `k` of `lines` cite for the first time
      *  (after the pending ones) would add to `col`'s foot. Undefined when
      *  there are none. */
@@ -1703,35 +1768,56 @@ function placeDocumentPass(content, config, cache, options, hints) {
         if (!columnNotes)
             return undefined;
         collectPendingNotes();
+        const page = cursor.pageIndex;
+        // Sidenotes waiting for this page are set first; on the even page of a
+        // spread only the notes that stay on it cost room.
+        const waiting = deferredFor(page);
         const ids = [...pendingNotes];
-        let any = ids.length > 0;
-        const cost = [notesCost(col, ids)];
+        let any = ids.length > 0 || waiting.length > 0;
+        const even = opensSpread(page);
+        const costOf = () => notesCost(col, [...waiting, ...(even ? splitSpreadNotes(page, col, ids).here : ids)]);
+        const cost = [costOf()];
         for (const line of lines) {
             for (const seg of line.segments ?? []) {
                 const id = seg.footnoteId;
-                if (id !== undefined && !placedNotes.has(id) && !ids.includes(id)) {
+                if (id !== undefined && !placedNotes.has(id) && !ids.includes(id) && !spreadDeferred.includes(id)) {
                     ids.push(id);
                     any = true;
                 }
             }
-            cost.push(notesCost(col, ids));
+            cost.push(costOf());
         }
         return any ? cost : undefined;
     };
     /** Reserve at the placed block's column foot the pending notes and the
-     *  ones the block cites first. */
+     *  ones the block cites first (sidenotes: the ones waiting for this
+     *  page first; on the even page of a spread, only the ones that stay). */
     const reserveCitedNotes = (placed) => {
         if (!columnNotes || placed.pageIndex < 0)
             return;
         collectPendingNotes();
-        const cited = footnoteIdsOfLines(placed.lines).filter((id) => !placedNotes.has(id) && !pendingNotes.includes(id));
-        if (cited.length === 0 && pendingNotes.length === 0)
+        const waiting = deferredFor(placed.pageIndex);
+        const cited = footnoteIdsOfLines(placed.lines).filter((id) => !placedNotes.has(id) && !pendingNotes.includes(id) && !spreadDeferred.includes(id));
+        if (cited.length === 0 && pendingNotes.length === 0 && waiting.length === 0)
             return;
         const page = doc.pages[placed.pageIndex];
         const col = page?.columns[placed.columnIndex];
         if (!page || !col)
             return;
-        reserveNotes(page, col, [...pendingNotes.splice(0), ...cited], placed.contentIndex ?? 0);
+        const anchor = placed.contentIndex ?? 0;
+        if (waiting.length > 0)
+            reserveNotes(page, col, spreadDeferred.splice(0), anchor);
+        const ids = [...pendingNotes.splice(0), ...cited];
+        if (opensSpread(placed.pageIndex)) {
+            const { wait, here } = splitSpreadNotes(placed.pageIndex, col, ids);
+            spreadDeferred.push(...wait);
+            spreadDeferredPage = placed.pageIndex + 1;
+            if (here.length > 0)
+                reserveNotes(page, col, here, anchor);
+            return;
+        }
+        if (ids.length > 0)
+            reserveNotes(page, col, ids, anchor);
     };
     /** Reserve `ids` at `col`'s foot. */
     const reserveNotes = (page, col, ids, anchor) => {
@@ -1774,6 +1860,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
         if (!columnNotes)
             return;
         collectPendingNotes();
+        reserveLeftoverSidenotes();
         if (pendingNotes.length === 0)
             return;
         const page = doc.pages[cursor.pageIndex];
@@ -1781,6 +1868,27 @@ function placeDocumentPass(content, config, cache, options, hints) {
         if (page && col)
             reserveNotes(page, col, pendingNotes.splice(0), contentBlocks.length - 1);
     };
+    /** Sidenotes still waiting when the flow ends on the even page of a
+     *  spread: they stay on it (JLReq §4.2.6), at the foot of the column the
+     *  flow ended in when they fit under its text, else on a page of their
+     *  own after it. */
+    const reserveLeftoverSidenotes = () => {
+        if (spreadDeferred.length === 0)
+            return;
+        const ids = spreadDeferred.splice(0);
+        let page = doc.pages[cursor.pageIndex];
+        let col = page?.columns[cursor.columnIndex];
+        if (!page || !col)
+            return;
+        if (notesCost(col, ids) > col.availableHeight + 0.01) {
+            page = createPageWithColumns(doc.pages.length, geomResolved, contentArea, pageWidthPx, pageHeightPx, pageIndexOffset);
+            doc.pages.push(page);
+            col = page.columns[0];
+            if (!col)
+                return;
+        }
+        reserveNotes(page, col, ids, contentBlocks.length - 1);
+    };
     /** `chapterEnd`: move the run of note paragraphs that closes a column
      *  down to the column's true foot (under a band cap's cut, above any
      *  bottom float band). */
@@ -2481,6 +2589,22 @@ function placeDocumentPass(content, config, cache, options, hints) {
         });
         pendingNumberingChange = null;
     };
+    /** `headings.keepWithNextSpread` (#424): whether a heading may close
+     *  `col` even so — the last text column of an even page, whose text then
+     *  opens the facing odd page of the same spread (JLReq §4.1.7 b). Pages
+     *  count as printed (`pageIndexOffset` of a chapter laid out after
+     *  others), page 1 being the lone recto. */
+    const headingMayCloseColumn = (col) => {
+        if (!resolved.headings.keepWithNextSpread)
+            return false;
+        const page = doc.pages[cursor.pageIndex];
+        if (!page || !page.columns.includes(col))
+            return false;
+        if ((page.index + (doc.pageIndexOffset ?? 0) + 1) % 2 !== 0)
+            return false;
+        const flow = page.columns.filter((c) => c.kind !== 'side' && c.kind !== 'span');
+        return flow[flow.length - 1] === col;
+    };
     /** Heading blocks that are not part of a callout — the only ones the
      *  keep-with-next rollbacks may pull along (a callout is one unbreakable
      *  unit; its children never leave it). */
@@ -2488,7 +2612,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
     /** Free headings closing `col` (its trailing run), 0 unless keep-with-next
      *  is on: the headings a block moving on would strand. */
     const trailingHeadingRun = (col) => {
-        if (!resolved.headings.keepWithNext)
+        if (!resolved.headings.keepWithNext || headingMayCloseColumn(col))
             return 0;
         let n = 0;
         for (let j = col.blocks.length - 1; j >= 0 && isFreeHeading(col.blocks[j]); j--)
@@ -3834,6 +3958,11 @@ function placeDocumentPass(content, config, cache, options, hints) {
                 // parity padding, so a blank parity page never carries a float.
                 flushFloatsIntoPage(doc.pages[cursor.pageIndex]);
                 flushPendingNumberingAtBoundary();
+                // `:::pagebreak{center}` (ページの左右中央, #424): the text of the page
+                // the break opens is centred between the head and the foot of the
+                // type area once the pass is done (`centrePageText`).
+                if (attrs.center !== undefined && attrs.center.trim().toLowerCase() !== 'false')
+                    centredPages.add(cursor.pageIndex);
             }
             else if (name === 'columnbreak') {
                 // Explicit column break: end the current column here (its bottom
@@ -4097,7 +4226,9 @@ function placeDocumentPass(content, config, cache, options, hints) {
             ? { ...containerTail.tailStyle, marginBottomPx: blockMeasureCtx.bodyStyle.marginBottomPx }
             : containerTail?.tailStyle;
         const styleOverride = paragraphContainer
-            ? (isContainerTail ? tailStyle ?? paragraphContainer.tailStyle : paragraphContainer.style)
+            ? (paragraphContainer.overBody
+                ? containerStyle(paragraphContainer, isContainerTail, blockMeasureCtx.bodyStyle, dpi)
+                : isContainerTail ? tailStyle ?? paragraphContainer.tailStyle : paragraphContainer.style)
             : undefined;
         // Column balancing "run a paragraph long": the loose path is taken only
         // for the paragraphs the driver asked for, so the common case keeps its
@@ -4125,9 +4256,28 @@ function placeDocumentPass(content, config, cache, options, hints) {
         const upright = pageIsVertical(blockPage) && rawBlock.type === 'resourceBlock'
             ? { uprightMaxLength: uprightOn(blockPage).length }
             : {};
+        // Column balancing: an inline picture with a safe area grown by whole
+        // lines (`flexFigure`, #442).
+        const figureGrowPx = rawBlock.type === 'resourceBlock' ? balanceExtraPx?.get(flexFigureKey(blockIdx)) ?? 0 : 0;
+        const figureDelta = figureGrowPx > 0 ? { figureHeightDelta: figureGrowPx } : {};
         let measuredBlock = tryLoose
             ? measureLooseParagraph(rawBlock, blockIdx, col.bbox.width, blockMeasureCtx, styleOverride, looseLines, trackingLadder, looseOutcome)
-            : measureContentBlock(rawBlock, blockIdx, measureWidth, blockMeasureCtx, { styleOverride, ...upright });
+            : measureContentBlock(rawBlock, blockIdx, measureWidth, blockMeasureCtx, { styleOverride, ...upright, ...figureDelta });
+        // 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).
+        if (measuredBlock?.kind.vdtType === 'resource' && measuredBlock.resourceBlock?.bodyFlex) {
+            const flex = measuredBlock.resourceBlock.bodyFlex;
+            const room = col.availableHeight - (col.blocks.length === 0 ? 0 : Math.max(pendingSpacing, floatGapPx));
+            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,
+                });
+                if (cropped && cropped.measured.totalHeight <= room + 0.01)
+                    measuredBlock = cropped;
+            }
+        }
         // Screen pages (`layout.fitFiguresToPage`): an inline figure a little
         // too tall for the room left in its column — under an opener band, say
         // — is set smaller to stay with its text rather than leave the rest of
@@ -4174,7 +4324,16 @@ function placeDocumentPass(content, config, cache, options, hints) {
         // break, keep-with-next and grid snap apply — but with no line height
         // and no margins: it takes no room, and renderers skip it.
         const hiddenHeading = vdtType === 'heading' && headingIsHidden(rawBlock, headingLevels.forBlock(rawBlock));
-        const style = hiddenHeading ? { ...kind.style, lineHeightPx: 0, marginTopPx: 0, marginBottomPx: 0 } : kind.style;
+        // 行取り (#424): a heading with a `lineSpan` takes that many body grid
+        // lines, its text centred in them; the band replaces its margins. Not a
+        // heading painted as a page opener or from its own design.
+        const lineSpan = vdtType === 'heading' && !hiddenHeading && kind.style.lineSpan !== undefined
+            && !headingSetsOwnBand(headingLevels.forBlock(rawBlock))
+            ? kind.style.lineSpan
+            : undefined;
+        const style = hiddenHeading
+            ? { ...kind.style, lineHeightPx: 0, marginTopPx: 0, marginBottomPx: 0 }
+            : lineSpan !== undefined ? { ...kind.style, marginTopPx: 0, marginBottomPx: 0 } : kind.style;
         // --- Resource blocks (image / svg / table + caption) -----------------
         // Placed atomically (kept-together) — no mid-content split for v1.
         if (vdtType === 'resource') {
@@ -4208,6 +4367,11 @@ 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);
+            const grown = figureGrowPx > 0 ? resourceBlock.bodyFlex?.delta ?? 0 : 0;
+            if (grown > 0.01) {
+                blk.balancing = { levers: ['flexFigure'], spaceAbove: 0, bodyGrowth: grown };
+                addBalanceExtra(currentColumn(doc, cursor), grown);
+            }
             doc.blocks.push(blk);
             // Snap the flow position after the resource to the baseline grid (the
             // group height is arbitrary), baking in at least marginBottom — same
@@ -4433,6 +4597,12 @@ function placeDocumentPass(content, config, cache, options, hints) {
                 spacingBefore = pendingSpacing;
                 if (vdtType === 'heading' || vdtType === 'mathDisplay') {
                     spacingBefore = Math.max(partIndex === 0 ? pendingBeforeSelfSnapping(blockIdx) : spacingBefore, style.marginTopPx);
+                    // A 行取り band opens on a grid line when its heading snaps to the
+                    // grid, so its lines are body lines (#424).
+                    if (lineSpan !== undefined && partIndex === 0 && (headingLevels.forBlock(rawBlock)?.snapToGrid ?? resolved.headings.snapToGrid)) {
+                        const usedHeight = curCol.bbox.height - curCol.availableHeight;
+                        spacingBefore = Math.ceil((usedHeight + spacingBefore - 0.01) / baselineGrid) * baselineGrid - usedHeight;
+                    }
                     // Column balancing: extra whole grid lines above this heading so
                     // the column it sits in ends flush with the page bottom. Applied
                     // after margin collapsing — the heading's effective top margin
@@ -4546,6 +4716,14 @@ function placeDocumentPass(content, config, cache, options, hints) {
             // actual content bottom so the reserved block height (and the
             // subsequent marginBottom + grid snap) starts from there.
             let effectiveRemainHeight = totalRemainHeight;
+            /** How far the lines of a 行取り heading go down its band (#424). */
+            let lineSpanShift = 0;
+            if (lineSpan !== undefined && partIndex === 0) {
+                const bodyBlockStyle = blockMeasureCtx.bodyStyle;
+                const band = headingLineSpanBand(lineSpan, remainingLines.length, style.lineHeightPx, { font: style.fontString, sizePx: style.fontSizePx }, { font: bodyBlockStyle.fontString, sizePx: bodyBlockStyle.fontSizePx }, baselineGrid);
+                effectiveRemainHeight = band.height;
+                lineSpanShift = band.shift;
+            }
             /** The heading's design and the values it is laid out with, kept for
              *  the side-column obstacles once the block is placed (EF-78). */
             let headingDesign;
@@ -4806,7 +4984,8 @@ function placeDocumentPass(content, config, cache, options, hints) {
                     && resolved.headings.keepWithNext
                     && !nextIsHeading
                     && nextBlock !== null
-                    && (curCol.blocks.length > trailingHeadingRun(curCol) || shortColumn)) {
+                    && (curCol.blocks.length > trailingHeadingRun(curCol) || shortColumn)
+                    && !headingMayCloseColumn(curCol)) {
                     const wouldUsedHeight = (curCol.bbox.height - curCol.availableHeight) + spacingBefore;
                     const naturalBottom = wouldUsedHeight + effectiveRemainHeight + style.marginBottomPx;
                     const snappedBottom = shouldSnapToGrid
@@ -4879,7 +5058,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
                     blk.lines = [mathLine];
                 }
                 else {
-                    blk.lines = resetLinePositions(remainingLines, style.lineHeightPx);
+                    blk.lines = shiftLinesDown(resetLinePositions(remainingLines, style.lineHeightPx), lineSpanShift);
                 }
                 blk.dirty = false;
                 blk.snappedToGrid = shouldSnapToGrid && partIndex === 0;
@@ -5250,7 +5429,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
                 blk.titleBreaks = rawBlock.titleBreaks;
                 blk.titleLength = rawBlock.text.length;
             }
-            blk.lines = resetLinePositions(remainingLines, style.lineHeightPx);
+            blk.lines = shiftLinesDown(resetLinePositions(remainingLines, style.lineHeightPx), lineSpanShift);
             blk.dirty = false;
             blk.snappedToGrid = false;
             if (remainingLines.length > 0) {
@@ -5306,6 +5485,11 @@ function placeDocumentPass(content, config, cache, options, hints) {
         dropChapterEndNotes();
     if (chapterEndNotes)
         ruleChapterEndNotes();
+    for (const index of centredPages) {
+        const page = doc.pages[index];
+        if (page)
+            centrePageText(page, reservedOf);
+    }
     // A band that is still cut at the end of the pass (a trailing cap: the
     // closing band of a chapter or of the document) must hold what it took,
     // under the same rules as an uncut one. Two ways a cut too low breaks
@@ -5551,8 +5735,9 @@ function printedFootnoteNumbers(doc) {
  *  beyond the first, for the numbers to settle. */
 const MAX_FOOTNOTE_ROUNDS = 3;
 /**
- * {@link buildDocumentBalanced}, with `footnotes.numbering: 'page'` /
- * `'column'`: a note's number depends on the page the layout sets it on,
+ * {@link buildDocumentBalanced}, with `footnotes.numbering: 'page'`,
+ * `'column'` or `'spread'`: a note's number depends on the page the layout
+ * sets it on,
  * so the document is numbered by chapter, laid out, numbered again where
  * its notes landed, and laid out with those numbers until they no longer
  * change (as the contents' page labels are). A circled marker is the same
@@ -5562,13 +5747,16 @@ const MAX_FOOTNOTE_ROUNDS = 3;
 function* buildDocumentNumbered(content, config, cache, options, tocRound = 0) {
     let doc = yield* buildDocumentBalanced(content, config, cache, options, tocRound);
     const f = doc.config.footnotes;
-    if (f.placement !== 'column' || (f.numbering !== 'page' && f.numbering !== 'column'))
+    if ((f.placement !== 'column' && f.placement !== 'spread') || (f.numbering !== 'page' && f.numbering !== 'column' && f.numbering !== 'spread'))
         return doc;
     for (let round = 0; round < MAX_FOOTNOTE_ROUNDS; round++) {
         const used = printedFootnoteNumbers(doc);
         if (used.size === 0)
             break;
-        const placed = numberFootnotesByPlacement(doc.pages, f.numbering, documentNumeralStyle(f.numberFormat, doc.config.numerals), f.markerTemplate).numbers;
+        // A spread counts its notes in citation order: the order of the first
+        // markers, which `used` holds.
+        const order = f.numbering === 'spread' ? new Map([...used.keys()].map((id, i) => [id, i])) : undefined;
+        const placed = numberFootnotesByPlacement(doc.pages, f.numbering, documentNumeralStyle(f.numberFormat, doc.config.numerals), f.markerTemplate, doc.pageIndexOffset ?? 0, order).numbers;
         // A note the layout set nowhere keeps the number it had.
         const next = new Map(used);
         for (const [id, number] of placed)
@@ -5690,7 +5878,7 @@ function* buildDocumentBalanced(content, config, cache, options, tocRound = 0, f
             if (si < 0)
                 continue;
             for (const c of g.candidates)
-                owner.set(balanceKey(c.contentIndex, c.part ?? 0), si);
+                owner.set(candidateKey(c), si);
         }
         return owner;
     };
@@ -5804,7 +5992,7 @@ function* buildDocumentBalanced(content, config, cache, options, tocRound = 0, f
                 }
             return hit;
         };
-        const keysOf = (pick) => new Set(gaps.filter(pick).flatMap((g) => g.candidates.map((c) => balanceKey(c.contentIndex, c.part ?? 0))));
+        const keysOf = (pick) => new Set(gaps.filter(pick).flatMap((g) => g.candidates.map((c) => candidateKey(c))));
         if (blacklist(keysOf((g) => g.pageIndex === div.pageIndex && g.columnIndex === div.columnIndex)))
             return true;
         if (blacklist(keysOf((g) => g.pageIndex === div.pageIndex)))
@@ -6016,4 +6204,69 @@ function verseSnaps(styleId, resolved) {
     const key = styleId?.trim();
     return !key || resolved.paragraphStyles.find((s) => s.id === key)?.snapToGrid !== false;
 }
+/** `lines` (block-relative, as `resetLinePositions` sets them) moved `dy`
+ *  px down their block: a 行取り heading's lines in its band (#424). */
+function shiftLinesDown(lines, dy) {
+    if (dy === 0)
+        return lines;
+    for (const line of lines) {
+        line.bbox.y += dy;
+        line.baseline += dy;
+    }
+    return lines;
+}
+/** Whether a heading level sets the band it takes itself — a page opener
+ *  (`span: 'page'`) or a heading painted from its `advancedDesign` — so a
+ *  `lineSpan` (#424) does not apply to it. */
+function headingSetsOwnBand(lvl) {
+    return lvl !== undefined && (lvl.span === 'page' || lvl.advancedDesign.enabled);
+}
+/**
+ * ページの左右中央 (#424): the text on `page` centred between the head and
+ * the foot of its type area — across the page in vertical text, down it in
+ * horizontal text — as a dedication or a part title is set on a page of its
+ * own. The extent is measured from the first line box to the last one of
+ * every text column (a box or a figure by its frame), and the room taken by
+ * floats at the head or foot of a column is left out; every block of the
+ * columns moves by the same amount, so columns and the text in them keep
+ * their places relative to each other. Floats, notes and running heads stay
+ * where they are. A page whose text already fills the area is left alone.
+ */
+function centrePageText(page, reservedOf) {
+    const cols = page.columns.filter((c) => c.kind !== 'side' && c.blocks.length > 0);
+    if (cols.length === 0)
+        return;
+    let top = Infinity;
+    let bottom = -Infinity;
+    let areaTop = Infinity;
+    let areaBottom = -Infinity;
+    for (const col of cols) {
+        const reserved = reservedOf(col);
+        areaTop = Math.min(areaTop, col.bbox.y + reserved.top);
+        areaBottom = Math.max(areaBottom, col.bbox.y + col.bbox.height - reserved.bottom);
+        for (const b of col.blocks) {
+            if (b.hidden)
+                continue;
+            const first = b.lines[0];
+            const last = b.lines[b.lines.length - 1];
+            const textual = first !== undefined && last !== undefined && b.type !== 'resource' && b.containerId === undefined;
+            top = Math.min(top, textual ? first.bbox.y : b.bbox.y);
+            bottom = Math.max(bottom, textual ? last.bbox.y + last.bbox.height : b.bbox.y + b.bbox.height);
+        }
+    }
+    if (!Number.isFinite(top) || !Number.isFinite(bottom))
+        return;
+    const dy = (areaTop + areaBottom) / 2 - (top + bottom) / 2;
+    if (dy < 0.5)
+        return;
+    const moved = new Set();
+    for (const col of cols) {
+        for (const b of col.blocks) {
+            if (moved.has(b))
+                continue;
+            moved.add(b);
+            offsetBlock(b, 0, dy);
+        }
+    }
+}
 //# sourceMappingURL=build.js.map