postext 1.35.1 → 1.37.0

package/dist/pipeline/build.js

@@ -3,6 +3,8 @@ import { plainTitleBreaks } from '../parse/inlineFormatting';
 import { dimensionToPx } from '../units';
 import { createVDTDocument, createVDTBlock, createBoundingBox, createVDTColumn, pageIsMirrored, pageIsVertical, flowRectToPage, } from '../vdt';
 import { figureLabels } from './buildMeasurement';
+import { contourOnPage } from '../contour';
+import { figureLabelWarnings, layOutFigureLabels, stampFigureLabelRects } from '../composed/labels';
 import { anchorBox } from '../design/layout';
 import { parseMarkdownMemo, spaceDirectiveLines } from '../parse';
 import { buildPageLabels, computeHeadingNumbering, parseNumberFormat, } from '../numbering';
@@ -38,7 +40,11 @@ import { flowColumnsStyles, isFlowColumnsStyle, wrapFlowColumns } from './flowCo
 import { FRAME_STYLE_ID, frameBoxStyle, wrapComposedPages } from '../composed/wrap';
 import { resolvePageTemplate } from '../composed/templates';
 import { layoutComposedSpread } from '../composed/spread';
+import { assignReceivers, continuationTarget, MAX_CONTINUATION_PAGES } from '../composed/continuation';
+import { frameElementId } from '../composed/ids';
+import { nextFrameOf } from '../composed/geometry';
 import { composedPageAt, frameStyleOf, layoutComposedPage, planComposedPages } from './composedLayout';
+import { configKeyOf, layoutComposedPageMemo } from '../composed/pageMemo';
 import { anchorOutline, computeOutline, hasIndexDirective, hasTocDirective, headingNumberingOptions, headingTemplatesOf, outlineFromDoc, sameOutline } from './outline';
 import { expandTocDirectives } from './toc';
 import { expandIndexDirectives, locateIndexMarks } from './indexDirective';
@@ -73,7 +79,7 @@ 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, bandLinePitch, capRetryLimit, } from './bandCaps';
 import { raggedLooseLines } from './raggedLines';
-import { cjkLooseLineWarnings, raggedLineWarnings, collectContentWarnings, designTruncationWarnings, dropCapWarnings, floatShrinkWarnings, joiningLetterSpacingWarnings, locateContentWarnings, wordOverflowWarnings } from './contentWarnings';
+import { cjkLooseLineWarnings, raggedLineWarnings, collectContentWarnings, designTruncationWarnings, dropCapWarnings, floatShrinkWarnings, joiningLetterSpacingWarnings, pictureBelowPrintSizeWarnings, locateContentWarnings, wordOverflowWarnings } from './contentWarnings';
 import { dropCapSinkAfter } from './dropCap';
 import { mostlyJoiningScript } from '../measure/joining';
 import { composesAsCjk } from '../measure/cjkCompose';
@@ -277,6 +283,8 @@ function placeDocumentPass(content, config, cache, options, hints) {
     // their own `resolution` from here on (#631); under the default policy
     // the content is untouched.
     const stampedResources = content.resources && withBitmapResolutions(content.resources, resolved.layout.bitmapResolution);
+    /** The resources as given: whose print size is the author's (#901). */
+    const givenResources = content.resources;
     if (stampedResources && stampedResources !== content.resources)
         content = { ...content, resources: stampedResources };
     // Tracking rungs a loose paragraph may climb: none, then 5‰ steps up to
@@ -532,9 +540,9 @@ function placeDocumentPass(content, config, cache, options, hints) {
     // floats is laid out by its id alone.
     const figureLabelsById = new Map();
     for (const b of contentBlocks) {
-        const labels = b.resourceId !== undefined && !figureLabelsById.has(b.resourceId) ? figureLabels(b) : undefined;
+        const labels = b.resourceId !== undefined && !figureLabelsById.has(b.resourceId) ? figureLabels(b, bodyOffset) : undefined;
         if (labels)
-            figureLabelsById.set(b.resourceId, labels);
+            figureLabelsById.set(b.resourceId, { labels, parsed: b.figure.labels });
     }
     // Resolve styles
     const bodyStyle = resolveBodyStyle(resolved);
@@ -1255,7 +1263,11 @@ function placeDocumentPass(content, config, cache, options, hints) {
         const { block: rb, totalHeight } = laid;
         const id = slice && slice.startRow > 0 ? `float-${resourceId}-cont-${slice.startRow}` : `float-${resourceId}`;
         const blk = createVDTBlock(id, 'resource', bodyStyle.fontString, bodyStyle.color, bodyStyle.textAlign);
-        const labels = figureLabelsById.get(resourceId);
+        // A floated figure's labels, laid out on its picture as set (#860).
+        const figure = figureLabelsById.get(resourceId);
+        const labels = figure
+            ? layOutFigureLabels(figure.labels, figure.parsed, rb, { resolved, resourceNumbering, resourceTypes, resources, ...(cache ? { cache } : {}) })
+            : undefined;
         blk.resourceBlock = labels ? { ...rb, labels } : rb;
         blk.dirty = false;
         blk.snappedToGrid = false;
@@ -1302,6 +1314,29 @@ function placeDocumentPass(content, config, cache, options, hints) {
     };
     /** The `textWrap` warnings of this pass (#627). */
     const textWrapNotes = [];
+    /** Resources whose contour wrap fell back to the box this pass (#883):
+     *  said once each. */
+    const contourFallbacks = new Set();
+    /** The shape a contour wrap (#883) of `resource`, set as `rb` in the
+     *  figure `box`, runs round on `page`: its polygon or traced alpha
+     *  channel through the picture's crop and scale, the contour's margin
+     *  round it (else the wrap's gap), its insets in whole body characters
+     *  under a CJK grid; `rb.bodyRect` is relative to `origin`, `box` is in
+     *  page px. `undefined` (and a `noContour` note) when the shape is not
+     *  known: the text runs round the box. */
+    const wrapContourOf = (resource, rb, box, gapPx, page, origin, source) => {
+        const own = resource.contour?.margin;
+        const margin = own ? Math.max(0, dimensionToPx(own, dpi, bodyStyle.fontSizePx)) : gapPx;
+        const quantum = resolved.cjk.grid.enabled && bodyStyle.fontSizePx > 0 ? bodyStyle.fontSizePx : undefined;
+        const c = contourOnPage(resource, rb, box, { margin, mirrored: pageIsMirrored(page), originX: origin.x, originY: origin.y, ...(quantum ? { quantum } : {}) });
+        if (c)
+            return c;
+        if (!contourFallbacks.has(resource.id)) {
+            contourFallbacks.add(resource.id);
+            textWrapNotes.push({ kind: 'textWrap', reason: 'noContour', resourceId: resource.id, ...(source ?? {}), pageIndex: page.index });
+        }
+        return undefined;
+    };
     const floatWraps = new Map();
     /** Give the bands of the wrapped floats of `col` back to the flow, as
      *  exclusions the text runs beside: a float at the head of a column the
@@ -1944,6 +1979,15 @@ function placeDocumentPass(content, config, cache, options, hints) {
                     gap: exWidth - width,
                     ownerId: built.block.id,
                 };
+                // A contour wrap (#883): the picture's shape where its block is
+                // set (`commitFloatBlock` puts it at `xLeft`, `y`).
+                const fRes = f.contour ? resourceById.get(f.resourceId) : undefined;
+                const fRb = built.block.resourceBlock;
+                if (fRes && fRb) {
+                    const c = wrapContourOf(fRes, fRb, { x: xLeft, y, width, height: built.height }, wrapGap, page, { x: xLeft, y });
+                    if (c)
+                        ex.contour = c;
+                }
                 if (underOpener) {
                     // The band was taken from the flow: the text placed next takes
                     // it back and runs beside the float, as it does beside an inline
@@ -3075,7 +3119,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
             blk.direction = raw.direction;
         const tocContinued = raw.toc?.group?.role === 'continuation' ? { continued: true } : {};
         if (raw.toc?.kind === 'entry') {
-            blk.tocEntry = { ...(raw.toc.pageIndex !== undefined ? { pageIndex: raw.toc.pageIndex } : {}), ...tocContinued };
+            blk.tocEntry = { ...(raw.toc.pageIndex !== undefined ? { pageIndex: raw.toc.pageIndex } : {}), ...(raw.toc.headingSource !== undefined ? { headingSource: raw.toc.headingSource } : {}), ...tocContinued };
         }
         if (raw.toc?.kind === 'part') {
             blk.tocPart = {
@@ -3966,6 +4010,18 @@ function placeDocumentPass(content, config, cache, options, hints) {
         withStripPlaceholder(blk, stripGeometry(idx, raw.comic, width, contentArea.height - 2 * floatGapPx, pageIsVertical(doc.pages[cursor.pageIndex])));
         return blk;
     };
+    /** The room a heading's design takes in a box or a frame (#906): as in
+     *  a column (see the heading placement below), against the heading's
+     *  box; a `span: 'page'` heading is laid out at the box's width too. */
+    const boxHeadingDesign = (raw, blockIdx, lines, pref, headingNumber, width) => {
+        const lvl = headingLevels.forBlock(raw);
+        if (!lvl?.advancedDesign.enabled)
+            return undefined;
+        const { titleText, marked } = defaultOpenerTitle(lines, pref, raw.titleBreaks, raw.text.length, lvl.numberSeparator);
+        const info = { titleText, ...(marked !== undefined ? { titleMarked: marked } : {}), formattedNumber: pref, numericValue: headingNumber, locale: resolvedLocale(resolved), ...(resolved.numerals ? { numerals: resolved.numerals } : {}), chapterNumber: chapterNumberByBlock[blockIdx] ?? '', attrs: raw.attrs };
+        const design = measureHeadingDesign(lvl, info, width, resolved.page.dpi, doc.metadata, cursor.pageIndex, undefined, undefined, resourceById);
+        return Math.max(design.height, design.textFloor);
+    };
     /** What the box typesetter (`frameLayout.ts`) reads of this pass. */
     const framePass = {
         contentBlocks,
@@ -3979,6 +4035,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
             : measureCtx),
         stripBlock: calloutStripBlock,
         columnHeight: () => contentArea.height,
+        headingDesign: (raw, blockIdx, heading, width) => boxHeadingDesign(raw, blockIdx, heading.lines, heading.numberPrefix, heading.headingNumber, width),
     };
     const makeCalloutLayouter = (startIdx, plan, style) => makeCalloutLayouterIn(framePass, startIdx, plan, style);
     /** Whether a page swaps its mirrored margins (a verso of a left-bound
@@ -5853,6 +5910,51 @@ function placeDocumentPass(content, config, cache, options, hints) {
     const composedLaid = new Set();
     /** The composed pages' layout warnings (`frameOverflow`). */
     const composedNotes = [];
+    /** What the composed pages' memo (#857) reads of this pass: the
+     *  numbers, part, section and pictures the blocks of a page are set
+     *  with, and the notes a page's layout leaves. */
+    const composedMemo = {
+        markdown: markdownBody,
+        bodyOffset,
+        configKey: () => configKeyOf(calloutResolved),
+        contextKey: (from, to) => {
+            const ids = new Set();
+            for (let i = from; i <= to; i++) {
+                const b = contentBlocks[i];
+                if (b.resourceId)
+                    ids.add(b.resourceId);
+            }
+            const pictures = [...ids].sort().map((id) => {
+                const r = resourceById.get(id);
+                return [id, r ?? null, r ? resourceTypeById.get(r.typeId) ?? null : null, resourceNumberById.get(id) ?? null, floatedIds.has(id), captionCitations?.get(id) ?? null];
+            });
+            const parts = [];
+            const sections = [];
+            const out = [];
+            for (let i = from; i <= to; i++) {
+                const part = partPlan.byBlock[i];
+                parts.push(part ? [part.number, part.title, part.palette] : 0);
+                sections.push(sectionPlan.byBlock[i]?.id ?? 0);
+                if (calloutsOutOfFlow.has(i))
+                    out.push(i - from);
+            }
+            return JSON.stringify([
+                headingPrefixes.slice(from, to + 1),
+                headingNumbers.slice(from, to + 1),
+                parts,
+                sections,
+                out,
+                paragraphContainers.byBlock.slice(from, to + 1).map((c) => (c ? c.style : 0)),
+                pictures,
+            ]);
+        },
+        sideEffectsIn: (from, to) => {
+            for (let i = from; i <= to; i++)
+                if (dropCapNotes.has(i) || joiningLetterSpacing.has(i))
+                    return true;
+            return false;
+        },
+    };
     /** Set the composed page `planned` on a fresh page (#855), or a spread
      *  template on the two facing pages from the next verso (#861). */
     const placeComposedPage = (planned, fence) => {
@@ -5861,7 +5963,11 @@ function placeDocumentPass(content, config, cache, options, hints) {
         leaveCurrentPage();
         cursor.columnIndex = 0;
         const frameless = calloutStyles.find((st) => st.id === FRAME_STYLE_ID);
-        const common = (page) => ({
+        /** What every composed page or spread reads; `current` names the
+         *  template laid, so a `useTemplate` proposal (#858) tries the book's
+         *  other templates of the same kind (single pages for this side, or
+         *  spreads). */
+        const common = (page, current) => ({
             pass: framePass,
             fence,
             startIdx: planned.startIdx,
@@ -5873,13 +5979,21 @@ function placeDocumentPass(content, config, cache, options, hints) {
             bodyOffset,
             mirrored: mirroredOf(page),
             pushGapPx: wrapGapPx(resolved.layout.wrap?.gap, dpi, bodyStyle.fontSizePx, floatGapPx),
+            locale: resolvedLocale(resolved),
+            // The book's other templates, for a `useTemplate` proposal (#858).
+            alternatives: () => [...new Set((resolved.pageTemplates ?? []).map((t) => t?.id))].flatMap((id) => {
+                if (typeof id !== 'string' || id === current.id)
+                    return [];
+                const alt = resolvePageTemplate(templateSource, id, current.spread ? { spread: true } : { parity: current.parity });
+                return alt && alt.spread === current.spread ? [alt] : [];
+            }),
         });
         const placed = [];
         let laid;
-        const sheet = resolvePageTemplate(templateSource, fence.template, { spread: true });
-        if (sheet?.spread) {
-            // A spread opens on a verso, a parity blank before it when needed,
-            // as a comic spread does; the recto after it takes the other half.
+        /** Lay a spread template over the next verso and the recto after it
+         *  (`breakToEvenPage` opens the verso, a parity blank before it when
+         *  needed, as a comic spread does). */
+        const laySpread = (sheet, extra) => {
             breakToEvenPage();
             const verso = doc.pages[cursor.pageIndex];
             verso.columns = [createVDTColumn(0, verso.contentArea)];
@@ -5897,7 +6011,8 @@ function placeDocumentPass(content, config, cache, options, hints) {
             const left = versoIsLeft ? verso : recto;
             const right = versoIsLeft ? recto : verso;
             const out = layoutComposedSpread({
-                ...common(flowMirrored ? right : left),
+                ...common(flowMirrored ? right : left, { id: sheet.id, spread: true }),
+                ...extra,
                 template: sheet,
                 first: flowMirrored ? right : left,
                 second: flowMirrored ? left : right,
@@ -5905,34 +6020,169 @@ function placeDocumentPass(content, config, cache, options, hints) {
                 trim: pageMetrics.physical.trimBox,
                 bleed: pageMetrics.physical.bleedBox,
             });
+            return { sides: out.sides, warnings: out.warnings, laid: out.laid, continuations: out.continuations };
+        };
+        /** The template `id` for the current page's side, and the boxes its
+         *  `area` reads. */
+        const singleOn = (page, id) => {
+            page.columns = [createVDTColumn(0, page.contentArea)];
+            // The physical side: a recto has an odd folio (in either binding).
+            const parity = (page.index + pageIndexOffset) % 2 === 0 ? 'recto' : 'verso';
+            const template = resolvePageTemplate(templateSource, id, { parity });
+            const frames = designFramesOn(page);
+            const area = template.area === 'trim' ? frames.page : template.area === 'bleed' ? frames.bleed : page.contentArea;
+            return { parity, template, areas: { area, page: frames.page, bleed: frames.bleed } };
+        };
+        let continuations;
+        const sheet = resolvePageTemplate(templateSource, fence.template, { spread: true });
+        if (sheet?.spread) {
+            const out = laySpread(sheet, {});
             placed.push(...out.sides);
             composedNotes.push(...out.warnings);
             laid = out.laid;
+            continuations = out.continuations;
         }
         else {
             const page = doc.pages[cursor.pageIndex];
-            page.columns = [createVDTColumn(0, page.contentArea)];
-            // The physical side: a recto has an odd folio (in either binding).
-            const parity = (page.index + pageIndexOffset) % 2 === 0 ? 'recto' : 'verso';
-            const template = resolvePageTemplate(templateSource, fence.template, { parity });
-            const frames = designFramesOn(page);
-            const area = template.area === 'trim' ? frames.page : template.area === 'bleed' ? frames.bleed : page.contentArea;
-            const out = layoutComposedPage({
-                ...common(page),
+            const { parity, template, areas } = singleOn(page, fence.template);
+            // Kept by what it reads (#857): a page met again is not set again.
+            // A spread is laid out afresh each time (its two sides are one sheet).
+            const out = layoutComposedPageMemo({
+                ...common(page, { id: template.id, spread: false, parity }),
                 page,
                 template,
-                areas: { area, page: frames.page, bleed: frames.bleed },
-            });
+                areas,
+            }, composedMemo);
             placed.push({ page, composed: out.composed, blocks: out.blocks });
             composedNotes.push(...out.warnings);
             laid = out.laid;
+            continuations = out.continuations;
         }
-        for (const { page, composed, blocks } of placed) {
-            page.composed = composed;
-            const floats = (page.floats ??= []);
-            for (const b of blocks) {
-                floats.push(b);
-                doc.blocks.push(b);
+        const commit = (list) => {
+            for (const { page, composed, blocks } of list) {
+                page.composed = composed;
+                const floats = (page.floats ??= []);
+                for (const b of blocks) {
+                    floats.push(b);
+                    doc.blocks.push(b);
+                }
+            }
+        };
+        commit(placed);
+        // Content that goes on on pages added after this one (#859): one page
+        // (or spread) per template it goes on to, generation after generation,
+        // each laid afresh after the pages before it. The added pages are
+        // ordinary pages (numbered, with running heads, sides kept).
+        const frameAt = new Map();
+        const indexFrames = (list) => {
+            for (const s of list)
+                for (const f of s.composed.frames)
+                    if (!f.facingBlocks)
+                        frameAt.set(f.id, { page: s.page, frame: f });
+        };
+        indexFrames(placed);
+        const overflowTemplateOf = (id) => resolvePageTemplate(templateSource, id)?.overflowTemplate;
+        const firstPage = placed[0]?.page.index ?? cursor.pageIndex;
+        let pending = continuations ?? [];
+        for (let generation = 1; pending.length > 0; generation++) {
+            const last = generation >= MAX_CONTINUATION_PAGES;
+            let queue = pending;
+            pending = [];
+            while (queue.length > 0) {
+                const target = continuationTarget(queue[0], overflowTemplateOf);
+                const same = (c) => {
+                    const t = continuationTarget(c, overflowTemplateOf);
+                    return t.template === target.template && t.collapse === target.collapse;
+                };
+                const batch = queue.filter(same);
+                queue = queue.filter((c) => !same(c));
+                const spreadSheetT = resolvePageTemplate(templateSource, target.template, { spread: true });
+                // A template with no frames takes nothing.
+                if (!spreadSheetT || spreadSheetT.frames.length === 0)
+                    continue;
+                // A fresh page after the last one laid.
+                const start = cursor.pageIndex;
+                do {
+                    advanceToNextColumn(doc, cursor, geomResolved, contentArea, pageWidthPx, pageHeightPx);
+                } while (cursor.pageIndex === start);
+                cursor.columnIndex = 0;
+                const storiesOf = (receivers) => new Map([...receivers].map(([name, c]) => [name, c.story]));
+                let sides;
+                let notes;
+                let more;
+                let receivers;
+                let laidTemplate;
+                if (spreadSheetT.spread) {
+                    const assigned = assignReceivers(spreadSheetT, batch);
+                    receivers = assigned.receivers;
+                    queue = [...assigned.left, ...queue];
+                    laidTemplate = spreadSheetT;
+                    const out = laySpread(spreadSheetT, { stories: storiesOf(receivers), continuing: { receivers, generation, collapse: target.collapse, last } });
+                    sides = out.sides;
+                    notes = out.warnings;
+                    more = out.continuations;
+                }
+                else {
+                    const page = doc.pages[cursor.pageIndex];
+                    const { parity, template, areas } = singleOn(page, target.template);
+                    const assigned = assignReceivers(template, batch);
+                    receivers = assigned.receivers;
+                    queue = [...assigned.left, ...queue];
+                    laidTemplate = template;
+                    const out = layoutComposedPage({
+                        ...common(page, { id: template.id, spread: false, parity }),
+                        page,
+                        template,
+                        areas,
+                        stories: storiesOf(receivers),
+                        continuing: { receivers, generation, collapse: target.collapse, last },
+                    });
+                    sides = [{ page, composed: out.composed, blocks: out.blocks }];
+                    notes = out.warnings;
+                    more = out.continuations;
+                }
+                for (const s of sides)
+                    s.composed.continuationOf = firstPage;
+                // On the last page allowed, a frame whose content would still go on
+                // says so (it is cut at its foot).
+                if (last) {
+                    const chained = new Set();
+                    const nextOf = (n) => {
+                        const f = laidTemplate.frames.find((x) => x.name === n);
+                        return f ? nextFrameOf(f) : undefined;
+                    };
+                    for (const name of receivers.keys()) {
+                        for (let n = name; n !== undefined && !chained.has(n); n = nextOf(n))
+                            chained.add(n);
+                    }
+                    notes = notes.map((w) => (w.kind === 'frameOverflow' && chained.has(w.frame)
+                        ? { kind: 'frameContinuationLimit', template: w.template, frame: w.frame, fenceIndex: w.fenceIndex, pages: generation, overflowMm: w.overflowMm, configPath: w.configPath, ...(w.sourceStart !== undefined ? { sourceStart: w.sourceStart, sourceEnd: w.sourceEnd } : {}), ...(w.pageIndex !== undefined ? { pageIndex: w.pageIndex } : {}) }
+                        : w));
+                }
+                commit(sides);
+                indexFrames(sides);
+                composedNotes.push(...notes);
+                // Each frame that sent content on points to the frame that took it,
+                // and its page's log says where it went.
+                for (const c of receivers.values()) {
+                    const to = frameElementId(fence.fenceIndex, c.slot, generation);
+                    const src = frameAt.get(c.fromFrameId);
+                    const dst = frameAt.get(to);
+                    if (!src || !dst)
+                        continue;
+                    src.frame.continuesTo = to;
+                    const log = src.page.composed.log;
+                    let at = log.length;
+                    for (let i = log.length - 1; i >= 0; i--) {
+                        if (log[i].frame === c.frame) {
+                            at = i + 1;
+                            break;
+                        }
+                    }
+                    log.splice(at, 0, { frame: c.frame, kind: 'continued', toPage: dst.page.index, toFrame: to });
+                }
+                if (more)
+                    pending.push(...more);
             }
         }
         for (const [head, story] of planned.stories) {
@@ -6669,6 +6919,12 @@ function placeDocumentPass(content, config, cache, options, hints) {
                     pendingSpacing = 0;
                     inlineGapOwed = null;
                     const exWidth = wrapExclusionWidth(rCol.bbox.width, rCol.bbox.width * wrapSpec.width, wrapGap);
+                    // A contour wrap (#883): the picture's shape where it was set.
+                    const slotWidth = rCol.bbox.width * wrapSpec.width;
+                    const slot = { x: wrapSpec.side === 'left' ? rCol.bbox.x : rCol.bbox.x + rCol.bbox.width - slotWidth, y: top, width: slotWidth, height: groupHeight };
+                    const contour = wrapSpec.contour
+                        ? wrapContourOf(kind.resource, resourceBlock, slot, wrapGap, doc.pages[cursor.pageIndex], { x: blk.bbox.x, y: blk.bbox.y }, { sourceStart: rawBlock.sourceStart + bodyOffset, sourceEnd: rawBlock.sourceEnd + bodyOffset })
+                        : undefined;
                     pendingWrap = {
                         col: rCol,
                         blocks: rCol.blocks.length,
@@ -6681,6 +6937,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
                             side: wrapSpec.side,
                             gap: exWidth - rCol.bbox.width * wrapSpec.width,
                             ownerId: blk.id,
+                            ...(contour ? { contour } : {}),
                         },
                     };
                     flushPendingNumberingAtBoundary();
@@ -8212,6 +8469,8 @@ function placeDocumentPass(content, config, cache, options, hints) {
     // reverse of their visual order.
     if (doc.pages.some((p) => pageIsMirrored(p)))
         orientLinesToFrames(doc);
+    // Figure labels (#860): where each one is painted, for the source map.
+    stampFigureLabelRects(doc);
     doc.converged = true;
     doc.iterationCount = 1;
     if (joiningLetterSpacing.size > 0)
@@ -8223,8 +8482,13 @@ function placeDocumentPass(content, config, cache, options, hints) {
         const b = contentBlocks[idx];
         return b ? { start: b.sourceStart + bodyOffset, end: b.sourceEnd + bodyOffset } : undefined;
     });
-    if (shrunk.length > 0)
-        floatShrinkWarningsByDoc.set(doc, shrunk);
+    // Pictures whose column holds them under half their print size (#901).
+    const belowPrint = pictureBelowPrintSizeWarnings(doc, givenResources, (idx) => {
+        const b = contentBlocks[idx];
+        return b ? { start: b.sourceStart + bodyOffset, end: b.sourceEnd + bodyOffset } : undefined;
+    });
+    if (shrunk.length > 0 || belowPrint.length > 0)
+        floatShrinkWarningsByDoc.set(doc, [...shrunk, ...belowPrint]);
     if (textWrapNotes.length > 0 || columnsNotes.length > 0)
         textWrapWarningsByDoc.set(doc, [...textWrapNotes, ...columnsNotes]);
     // Composed pages (#855): frames whose content does not fit.
@@ -8310,6 +8574,9 @@ export function* buildDocumentGen(content, config, cache, options) {
     loose.push(...afterTextWarnings(doc), ...(unplacedByDoc.get(doc) ?? []));
     // Design texts cut to fit their width (#628).
     loose.push(...designTruncationWarnings(doc));
+    // Figure labels at anchors their picture lacks, anchors left without a
+    // word in this locale (#860).
+    loose.push(...figureLabelWarnings(doc, (b) => (b.sourceStart !== undefined && b.sourceEnd !== undefined ? { start: b.sourceStart, end: b.sourceEnd } : undefined)));
     // Comic panels whose cell cannot hold their picture's safe area (#556).
     for (const page of doc.pages) {
         if (page.comic)
@@ -8360,7 +8627,8 @@ const indexWarnings = new WeakMap();
 const joiningSpacingWarnings = new WeakMap();
 /** The `dropCap` warnings of the last pass, per document (#623). */
 const dropCapWarningsByDoc = new WeakMap();
-/** The `floatShrunk` warnings of a build (#626), found by its last pass. */
+/** The `floatShrunk` (#626) and `pictureBelowPrintSize` (#901) warnings
+ *  of a build, found by its last pass. */
 const floatShrinkWarningsByDoc = new WeakMap();
 /** The `textWrap` warnings of a build (#627) and its `columnsTooNarrow`
  *  ones (#634), found by its last pass. */