postext 1.22.3 → 1.24.0

package/dist/pipeline/build.js

@@ -1,3 +1,4 @@
+import { withBitmapResolutions } from '../bitmapResolution';
 import { plainTitleBreaks } from '../parse/inlineFormatting';
 import { dimensionToPx } from '../units';
 import { createVDTDocument, createVDTBlock, createBoundingBox, createVDTColumn, pageIsMirrored, pageIsVertical, flowRectToPage, } from '../vdt';
@@ -13,6 +14,7 @@ import { getMeasureRegion, getMeasureUprightDigits, getMeasureWritingMode, setMe
 import { stampCentralBaselines } from './verticalMetrics';
 import { orientLinesToFrames } from './mirrorFrame';
 import { verseMarginTopPx } from './buildBlockKind';
+import { verseLinesSettings, versesLineByLine } from './verseLines';
 import { resolveAllConfig, computeBaselineGrid, resolvedDirection, resolvedLocale } from './config';
 import { asciiDigits } from '../arabicNumerals';
 import { getMeasureDirection, setMeasureDirection, shiftLineX } from '../measure/bidiLines';
@@ -41,26 +43,34 @@ import { planParts, derivePartMeasureContext } from './parts';
 import { layoutCallout, offsetBlock, offsetCalloutToAbsolute, pickCalloutStyle, planCallouts, resolveCalloutAttrs, } from './calloutLayout';
 import { layoutCaptionText, layoutResourceBlock, planTableSlice } from './resourceLayout';
 import { computeFloatPlan, floatedResourceIds, floatColumnCount, } from './floatPlacement';
-import { enumerateCurrentPageSlots, measureFloatBand, floatGapAbove, measureSideStack, clearSideObstacles, columnHasFloatBand, fitsStrict, trueBottom, } from './floatSlots';
+import { enumerateCurrentPageSlots, measureFloatBand, floatGapAbove, floatGapBelow, measureSideStack, clearSideObstacles, columnHasFloatBand, fitsStrict, trueBottom, } from './floatSlots';
 import { computeHeadingContext, computeResourceNumberingState, } from './resourceNumbering';
 import { documentLocale, effectiveResourceTypes } from '../defaults/resourceTypes';
 import { resolveCalloutStylesConfig } from '../defaults/calloutStyles';
+import { codeBoxStyle, codeParseOptions, wrapCodeBlocks } from './codeBlocks';
+import { buildCodeLineNumbers, codeOverflowWarnings } from './codeLines';
 import { pickTableStyle } from '../defaults/tableStyle';
+import { DEFAULT_FLOAT_MIN_SCALE } from '../defaults/layout';
+import { buildLineNumbers, lineNumberWarnings } from './lineNumbers';
 import { buildHeadersAndFooters, defaultOpenerTitle, headingDesignBoxes, 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, 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';
+import { cjkLooseLineWarnings, collectContentWarnings, designTruncationWarnings, dropCapWarnings, floatShrinkWarnings, joiningLetterSpacingWarnings, locateContentWarnings, wordOverflowWarnings } from './contentWarnings';
+import { dropCapSinkAfter } from './dropCap';
 import { mostlyJoiningScript } from '../measure/joining';
 import { annotateDocument } from '../cjkMarks';
 import { annotateArabicMarks } from '../arabicMarks';
+import { literalBreaksFor } from './hardBreaks';
 import { tashkilFor } from './tashkil';
 import { overlineEmphasis } from '../emphasisOverline';
 import { withBookTitleBrackets } from './annotations';
 import { paperByBlock, stampPagePaper } from './paper';
 import { headingLineSpanBand } from './lineSpan';
+import { columnCursorY, insetsBefore, minTextWidthPx, openColumnWrap, resolveCalloutWrap, resolveResourceWrap, runsBesideWrap, sameInsetsFrom, settleColumnWraps, transparentToWrap, wrapGapPx, wrapInsetSteps } from './textWrap';
+import { lineInsetsAt } from '../measure/types';
 /** 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;
@@ -142,6 +152,12 @@ function measureLooseParagraph(rawBlock, blockIdx, columnWidth, ctx, styleOverri
     const base = measureContentBlock(rawBlock, blockIdx, columnWidth, ctx, { styleOverride });
     if (!base)
         return null;
+    // A paragraph with a tab at a stop (#622) is set line by line, as
+    // measured: neither looseness nor tracking moves its stops' text.
+    if (base.measured.lines.some((l) => l.tabbed)) {
+        looseOutcome.set(blockIdx, null);
+        return base;
+    }
     const target = base.measured.lines.length + extraLines;
     // The breaker's optimum, before any runt fix (a looseness of 0 skips it).
     const optimum = measureContentBlock(rawBlock, blockIdx, columnWidth, ctx, { styleOverride, looseness: 0 });
@@ -213,6 +229,12 @@ function placeDocumentPass(content, config, cache, options, hints) {
      *  shortened it, so what does not fit it may still fit a full column. */
     const shortSideColumn = (page, col) => col.bbox.height < page.contentArea.height - 0.5;
     const resolved = resolveAllConfig(config);
+    // Bitmaps sized by the document's `layout.bitmapResolution` carry it as
+    // 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);
+    if (stampedResources && stampedResources !== content.resources)
+        content = { ...content, resources: stampedResources };
     // Tracking rungs a loose paragraph may climb: none, then 5‰ steps up to
     // the cap (`headings.balancing.maxTracking`, thousandths of an em), the
     // cap itself always included. Only the smallest rung that gains the line
@@ -320,7 +342,11 @@ function placeDocumentPass(content, config, cache, options, hints) {
     // bibliography takes `:::bibliography`'s place or follows the text.
     // Arabic vowel marks out of the text when `bodyText.tashkil` says so
     // (#376), for the outline and the layout alike.
-    const parsedBody = numberTitlesFor(headingMarksFor(tashkilFor(parseMarkdownMemo(markdownBody), resolved.bodyText.tashkil), resolved), resolved);
+    // A configuration stored before #620 prints the backslashes of forced
+    // line breaks (`bodyText.hardLineBreaks: false`).
+    // Code fences (#624) as `codeStyle` reads them: a configuration stored
+    // before #624 reads their lines as Markdown (`codeStyle.blocks: false`).
+    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);
     const citationsApplied = citationContext
@@ -375,7 +401,10 @@ function placeDocumentPass(content, config, cache, options, hints) {
     // page where it stands (#535): each goes in a frameless page-span box,
     // set by the span-block path like any other.
     const spanEmbeds = wrapPageSpanEmbeds(numberedBlocks, content.resources ?? [], effectiveResourceTypes(config, content.resources ?? []));
-    const contentBlocks = spanEmbeds.blocks;
+    // Code listings (#624): each in a box of the code style, which the
+    // callout machinery places and splits.
+    const codeBoxes = wrapCodeBlocks(spanEmbeds.blocks, resolved);
+    const contentBlocks = codeBoxes.blocks;
     if (indexExpanded.warnings.length > 0)
         indexWarnings.set(doc, indexExpanded.warnings);
     const isNumbered = (b) => headingIsNumbered(b, resolved);
@@ -412,9 +441,17 @@ function placeDocumentPass(content, config, cache, options, hints) {
     // The callout styles, with the frameless box of the page-span embeds
     // when there are any: the float gap (a line) above and below it, as an
     // inline resource keeps in a column.
-    const calloutStyles = spanEmbeds.wrapped
-        ? [...resolved.calloutStyles, ...resolveCalloutStylesConfig([spanEmbedStyle(bodyStyle.lineHeightPx, resolved.layout.inlineResourceGap !== 'above')], resolved.bodyText, resolved.headings, resolved.unorderedLists, config?.locale)]
+    // The listings' box (#624) likewise.
+    const syntheticBoxes = [
+        ...(spanEmbeds.wrapped ? [spanEmbedStyle(bodyStyle.lineHeightPx, resolved.layout.inlineResourceGap !== 'above')] : []),
+        ...(codeBoxes.wrapped ? [codeBoxStyle(resolved)] : []),
+    ];
+    const calloutStyles = syntheticBoxes.length > 0
+        ? [...resolved.calloutStyles, ...resolveCalloutStylesConfig(syntheticBoxes, resolved.bodyText, resolved.headings, resolved.unorderedLists, config?.locale)]
         : resolved.calloutStyles;
+    // A box nested in another looks its style up in the configuration it is
+    // laid out with: the listings' box among them.
+    const calloutResolved = codeBoxes.wrapped ? { ...resolved, calloutStyles } : resolved;
     const blockquoteStyle = resolveBlockquoteStyle(resolved);
     const listLevelIndentsPx = computeLevelIndentsPx(resolved, bodyStyle.fontSizePx);
     const orderedMetrics = computeOrderedListRunMetrics(contentBlocks, resolved, bodyStyle.fontSizePx);
@@ -445,7 +482,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
     // it asks for is not applied there. Decided per block, by the writing
     // mode of the styled section the reference sits in (a horizontal
     // appendix of a vertical book turns its figures as asked).
-    const floatPlan = computeFloatPlan(contentBlocks, resources, resourceTypes, incorporated, (blockIdx) => sectionWritingMode(sectionPlan, resolved, blockIdx) === 'vertical-rl');
+    const floatPlan = computeFloatPlan(contentBlocks, resources, resourceTypes, incorporated, (blockIdx) => sectionWritingMode(sectionPlan, resolved, blockIdx) === 'vertical-rl', resolved.layout.floatShrink, resolved.layout.wrap);
     const floatedIds = floatedResourceIds(floatPlan, incorporated, resources, resourceTypes);
     const floatsByFirstBlock = new Map();
     for (const f of floatPlan) {
@@ -808,7 +845,9 @@ function placeDocumentPass(content, config, cache, options, hints) {
     /** Pages whose head or foot a floated box took (see the gallery rule in
      *  `placeFloatInColumns`). */
     const calloutBandPages = new Set();
-    const enqueueCalloutFloat = (startIdx, plan, style, L, placement, span) => {
+    const enqueueCalloutFloat = (startIdx, plan, style, L, placement, span, 
+    /** Text wraps round the box (#627): a one-column float at its side. */
+    wrap) => {
         const key = `${CALLOUT_FLOAT_PREFIX}${startIdx}`;
         const columns = plan.attrs.columns !== undefined ? floatColumnCount(plan.attrs.columns) : style.columns;
         // A keep-with-next replay passes the fence again: enqueue once.
@@ -824,6 +863,9 @@ function placeDocumentPass(content, config, cache, options, hints) {
                 span: span === 'page' ? 'page' : 'column',
                 ...(span === 'column' && columns > 1 ? { columns } : {}),
                 callout: { startIdx },
+                ...(wrap && span === 'column' && columns === 1
+                    ? { widthFraction: wrap.width, align: wrap.side, wrap: wrap.side, ...(wrap.gap ? { wrapGap: wrap.gap } : {}) }
+                    : {}),
                 ...(col ? { refPageIndex: page.index, refY: col.bbox.y + (col.bbox.height - col.availableHeight) } : {}),
             });
         }
@@ -891,7 +933,8 @@ function placeDocumentPass(content, config, cache, options, hints) {
     };
     const rotationKey = (rotated) => rotated ? `:${rotated.direction}${rotated.length.toFixed(2)}${rotated.upright ? 'u' : ''}` : '';
     const asideKey = (a) => (a ? `:aside${a.dx.toFixed(1)}x${a.width.toFixed(1)}${a.alignBottom ? 'b' : 't'}${(a.offsetY ?? 0).toFixed(1)}` : '');
-    const layoutFloat = (resourceId, width, slice, rotated, aside) => {
+    const capKey = (cap) => (cap ? `:cap${cap.maxBodyHeight.toFixed(2)}@${cap.minScale}` : '');
+    const layoutFloat = (resourceId, width, slice, rotated, aside, cap) => {
         const resource = resourceById.get(resourceId);
         if (!resource)
             return null;
@@ -912,6 +955,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
             ...(rotated ? (rotated.upright ? { upright: { maxLength: rotated.length } } : { rotate: rotated.direction, rotatedLength: rotated.length }) : {}),
             ...(aside ? { captionAside: aside } : {}),
             ...(flexPx > 0 ? { bodyHeightDelta: flexPx } : {}),
+            ...(cap && !rotated ? { maxBodyHeight: cap.maxBodyHeight, minBodyScale: cap.minScale } : {}),
         });
     };
     /** The rotation of a pending float on a band whose columns keep `avail`
@@ -962,8 +1006,8 @@ function placeDocumentPass(content, config, cache, options, hints) {
     /** Height (and caption baseline) of a float at a given width, memoised —
      *  fit checks run for every pending float on every loop iteration. */
     const floatMeasureMemo = new Map();
-    const measureFloat = (resourceId, width, slice, rotated, aside) => {
-        const key = `${resourceId}:${width.toFixed(2)}${sliceKey(slice)}${rotationKey(rotated)}${asideKey(aside)}`;
+    const measureFloat = (resourceId, width, slice, rotated, aside, cap) => {
+        const key = `${resourceId}:${width.toFixed(2)}${sliceKey(slice)}${rotationKey(rotated)}${asideKey(aside)}${capKey(cap)}`;
         const memo = floatMeasureMemo.get(key);
         if (memo !== undefined)
             return memo;
@@ -997,7 +1041,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
             floatMeasureMemo.set(key, mc);
             return mc;
         }
-        const laid = layoutFloat(resourceId, width, slice, rotated, aside);
+        const laid = layoutFloat(resourceId, width, slice, rotated, aside, cap);
         let m = null;
         if (laid && laid.block.rotation) {
             // A rotated block takes its band whole: no caption baseline to align,
@@ -1018,10 +1062,12 @@ function placeDocumentPass(content, config, cache, options, hints) {
                 if (lastBaseline === undefined || ln.baseline > lastBaseline)
                     lastBaseline = ln.baseline;
             }
+            const picture = rb.kind === 'bitmap' || rb.kind === 'svg' || rb.kind === 'video';
             m = {
                 height: laid.totalHeight,
                 ...(lastBaseline !== undefined ? { lastCaptionBaseline: lastBaseline } : {}),
                 ...(laid.asideHeight !== undefined ? { asideHeight: laid.asideHeight } : {}),
+                ...(picture ? { body: { height: rb.bodyRect.height, scale: rb.shrinkScale ?? 1 } } : {}),
             };
         }
         floatMeasureMemo.set(key, m);
@@ -1037,7 +1083,9 @@ function placeDocumentPass(content, config, cache, options, hints) {
     flushEnd = false, aside, 
     /** The page is a verso of mirrored margins (a floated box's `'outer'`
      *  corner icon hangs on the left there). */
-    mirrored = false) => {
+    mirrored = false, 
+    /** A picture scaled to its slot (`placement.shrink`). */
+    cap) => {
         const strip = comicStripOf(resourceId);
         if (strip) {
             const block = buildComicStripBlock(strip.idx, strip.source, x, width, contentArea.height - 2 * floatGapPx, cursor.pageIndex);
@@ -1050,7 +1098,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
             calloutFloatResults.set(result.frame, { result, startIdx, plan: cf.plan });
             return { block: result.frame, height: result.totalHeight };
         }
-        const laid = layoutFloat(resourceId, width, slice, rotated, aside);
+        const laid = layoutFloat(resourceId, width, slice, rotated, aside, cap);
         if (!laid)
             return null;
         const { block: rb, totalHeight } = laid;
@@ -1089,6 +1137,52 @@ function placeDocumentPass(content, config, cache, options, hints) {
     /** Pages a `:::pagebreak{center}` opened (#424). */
     const centredPages = new Set();
     const reservedOf = (col) => floatReserved.get(col) ?? { top: 0, bottom: 0 };
+    /** Text wrap (#627): floats set in a band at the head or foot of one
+     *  column that text may run beside, per column. The band stays a band
+     *  until running text comes to take it back (`openFloatWraps`). */
+    /** The room a wrapped item takes from the lines beside it (#627): its
+     *  width and gap, in whole characters of the body under a CJK character
+     *  grid (`cjk.grid`), so the lines beside it keep to the grid. */
+    const wrapExclusionWidth = (columnWidth, itemWidth, gap) => {
+        const w = itemWidth + gap;
+        const em = bodyStyle.fontSizePx;
+        return Math.min(columnWidth, resolved.cjk.grid.enabled && em > 0 ? Math.ceil((w - 0.01) / em) * em : w);
+    };
+    /** The `textWrap` warnings of this pass (#627). */
+    const textWrapNotes = [];
+    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
+     *  text has not entered yet, one at its foot the text has not reached. */
+    const openFloatWraps = (col) => {
+        const list = floatWraps.get(col);
+        if (!list)
+            return;
+        floatWraps.delete(col);
+        for (const w of list) {
+            const r = { ...reservedOf(col) };
+            if (w.position === 'top') {
+                // A block already stands under it, or another band between: it
+                // keeps its band.
+                if (col.blocks.length > 0 || Math.abs(w.ex.y + w.need - col.bbox.y) > 0.5)
+                    continue;
+                col.bbox.y -= w.need;
+                col.bbox.height += w.need;
+                col.availableHeight += w.need;
+                r.top = Math.max(0, r.top - w.need);
+                openColumnWrap(col, w.ex, 'top');
+            }
+            else {
+                if (uncappedBottoms.has(col) || Math.abs(col.bbox.y + col.bbox.height - w.ex.y) > 0.5 || columnCursorY(col) > w.ex.y + 0.01)
+                    continue;
+                col.bbox.height += w.need;
+                col.availableHeight += w.need;
+                r.bottom = Math.max(0, r.bottom - w.need);
+                openColumnWrap(col, w.ex, 'bottom');
+            }
+            floatReserved.set(col, r);
+        }
+    };
     const floatHeadOf = (col) => reservedOf(col).top;
     /** `BandCap.headPx` for a cap proposed on `cols`: how far the float bands
      *  every column holds at its head put the band's top below its bare one. */
@@ -1342,6 +1436,50 @@ function placeDocumentPass(content, config, cache, options, hints) {
         built.block.contentIndex = anchorIdx;
         (page.floats ??= []).push(built.block);
     };
+    /**
+     * A picture float scaled to `room` px of a slot instead of moving on
+     * (`placement.shrink`, #626): the tallest body that keeps its band
+     * within the room. A top band rounds up to the grid, so the float may
+     * stand as tall as the grid multiple within the room, less its gap; a
+     * bottom band (its caption's last baseline on the grid) and a side
+     * stack give the room back px for px. The caption's height may change
+     * with the picture's width (`captionMeasure: 'body'`) and a safe area
+     * crops before it scales, so the cap is refined over a few rounds. The
+     * scale never goes below the float's `minScale`; `fits` is false when
+     * even that does not hold the room. Null for a float that does not
+     * scale (no `shrink`, not an upright picture, the rest of a table) or
+     * already fits.
+     */
+    const shrinkToRoom = (f, width, aside, full, room, topBand, bandOf) => {
+        if (!f.shrink || !full.body || f.rotate || f.startRow)
+            return null;
+        const minScale = f.minScale ?? DEFAULT_FLOAT_MIN_SCALE;
+        const excessOf = (m, band) => topBand
+            ? m.height + floatGapBelow(m, floatGapPx) - Math.floor((room + 0.01) / baselineGrid) * baselineGrid
+            : band.need - room;
+        let measure = full;
+        let band = bandOf(full);
+        let cap;
+        for (let round = 0; round < 4; round++) {
+            const excess = excessOf(measure, band);
+            if (excess <= 0.01)
+                break;
+            const next = { maxBodyHeight: Math.max(0, measure.body.height - excess), minScale };
+            if (cap && next.maxBodyHeight >= cap.maxBodyHeight - 0.01)
+                break;
+            cap = next;
+            const m = measureFloat(f.resourceId, width, undefined, undefined, aside, cap);
+            if (!m?.body)
+                return null;
+            measure = m;
+            band = bandOf(m);
+            if (m.body.scale <= minScale + 1e-6)
+                break;
+        }
+        if (!cap)
+            return null;
+        return { measure, ...band, cap, fits: excessOf(measure, band) <= 0.01 };
+    };
     const placeFloatInColumns = (page, f, targetCols, position, pageSpan, mode, anchorToCap = false, side = false, refY) => {
         const first = targetCols[0];
         const probe = probeFloatBand(page, f, targetCols, position, pageSpan, anchorToCap, side, refY);
@@ -1350,6 +1488,9 @@ function placeDocumentPass(content, config, cache, options, hints) {
         const { width, xLeft, rotated, aside, sideCol } = probe;
         let { slice, measure, need, y } = probe;
         let rest;
+        /** A picture scaled to this slot (`placement.shrink`, #626). */
+        let cap;
+        const bandOf = (m) => measureFloatBand(position, m, targetCols, page.contentArea, baselineGrid, floatGapPx, (c) => (anchorToCap ? c.bbox.y + c.bbox.height : trueBottom(c, uncappedBottoms)));
         /** The float was cut to this slot (a table slice). */
         let cut = false;
         /** A rotated block wider than the band (its upright height). */
@@ -1359,24 +1500,36 @@ function placeDocumentPass(content, config, cache, options, hints) {
             // when the rest of the column takes it; otherwise it waits for the
             // side column of the next page — where it is set anyway, overflowing,
             // when even an empty column cannot hold it (a dominating figure).
+            let cap;
             if (need > first.availableHeight + 0.01) {
                 // A column that already holds something — a float, a box, or a
                 // heading design standing in it — is no empty column to overflow.
                 const holds = sideUsedBottom(first) > first.bbox.y + 0.5 || (sideObstacles.get(first)?.length ?? 0) > 0;
-                if (mode === 'strict' || holds)
-                    return 'defer';
                 // An empty column shortened by a band above it (a page-span box,
                 // a top float) is no measure of the float: when a full column
                 // would hold it, it waits for one instead of overflowing this one.
-                if (shortSideColumn(page, first) && measure.height <= page.contentArea.height + 0.01)
-                    return 'defer';
-                // Overflowing a column a side caption has shortened: the next pass
-                // sets that caption under its figure and gives the column back.
-                const cutBy = asideCutBy.get(first);
-                if (cutBy !== undefined)
-                    captionUnderProposals.add(cutBy);
+                const waitsForFull = shortSideColumn(page, first) && measure.height <= page.contentArea.height + 0.01;
+                const lastResort = mode === 'fresh' && !holds && !waitsForFull;
+                // A picture scaled to the room the column keeps (#626): any slot
+                // with `'slot'`, when it holds it at its smallest scale or more;
+                // the empty column it would overflow with `'page'` too, at its
+                // smallest scale if need be.
+                if (f.shrink === 'slot' || (f.shrink && lastResort)) {
+                    const s = shrinkToRoom(f, width, undefined, measure, first.availableHeight, false, (m) => measureSideStack(m, first, refY, page.contentArea, baselineGrid, floatGapPx, sideObstacles.get(first)));
+                    if (s && (s.fits || lastResort))
+                        ({ measure, need, y, cap } = s);
+                }
+                if (need > first.availableHeight + 0.01) {
+                    if (!lastResort)
+                        return 'defer';
+                    // Overflowing a column a side caption has shortened: the next pass
+                    // sets that caption under its figure and gives the column back.
+                    const cutBy = asideCutBy.get(first);
+                    if (cutBy !== undefined)
+                        captionUnderProposals.add(cutBy);
+                }
             }
-            const built = buildFloatBlock(f.resourceId, xLeft, width, slice, rotated);
+            const built = buildFloatBlock(f.resourceId, xLeft, width, slice, rotated, false, undefined, false, cap);
             if (!built)
                 return 'skip';
             first.availableHeight = Math.max(0, first.availableHeight - need);
@@ -1404,9 +1557,26 @@ function placeDocumentPass(content, config, cache, options, hints) {
                 const gallery = need <= minAvail + 0.01
                     && f.refPageIndex !== undefined && f.refPageIndex < page.index
                     && calloutBandPages.has(page) && !calloutFloatOf(f.resourceId);
-                if (!gallery)
-                    return 'defer';
-                galleryFill = true;
+                if (gallery) {
+                    galleryFill = true;
+                }
+                else {
+                    // A picture that scales to any slot (#626) takes the room left
+                    // beside the other band, the text room kept, when it holds it
+                    // at its smallest scale or more.
+                    const s = f.shrink === 'slot' ? shrinkToRoom(f, width, aside, measure, minAvail - minTextPx, position === 'top', bandOf) : null;
+                    if (!s?.fits)
+                        return 'defer';
+                    ({ measure, need, y, cap } = s);
+                }
+            }
+            // Dominating the band: a picture that scales (`'page'` or `'slot'`,
+            // #626) takes the band's room, at its smallest scale if need be —
+            // then it runs past the band, as any dominating float does.
+            if (need > minAvail + 0.01 && f.shrink && !rotated) {
+                const s = shrinkToRoom(f, width, aside, measure, minAvail, position === 'top', bandOf);
+                if (s)
+                    ({ measure, need, y, cap } = s);
             }
             if (need > minAvail + 0.01 || tooWide(measure)) {
                 // Dominating the band: a table is cut to it (a rotated table, to
@@ -1432,6 +1602,19 @@ function placeDocumentPass(content, config, cache, options, hints) {
             // too wide.
             if (f.rotate || tooWide(measure))
                 return 'defer';
+            // A picture that scales to any slot (#626) takes this one when it
+            // holds it at its smallest scale or more (the text room kept next
+            // to another band, as `fitsStrict` keeps it); the loop below checks
+            // the band as for any float.
+            if (f.shrink === 'slot' && measure.body && !rotated) {
+                const room = Math.min(...targetCols.map((c) => c.availableHeight - (columnHasFloatBand(page, c) ? minTextPx : 0)));
+                if (need > room + 0.01) {
+                    const s = shrinkToRoom(f, width, aside, measure, room, position === 'top', bandOf);
+                    if (!s?.fits)
+                        return 'defer';
+                    ({ measure, need, y, cap } = s);
+                }
+            }
             for (const c of targetCols) {
                 if (position === 'bottom' && uncappedBottoms.has(c) && !anchorToCap) {
                     // Trailing cap: the band must lie entirely below the level cut.
@@ -1489,7 +1672,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
         // An upright figure of a vertical page stands at the head of its tier
         // (`placement.align`: `left` the top, `center`, `right` the foot).
         const flush = rotated?.upright ? (f.align === 'center' ? 0.5 : f.align === 'right' ? 1 : 0) : rotated ? rotatedFlushEnd(page) : false;
-        const built = buildFloatBlock(f.resourceId, xLeft, width, slice, rotated, flush, aside, mirroredOf(page));
+        const built = buildFloatBlock(f.resourceId, xLeft, width, slice, rotated, flush, aside, mirroredOf(page), cap);
         if (!built)
             return 'skip';
         // The caption beside the figure takes its band of the side column: a
@@ -1544,6 +1727,40 @@ function placeDocumentPass(content, config, cache, options, hints) {
         if (galleryFill)
             for (const col of targetCols)
                 col.availableHeight = 0;
+        // Text wrap (#627): a one-column float at the head or foot of its
+        // column, which running text may take back to run beside it — unless
+        // the text left beside it would be too narrow, or the float too short
+        // for lines beside it.
+        if (f.wrap && !pageSpan && !side && targetCols.length === 1 && !rotated && !aside && !cut && !galleryFill
+            && !(position === 'bottom' && uncappedBottoms.has(first))) {
+            const gap = wrapGapPx(f.wrapGap, dpi, bodyStyle.fontSizePx, floatGapPx);
+            const settings = resolved.layout.wrap;
+            const reason = first.bbox.width - width - gap + 0.01 < minTextWidthPx(settings.minTextWidth, first.bbox.width, dpi, bodyStyle.fontSizePx)
+                ? 'tooNarrow'
+                : Math.round(need / bodyStyle.lineHeightPx) < settings.minLinesBeside ? 'fewLines' : undefined;
+            if (reason) {
+                textWrapNotes.push({ kind: 'textWrap', reason, resourceId: f.resourceId, pageIndex: page.index });
+            }
+            else {
+                const exWidth = wrapExclusionWidth(first.bbox.width, width, gap);
+                const exY = position === 'top' ? first.bbox.y - need : first.bbox.y + first.bbox.height;
+                const list = floatWraps.get(first) ?? [];
+                list.push({
+                    position,
+                    need,
+                    ex: {
+                        x: f.wrap === 'left' ? first.bbox.x : first.bbox.x + first.bbox.width - exWidth,
+                        y: exY,
+                        width: exWidth,
+                        height: need,
+                        side: f.wrap,
+                        gap: exWidth - width,
+                        ownerId: built.block.id,
+                    },
+                });
+                floatWraps.set(first, list);
+            }
+        }
         commitFloatBlock(page, first, built, xLeft, y, width, f.firstBlockIdx);
         floatsPlaced++;
         return rest ? { rest } : 'placed';
@@ -1898,6 +2115,8 @@ function placeDocumentPass(content, config, cache, options, hints) {
     /** Blocks whose style tracks text of a joining script, which is set
      *  untracked (see `BlockMeasureContext.joiningLetterSpacing`). */
     const joiningLetterSpacing = new Set();
+    /** Paragraphs whose drop cap could not be set as configured (#623). */
+    const dropCapNotes = new Map();
     // Everything per-block measurement needs that is constant for this pass.
     const measureCtx = {
         resolved,
@@ -1923,6 +2142,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
         floatedIds,
         leftFlow: calloutsOutOfFlow,
         joiningLetterSpacing,
+        dropCapNotes,
         ...(footnoteNumbering.numbers.size > 0 ? { footnoteNumbers: footnoteNumbering.numbers } : {}),
         ...(anchorRefContext ? { anchorRefs: anchorRefContext } : {}),
     };
@@ -2283,7 +2503,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
                     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),
-                        ...(line.measure ? { measure: { x: line.measure.x + x, width: line.measure.width } } : {}),
+                        ...(line.measure ? { measure: { ...line.measure, x: line.measure.x + x } } : {}),
                         baseline: line.baseline + y,
                     }));
                     const h = blk.lines.length * noteStyle.lineHeightPx;
@@ -2745,7 +2965,8 @@ function placeDocumentPass(content, config, cache, options, hints) {
             return;
         const band = currentBand(page, cursor);
         const cols = bandColumns(page, band).filter((c) => c.bbox.height > 0.5);
-        if (cols.length < 2 || cols.some((c) => c.forcedBreak))
+        // A band where text wraps round something (#627) is not levelled.
+        if (cols.length < 2 || cols.some((c) => c.forcedBreak || (c.exclusions?.length ?? 0) > 0))
             return;
         if (activeCap && activeCap.spanIndex === boundaryIndex
             && activeCap.pageIndex === page.index && activeCap.band === band) {
@@ -2815,7 +3036,15 @@ function placeDocumentPass(content, config, cache, options, hints) {
      *  page the boundary opens: they sit the drain out and stay pending (with
      *  no reference stamp, which the citing line sets), so they land after
      *  the line that cites them, in the new segment (EF-69). */
+    /** Text wrap (#627): an inline figure that wraps, placed as a band, whose
+     *  band the next block takes back to run beside it when it can (see
+     *  `pipeline/textWrap.ts`). */
+    let pendingWrap = null;
     const closeFlowSegment = (boundaryIndex) => {
+        // What text wrapped round in the column the segment ends in keeps its
+        // room (#627).
+        pendingWrap = null;
+        settleColumnWraps(currentColumn(doc, cursor));
         settleAwaitingSideBoxes(true);
         releaseStaleCitationGates();
         const ownFloats = [];
@@ -3081,7 +3310,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
                 childStartIdx: startIdx + 1 + from.child,
                 width,
                 ctx: measureCtx,
-                resolved,
+                resolved: calloutResolved,
                 containerId: plan.containerId,
                 frameId,
                 nextChildId: () => `${frameId}-c${n++}`,
@@ -3154,7 +3383,9 @@ function placeDocumentPass(content, config, cache, options, hints) {
             return null;
         // A head that goes on also carries the style's continuation marker.
         const tail = tailOf(full) + full.continuesMarkerPx;
-        /** Candidate cuts with the head's content bottom. */
+        /** Candidate cuts with the head's content bottom. A `soft` cut parts a
+         *  wrapped code line from its continuation (#624): taken only when no
+         *  other cut fits. */
         const candidates = [];
         /** Collect the cuts among `units` (one box's items; `below` = the tails
          *  of the nested boxes around them), each side of a cut holding enough
@@ -3197,6 +3428,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
                                 candidates.push({
                                     cut: { child: k, line: lineBase + l, widths: k === from.child ? cutWidths(from, width) : [{ fromLine: 0, width }] },
                                     bottom: line.bbox.y + line.bbox.height + below,
+                                    ...(c.lines[l]?.codeLine?.continued ? { soft: true } : {}),
                                 });
                             }
                         }
@@ -3223,6 +3455,9 @@ function placeDocumentPass(content, config, cache, options, hints) {
         const viable = candidates
             .filter((c) => !insideGroup(c.cut))
             .sort((a, b) => b.bottom - a.bottom);
+        // A wrapped code line stays with its continuations when a cut
+        // elsewhere fits (#624).
+        viable.sort((a, b) => (a.soft ? 1 : 0) - (b.soft ? 1 : 0));
         for (const c of viable) {
             if (c.bottom + tail > roomPx + 0.01)
                 continue;
@@ -4066,6 +4301,83 @@ function placeDocumentPass(content, config, cache, options, hints) {
      * boxes) still fall back to this inline placement for v1 — the frame's
      * `callout.placement` records the request.
      */
+    /**
+     * A box set `here` that text wraps round (#627): laid out whole at its
+     * share of the column, at its side, level with the next line's top, then
+     * set as a band the next running text takes back to run beside it (see
+     * `pendingWrap`). It never splits: too tall for the room left, it moves
+     * on to the next column (a `textWrap` warning says so). Frame and
+     * children go to the page's floats, where a floated box goes. Returns
+     * false, the box set in the flow as any, when the text beside it would
+     * be too narrow or the box too short for lines beside it.
+     */
+    const placeCalloutWrapped = (startIdx, plan, style, L, frameId, wrap) => {
+        const settings = resolved.layout.wrap;
+        const gap = wrapGapPx(wrap.gap, dpi, bodyStyle.fontSizePx, floatGapPx);
+        const note = (reason) => {
+            const start = contentBlocks[startIdx];
+            textWrapNotes.push({ kind: 'textWrap', reason, box: style.id, sourceStart: start.sourceStart + bodyOffset, sourceEnd: start.sourceEnd + bodyOffset, pageIndex: cursor.pageIndex });
+        };
+        let col = currentColumn(doc, cursor);
+        if (col.bbox.width * (1 - wrap.width) - gap + 0.01 < minTextWidthPx(settings.minTextWidth, col.bbox.width, dpi, bodyStyle.fontSizePx)) {
+            note('tooNarrow');
+            return false;
+        }
+        for (let attempt = 0;; attempt++) {
+            col = currentColumn(doc, cursor);
+            const page = doc.pages[cursor.pageIndex];
+            const width = col.bbox.width * wrap.width;
+            const result = L.layoutRange(CUT_START, L.end, width, frameId, false, mirroredOf(page));
+            if (attempt === 0 && Math.ceil((result.totalHeight + gap - 0.01) / bodyStyle.lineHeightPx) < settings.minLinesBeside) {
+                note('fewLines');
+                return false;
+            }
+            const spacing = col.blocks.length === 0 ? 0 : pendingSpacing;
+            if (result.totalHeight > col.availableHeight - spacing + 0.01 && col.blocks.length > 0 && attempt < 4) {
+                if (attempt === 0)
+                    note('moved');
+                pendingSpacing = 0;
+                advanceToNextColumn(doc, cursor, geomResolved, contentArea, pageWidthPx, pageHeightPx, onNewPage);
+                continue;
+            }
+            const top = columnCursorY(col) + spacing;
+            const x = wrap.side === 'left' ? col.bbox.x : col.bbox.x + col.bbox.width - width;
+            const frame = result.frame;
+            stampCalloutSource(frame, startIdx, plan);
+            frame.pageIndex = page.index;
+            frame.columnIndex = col.index;
+            offsetCalloutToAbsolute(result, x, top);
+            const floats = (page.floats ??= []);
+            doc.blocks.push(frame);
+            floats.push(frame);
+            for (const child of result.children) {
+                child.pageIndex = page.index;
+                child.columnIndex = col.index;
+                doc.blocks.push(child);
+                floats.push(child);
+            }
+            const bottomRel = Math.ceil((top - col.bbox.y + result.totalHeight + gap - 0.01) / baselineGrid) * baselineGrid;
+            col.availableHeight = Math.max(0, Math.min(col.availableHeight, col.bbox.height - bottomRel));
+            pendingSpacing = 0;
+            inlineGapOwed = null;
+            const exWidth = wrapExclusionWidth(col.bbox.width, width, gap);
+            pendingWrap = {
+                col,
+                blocks: col.blocks.length,
+                cursorY: columnCursorY(col),
+                ex: {
+                    x: wrap.side === 'left' ? col.bbox.x : col.bbox.x + col.bbox.width - exWidth,
+                    y: top,
+                    width: exWidth,
+                    height: col.bbox.y + bottomRel - top,
+                    side: wrap.side,
+                    gap: exWidth - width,
+                    ownerId: frame.id,
+                },
+            };
+            return true;
+        }
+    };
     const placeCalloutInline = (startIdx, plan) => {
         const style = pickCalloutStyle(calloutStyles, plan.attrs.type);
         const firstFrameId = `block-${blockIdCounter++}`;
@@ -4094,7 +4406,17 @@ function placeDocumentPass(content, config, cache, options, hints) {
             const inFlow = tallerThanColumn(L.layoutRange(CUT_START, L.end, width, 'float-probe', false))
                 && splitCalloutFragment(L, CUT_START, width, contentArea.height, 'float-probe', false, style.splitMinLines) !== null;
             if (!inFlow) {
-                enqueueCalloutFloat(startIdx, plan, style, L, placement, span);
+                const wrap = pageIsVertical(page) ? undefined : resolveCalloutWrap(plan.attrs, resolved.layout.wrap);
+                enqueueCalloutFloat(startIdx, plan, style, L, placement, span, wrap);
+                calloutsOutOfFlow.add(startIdx);
+                return undefined;
+            }
+        }
+        // A box text wraps round (#627): at its side of the column, the text
+        // after it beside it.
+        if (placement === 'here' && span === 'column' && !pageIsVertical(doc.pages[cursor.pageIndex])) {
+            const wrap = resolveCalloutWrap(plan.attrs, resolved.layout.wrap);
+            if (wrap && placeCalloutWrapped(startIdx, plan, style, L, firstFrameId, wrap)) {
                 calloutsOutOfFlow.add(startIdx);
                 return undefined;
             }
@@ -4433,6 +4755,29 @@ function placeDocumentPass(content, config, cache, options, hints) {
         releaseStaleCitationGates(blockIdx);
         tryPlacePendingFloatsOnCurrentPage(spanBoxAt(blockIdx), blockIdx);
         enqueueFloatsFor(blockIdx);
+        // Text wrap (#627): running text after a wrapped figure takes the band
+        // the figure was set in back, and runs beside it; anything else that
+        // takes room from the flow goes under what text wraps round first.
+        // Markers and the `::resource` line of a floated resource leave it.
+        if (!transparentToWrap(rawBlock) && !(rawBlock.type === 'resourceBlock' && rawBlock.resourceId !== undefined && floatedIds.has(rawBlock.resourceId))) {
+            const wrapCol = currentColumn(doc, cursor);
+            const beside = runsBesideWrap(rawBlock);
+            if (pendingWrap) {
+                const { col, blocks, cursorY, ex } = pendingWrap;
+                pendingWrap = null;
+                if (beside && col === wrapCol && col.blocks.length === blocks && Math.abs(columnCursorY(col) - cursorY) < 0.01) {
+                    // The cursor goes back to the figure's top; the text starts there.
+                    col.availableHeight += columnCursorY(col) - ex.y;
+                    pendingSpacing = 0;
+                    inlineGapOwed = null;
+                    openColumnWrap(col, ex, 'top');
+                }
+            }
+            if (!beside && settleColumnWraps(wrapCol)) {
+                pendingSpacing = 0;
+                inlineGapOwed = null;
+            }
+        }
         // --- Directives ----------------------------------------------------
         // (A comic page, `:::page`, and a strip, `:::strip`, are placed below,
         // once a closed part or paper run has taken its page break.)
@@ -4881,6 +5226,10 @@ function placeDocumentPass(content, config, cache, options, hints) {
         if (!measuredBlock)
             continue;
         const { kind, contentBlock, measured, prefixLen, absoluteSourceMap, mathDisplayRender } = measuredBlock;
+        /** The drop cap opening the paragraph (#623): stamped on the fragment
+         *  that holds its first line. A paragraph broken again for a column of
+         *  another width takes the one of that setting. */
+        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;
@@ -4922,12 +5271,55 @@ function placeDocumentPass(content, config, cache, options, hints) {
                     segments: [],
                     isLastLine: true,
                 }];
+            // Text wrap (#627): a picture the text after it may run beside, at
+            // its side of the column — unless the text left beside it would be
+            // too narrow, or the picture too short to set lines beside.
+            const wrapSettings = blockMeasureCtx.resolved.layout.wrap;
+            const wrapSpec = kind.resource && !pageIsVertical(blockPage)
+                ? resolveResourceWrap(kind.resource, kind.resourceType, wrapSettings)
+                : undefined;
+            // Vertical text keeps its figures' bands whole (horizontal wrap only).
+            if (kind.resource && pageIsVertical(blockPage) && resolveResourceWrap(kind.resource, kind.resourceType, wrapSettings)) {
+                textWrapNotes.push({
+                    kind: 'textWrap', reason: 'verticalText', resourceId: kind.resource.id,
+                    sourceStart: rawBlock.sourceStart + bodyOffset, sourceEnd: rawBlock.sourceEnd + bodyOffset, pageIndex: cursor.pageIndex,
+                });
+            }
+            let wrapGap = 0;
+            let wraps = false;
+            if (wrapSpec) {
+                wrapGap = wrapGapPx(wrapSpec.gap, dpi, bodyStyle.fontSizePx, floatGapPx);
+                const textWidth = col.bbox.width * (1 - wrapSpec.width) - wrapGap;
+                const linesBeside = Math.ceil((groupHeight + wrapGap - 0.01) / bodyStyle.lineHeightPx);
+                const reason = textWidth + 0.01 < minTextWidthPx(wrapSettings.minTextWidth, col.bbox.width, dpi, bodyStyle.fontSizePx)
+                    ? 'tooNarrow'
+                    : linesBeside < wrapSettings.minLinesBeside ? 'fewLines' : undefined;
+                if (reason) {
+                    textWrapNotes.push({
+                        kind: 'textWrap', reason, resourceId: kind.resource.id,
+                        sourceStart: rawBlock.sourceStart + bodyOffset, sourceEnd: rawBlock.sourceEnd + bodyOffset, pageIndex: cursor.pageIndex,
+                    });
+                }
+                else {
+                    wraps = true;
+                }
+            }
             // An inline resource keeps the float gap (a line) above it, as a
-            // float would, unless the block before asked for more.
-            const spacingBefore = Math.max(pendingSpacing, floatGapPx);
+            // float would, unless the block before asked for more. A wrapped one
+            // stands level with the next line's top instead.
+            const spacingBefore = wraps ? pendingSpacing : Math.max(pendingSpacing, floatGapPx);
+            const columnBefore = col;
             enterBand(blockIdx, 0);
             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
+            // on with its anchor: say so.
+            if (wraps && currentColumn(doc, cursor) !== columnBefore && columnBefore.blocks.length > 0) {
+                textWrapNotes.push({
+                    kind: 'textWrap', reason: 'moved', resourceId: kind.resource.id,
+                    sourceStart: rawBlock.sourceStart + bodyOffset, sourceEnd: rawBlock.sourceEnd + bodyOffset, pageIndex: cursor.pageIndex,
+                });
+            }
             // `placeBlockInColumn` (inside placeAtomicBlock) shifts `blk.lines`; the
             // resource's own caption/table lines live on `resourceBlock` and must be
             // offset to absolute page coordinates here using the placed bbox origin.
@@ -4938,6 +5330,34 @@ function placeDocumentPass(content, config, cache, options, hints) {
                 addBalanceExtra(currentColumn(doc, cursor), grown);
             }
             doc.blocks.push(blk);
+            // A wrapped picture (#627): the flow goes on under it and its gap, on
+            // a grid line, unless the next block takes the band back to run
+            // beside it (see `pendingWrap`).
+            if (wraps && wrapSpec) {
+                const rCol = currentColumn(doc, cursor);
+                const top = blk.bbox.y;
+                const bottomRel = Math.ceil((top - rCol.bbox.y + groupHeight + wrapGap - 0.01) / baselineGrid) * baselineGrid;
+                rCol.availableHeight = Math.max(0, Math.min(rCol.availableHeight, rCol.bbox.height - bottomRel));
+                pendingSpacing = 0;
+                inlineGapOwed = null;
+                const exWidth = wrapExclusionWidth(rCol.bbox.width, rCol.bbox.width * wrapSpec.width, wrapGap);
+                pendingWrap = {
+                    col: rCol,
+                    blocks: rCol.blocks.length,
+                    cursorY: columnCursorY(rCol),
+                    ex: {
+                        x: wrapSpec.side === 'left' ? rCol.bbox.x : rCol.bbox.x + rCol.bbox.width - exWidth,
+                        y: top,
+                        width: exWidth,
+                        height: rCol.bbox.y + bottomRel - top,
+                        side: wrapSpec.side,
+                        gap: exWidth - rCol.bbox.width * wrapSpec.width,
+                        ownerId: blk.id,
+                    },
+                };
+                flushPendingNumberingAtBoundary();
+                continue;
+            }
             // Snap the flow position after the resource to the baseline grid (the
             // group height is arbitrary), baking in at least marginBottom — same
             // convention as snapped headings — so the following text lands back on
@@ -4965,6 +5385,32 @@ function placeDocumentPass(content, config, cache, options, hints) {
             continue;
         }
         const finalizeListItem = (blk, isFirstPart) => {
+            // The drop cap (#623) stands on the baseline of the line it sinks to,
+            // beside the first fragment only.
+            const capLine = blk.lines[0];
+            if (isFirstPart && capInfo && capLine) {
+                const cap = capInfo;
+                blk.dropCap = {
+                    text: cap.text,
+                    fontString: cap.fontString,
+                    color: cap.color,
+                    x: blk.bbox.x + cap.x,
+                    baselineY: capLine.baseline + (cap.sink - 1) * style.lineHeightPx,
+                    width: cap.width,
+                    fontSizePx: cap.fontSizePx,
+                    lines: cap.lines,
+                    sink: cap.sink,
+                    ...(cap.sourceStart !== undefined ? { sourceStart: cap.sourceStart, sourceEnd: cap.sourceEnd } : {}),
+                    plainStart: cap.plainStart,
+                    plainEnd: cap.plainEnd,
+                    word: cap.word,
+                    wordRest: cap.wordRest,
+                    ...(cap.hang ? { hang: { text: cap.hang.text, fontString: cap.hang.fontString, x: blk.bbox.x + cap.hang.x, baselineY: capLine.baseline, width: cap.hang.width } } : {}),
+                };
+                // The block's source range starts at the initial.
+                if (cap.sourceStart !== undefined && (blk.sourceStart === undefined || cap.sourceStart < blk.sourceStart))
+                    blk.sourceStart = cap.sourceStart;
+            }
             if (!listBullet)
                 return;
             blk.listDepth = listDepth;
@@ -4979,7 +5425,9 @@ function placeDocumentPass(content, config, cache, options, hints) {
             // `bulletXOffsetInColumn` is `indentPx` for unordered/task, and
             // `indentPx + (maxNumberWidth - thisNumberWidth)` for ordered — giving
             // the right-aligned separator.
-            blk.bulletOffsetX = blk.bbox.x + bulletXOffsetInColumn;
+            // Beside a wrapped picture on the left (#627) the marker stands past
+            // it, with its text.
+            blk.bulletOffsetX = blk.bbox.x + bulletXOffsetInColumn + lineInsetsAt(wrapInsets, 0).start;
             if (listBullet.separatorText !== undefined) {
                 blk.separatorText = listBullet.separatorText;
                 blk.separatorFontString = listBullet.separatorFontString;
@@ -5035,7 +5483,12 @@ function placeDocumentPass(content, config, cache, options, hints) {
             (vdtType === 'paragraph' && isContainerTail && paragraphContainer?.snapToGrid !== false) ||
             // A poem, like a container of one block: its own leading and the
             // margins of its style are off the grid, the text after it is not.
-            (vdtType === 'paragraph' && rawBlock.verse !== undefined && verseSnaps(rawBlock.verse.attrs.style, resolved)) ||
+            // A stanza between two of a poem in the line layout snaps too, so the
+            // space between stanzas is whole grid lines (#620); one of a poem set
+            // as single hemistichs (a configuration stored before #620) does not,
+            // as the one block postext 1.22 set it in did not.
+            (vdtType === 'paragraph' && rawBlock.verse !== undefined && verseSnaps(rawBlock.verse.attrs.style, resolved)
+                && (rawBlock.verse.stanza === undefined || rawBlock.verse.stanza.last || versesLineByLine(rawBlock, resolved))) ||
             vdtType === 'mathDisplay');
         // Place block, splitting across columns/pages if needed.
         // List items may split too — orphan/widow protection per-list is gated by
@@ -5072,6 +5525,10 @@ function placeDocumentPass(content, config, cache, options, hints) {
          *  default opener paints across the page. */
         let brokenForWidth = measureWidth;
         let laterWidths = [];
+        /** Text wrap (#627): the lines of the block set short beside what text
+         *  wraps round, as its lines are now set (paragraph line numbers). */
+        let wrapInsets = [];
+        const wrapsBeside = canSplit && runsBesideWrap(rawBlock);
         const rebreaksForColumn = !tryLoose && rawBlock.toc === undefined && rawBlock.index === undefined
             && (canSplit || (vdtType === 'heading' && !opensDefaultOpener(rawBlock)));
         /** Measure the block again for the columns it is set in (see
@@ -5079,6 +5536,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
         const measureForColumns = (extra) => measureContentBlock(rawBlock, blockIdx, brokenForWidth, blockMeasureCtx, {
             styleOverride,
             ...(laterWidths.length > 0 ? { restColumnWidths: laterWidths } : {}),
+            ...(wrapInsets.length > 0 ? { lineInsets: wrapInsets } : {}),
             ...extra,
         });
         // "Keep with next" for colon-introduced lists: a paragraph ending in `:`
@@ -5098,6 +5556,10 @@ function placeDocumentPass(content, config, cache, options, hints) {
         while (remainingLines.length > 0) {
             enterBand(blockIdx, partIndex);
             const curCol = currentColumn(doc, cursor);
+            // A wrapped float at the head or foot of this column (#627): running
+            // text takes its band back to run beside it.
+            if (wrapsBeside)
+                openFloatWraps(curCol);
             // The rest of the block goes into a column of another width than the
             // one it was broken for (EF-157): break it again for this one. Up to
             // postext 1.4 it kept the lines of the column it started in, and a
@@ -5109,8 +5571,10 @@ function placeDocumentPass(content, config, cache, options, hints) {
                     // Nothing placed yet: the whole block, for this column.
                     const again = measureContentBlock(rawBlock, blockIdx, curCol.bbox.width, blockMeasureCtx, { styleOverride });
                     if (again && again.measured.lines.length > 0) {
+                        capInfo = again.dropCap;
                         brokenForWidth = curCol.bbox.width;
                         laterWidths = [];
+                        wrapInsets = [];
                         letterSpacingPx = again.letterSpacingPx;
                         remainingLines = [...raggedLooseLines(again.measured.lines, style.textAlign)];
                         paragraphLines = remainingLines;
@@ -5129,8 +5593,10 @@ function placeDocumentPass(content, config, cache, options, hints) {
                     const keepBreaks = paragraphBreaks && paragraphBreaks.at.length >= placed
                         ? { path: paragraphBreaks.path, at: paragraphBreaks.at.slice(0, placed) }
                         : undefined;
+                    const keptInsets = insetsBefore(wrapInsets, placed);
                     const again = measureContentBlock(rawBlock, blockIdx, brokenForWidth, blockMeasureCtx, {
                         styleOverride, restColumnWidths: steps, ...(keepBreaks ? { keepBreaks } : {}),
+                        ...(keptInsets.length > 0 ? { lineInsets: keptInsets } : {}),
                     });
                     const lines = again && (again.letterSpacingPx ?? 0) === (letterSpacingPx ?? 0)
                         ? [...raggedLooseLines(again.measured.lines, style.textAlign)]
@@ -5138,6 +5604,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
                     if (lines && lines.length > placed
                         && paragraphLines.slice(0, placed).every((l, i) => lines[i].text === l.text && lines[i].hyphenated === l.hyphenated)) {
                         laterWidths = steps;
+                        wrapInsets = keptInsets;
                         paragraphLines = lines;
                         paragraphBreaks = again.measured.breaks;
                         remainingLines = lines.slice(placed);
@@ -5244,6 +5711,58 @@ function placeDocumentPass(content, config, cache, options, hints) {
                     balancing = { levers: [vdtType === 'heading' ? 'heading' : 'afterFloat'], spaceAbove: extraPx };
                 }
             }
+            // A raised initial (#623) keeps its rise clear above the paragraph,
+            // in whole grid lines.
+            if (partIndex === 0 && capInfo && capInfo.rise > 0.5) {
+                spacingBefore += Math.ceil((capInfo.rise - 0.5) / baselineGrid) * baselineGrid;
+            }
+            // Text wrap (#627): the lines this block would set beside what text
+            // wraps round in this column are broken short of it; the lines it
+            // already placed elsewhere keep their breaks. A block that cannot
+            // keep them (a break trace of the other measuring path) goes under
+            // what it would have run beside instead.
+            if (wrapsBeside) {
+                const placed = paragraphLines.length - remainingLines.length;
+                const y0 = columnCursorY(curCol) + spacingBefore;
+                const wanted = wrapInsetSteps(curCol, y0, style.lineHeightPx, placed);
+                if (!sameInsetsFrom(wrapInsets, wanted, placed)) {
+                    const steps = [...insetsBefore(wrapInsets, placed), ...wanted];
+                    const keepBreaks = placed > 0 && paragraphBreaks && paragraphBreaks.at.length >= placed
+                        ? { path: paragraphBreaks.path, at: paragraphBreaks.at.slice(0, placed) }
+                        : undefined;
+                    const again = placed > 0 && !keepBreaks ? null : measureContentBlock(rawBlock, blockIdx, brokenForWidth, blockMeasureCtx, {
+                        styleOverride,
+                        ...(laterWidths.length > 0 ? { restColumnWidths: laterWidths } : {}),
+                        ...(steps.length > 0 ? { lineInsets: steps } : {}),
+                        ...(keepBreaks ? { keepBreaks } : {}),
+                    });
+                    const lines = again && (placed === 0 || (again.letterSpacingPx ?? 0) === (letterSpacingPx ?? 0))
+                        ? [...raggedLooseLines(again.measured.lines, style.textAlign)]
+                        : undefined;
+                    if (lines && lines.length > placed
+                        && paragraphLines.slice(0, placed).every((l, i) => lines[i].text === l.text && lines[i].hyphenated === l.hyphenated)) {
+                        wrapInsets = steps;
+                        paragraphLines = lines;
+                        paragraphBreaks = again.measured.breaks;
+                        remainingLines = lines.slice(placed);
+                        if (placed === 0) {
+                            capInfo = again.dropCap;
+                            letterSpacingPx = again.letterSpacingPx;
+                            guardedEnds = [];
+                            columnEndHyphenRetried = false;
+                        }
+                        regateCitedFloats(blockIdx, lines);
+                    }
+                    else if (wanted.length > 0) {
+                        if (balancing && balancing.spaceAbove > 0) {
+                            balanceExtraInColumn.set(curCol, (balanceExtraInColumn.get(curCol) ?? 0) - balancing.spaceAbove);
+                        }
+                        settleColumnWraps(curCol);
+                        pendingSpacing = 0;
+                        continue;
+                    }
+                }
+            }
             // A loose paragraph's extra line is balancing height too (it lands
             // whole in this column — loose candidates are never split parts).
             const looseTracking = looseOutcome.get(blockIdx);
@@ -5281,6 +5800,11 @@ 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;
+            // A paragraph shorter than its drop cap sinks (#623, `'reserve'`):
+            // the block keeps the room under the initial.
+            if (partIndex === 0 && capInfo && capInfo.minLines > remainingLines.length) {
+                effectiveRemainHeight = capInfo.minLines * style.lineHeightPx;
+            }
             /** How far the lines of a 行取り heading go down its band (#424). */
             let lineSpanShift = 0;
             if (lineSpan !== undefined && partIndex === 0) {
@@ -5557,9 +6081,8 @@ function placeDocumentPass(content, config, cache, options, hints) {
                         ? Math.ceil((naturalBottom - 0.01) / baselineGrid) * baselineGrid
                         : naturalBottom;
                     const remainAfterHeading = curCol.bbox.height - snappedBottom;
-                    const minLinesNeeded = resolved.bodyText.avoidWidows
-                        ? Math.max(1, resolved.bodyText.widowMinLines)
-                        : 1;
+                    // A drop cap opening the text (#623) needs its lines under it.
+                    const minLinesNeeded = Math.max(resolved.bodyText.avoidWidows ? Math.max(1, resolved.bodyText.widowMinLines) : 1, dropCapSinkAfter(blockIdx, blockMeasureCtx));
                     // A `:::space` between the heading and its text needs room too.
                     const minSpaceAfter = minLinesNeeded * bodyStyle.lineHeightPx
                         + spaceLinesAfter(contentBlocks, blockIdx) * baselineGrid;
@@ -5725,7 +6248,8 @@ function placeDocumentPass(content, config, cache, options, hints) {
                 // (the no-fit branch below rolls it back).
                 const headingRun = partIndex === 0 ? trailingHeadingRun(curCol) : 0;
                 if (choice.splitAt === 0 && headingRun > 0 && headingRun < curCol.blocks.length) {
-                    const minKeep = effectiveAvoidWidows ? Math.max(1, resolved.bodyText.widowMinLines) : 1;
+                    // A drop cap's lines stay with it (#623).
+                    const minKeep = Math.max(effectiveAvoidWidows ? Math.max(1, resolved.bodyText.widowMinLines) : 1, partIndex === 0 && capInfo ? capInfo.sink : 1);
                     const minTail = effectiveAvoidOrphans && resolved.headings.keepWithNextSplit === 'rules'
                         ? Math.max(1, resolved.bodyText.orphanMinLines)
                         : 1;
@@ -5848,11 +6372,27 @@ function placeDocumentPass(content, config, cache, options, hints) {
                     }
                 }
                 // A poem's bayt set staggered over two lines (or more) stays in one
-                // column (#378): the cut goes before it — in an empty column, which
-                // the poem cannot leave, after its first line at least.
-                while (choice.splitAt > (curCol.blocks.length === 0 ? 1 : 0) && sameBayt(remainingLines[choice.splitAt - 1], remainingLines[choice.splitAt])) {
+                // column (#378), and so does a line of verse with its turnovers
+                // (#620): the cut goes before it — in an empty column, which the
+                // poem cannot leave, after its first line at least.
+                while (choice.splitAt > (curCol.blocks.length === 0 ? 1 : 0) && sameVerseLine(remainingLines[choice.splitAt - 1], remainingLines[choice.splitAt])) {
                     choice = { splitAt: choice.splitAt - 1, demerit: choice.demerit };
                 }
+                // A paragraph a drop cap opens never breaks before the initial's
+                // last line (#623): it moves on whole, unless it is alone in an
+                // empty column too short for those lines, where it breaks all the
+                // same (and says so).
+                if (partIndex === 0 && capInfo && choice.splitAt > 0 && choice.splitAt < Math.min(capInfo.sink, remainingLines.length)) {
+                    if (curCol.blocks.length > 0)
+                        choice = { splitAt: 0, demerit: choice.demerit };
+                    else
+                        blockMeasureCtx.dropCapNotes?.set(blockIdx, { reason: 'split' });
+                }
+                // A stanza `keepStanzas` covers (a haiku, a tanka) moves on whole,
+                // unless the column is empty: it cannot do better anywhere.
+                if (choice.splitAt > 0 && partIndex === 0 && curCol.blocks.length > 0 && keepsStanzaWhole(rawBlock, resolved)) {
+                    choice = { splitAt: 0, demerit: choice.demerit };
+                }
                 if (choice.splitAt > 0) {
                     // Consume spacing (negative: a container margin pulling the block up)
                     if (spacingBefore !== 0) {
@@ -6121,6 +6661,9 @@ function placeDocumentPass(content, config, cache, options, hints) {
         .map((s) => s.startPageIndex);
     if (restarts.length > 0)
         doc.pageNumberRestarts = restarts;
+    // Line numbers (#621): the lines of this pass counted where they landed,
+    // before the running heads (whose palettes recolour them).
+    buildLineNumbers(doc, contentBlocks, continuation);
     buildHeadersAndFooters(doc, resourceById, {
         // Where two palette entries share a base value, each kind of flow
         // colour follows its own settings under a part or section palette.
@@ -6137,6 +6680,10 @@ function placeDocumentPass(content, config, cache, options, hints) {
             return text.length > 0 ? { styleId, text } : undefined;
         },
     });
+    // The line numbers of code listings (#624), in the same slot, after the
+    // margin numbers' palette pass: they keep `codeStyle.lineNumberColor`.
+    if (codeBoxes.wrapped)
+        buildCodeLineNumbers(doc);
     // Vertical pages: the axis each font's upright characters turn about.
     if (doc.pages.some((p) => pageIsVertical(p)))
         stampCentralBaselines(doc);
@@ -6148,6 +6695,17 @@ function placeDocumentPass(content, config, cache, options, hints) {
     doc.iterationCount = 1;
     if (joiningLetterSpacing.size > 0)
         joiningSpacingWarnings.set(doc, joiningLetterSpacingWarnings(doc, joiningLetterSpacing));
+    if (dropCapNotes.size > 0)
+        dropCapWarningsByDoc.set(doc, dropCapWarnings(doc, dropCapNotes));
+    // Pictures scaled to the room of their slot (#626), at the block citing them.
+    const shrunk = floatShrinkWarnings(doc, (idx) => {
+        const b = contentBlocks[idx];
+        return b ? { start: b.sourceStart + bodyOffset, end: b.sourceEnd + bodyOffset } : undefined;
+    });
+    if (shrunk.length > 0)
+        floatShrinkWarningsByDoc.set(doc, shrunk);
+    if (textWrapNotes.length > 0)
+        textWrapWarningsByDoc.set(doc, textWrapNotes);
     return { doc, forcedBreakPages, bandCapProposals, spanPlacedInBand, bandCapsApplied, looseOutcome, captionUnderProposals };
 }
 /** Passes a document printing its own contents gets at most, beyond the
@@ -6207,7 +6765,10 @@ export function* buildDocumentGen(content, config, cache, options) {
     // Justified CJK lines the composer could not fill within its tracking
     // cap; words of a joining script that run past their line, and styles
     // whose letter-spacing such words do not take.
-    const loose = [...cjkLooseLineWarnings(doc), ...wordOverflowWarnings(doc), ...(joiningSpacingWarnings.get(doc) ?? [])];
+    // 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) ?? [])];
+    // Design texts cut to fit their width (#628).
+    loose.push(...designTruncationWarnings(doc));
     // Comic panels whose cell cannot hold their picture's safe area (#556).
     for (const page of doc.pages) {
         if (page.comic)
@@ -6250,10 +6811,16 @@ const indexWarnings = new WeakMap();
 /** The `joiningScriptLetterSpacing` warnings of the last pass, per
  *  document. */
 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. */
+const floatShrinkWarningsByDoc = new WeakMap();
+/** The `textWrap` warnings of a build (#627), found by its last pass. */
+const textWrapWarningsByDoc = new WeakMap();
 /** `doc` with the page of each of its index marks (`doc.indexMarks`). */
 function withIndexMarks(doc, content) {
     const { content: body, contentOffset } = extractFrontmatter(content.markdown);
-    const blocks = parseMarkdownMemo(body);
+    const blocks = parseMarkdownMemo(body, codeParseOptions(doc.config));
     if (content.markdown.includes(':index')) {
         const marks = locateIndexMarks(doc, blocks, contentOffset);
         if (marks)
@@ -6274,7 +6841,7 @@ function* buildDocumentRounds(content, config, cache, options) {
     // follows, and a numbering restart after the front matter usually settles
     // it in one extra round.
     if (content.outline === undefined) {
-        const parsed = parseMarkdownMemo(extractFrontmatter(content.markdown).content);
+        const parsed = parseMarkdownMemo(extractFrontmatter(content.markdown).content, codeParseOptions(resolveAllConfig(config)));
         // A reference printing an anchor's page (#263) settles the same way.
         const pageRefs = () => {
             if (!hasAnchorRefs(parsed, new Set((content.resources ?? []).map((r) => r.id))))
@@ -6804,6 +7371,21 @@ function* buildDocumentBalanced(content, config, cache, options, tocRound = 0, f
 function sameBayt(a, b) {
     return a?.verse !== undefined && b?.verse !== undefined && a.verse.bayt === b.verse.bayt;
 }
+/** Whether a column may not break between two lines of verse: they set one
+ *  bayt (#378), or `b` is a turnover of the line of verse `a` sets or
+ *  turns over (#620). */
+function sameVerseLine(a, b) {
+    return sameBayt(a, b) || (a?.verseLine !== undefined && b?.verseLine?.turnover === true);
+}
+/** Whether a stanza of the line layout is kept whole (#620): it has no
+ *  more lines of verse than `keepStanzas` asks for. */
+function keepsStanzaWhole(raw, resolved) {
+    const stanza = raw.verse?.stanza;
+    if (!stanza || !versesLineByLine(raw, resolved))
+        return false;
+    const keep = verseLinesSettings(raw.verse.attrs, { fontSizePx: 0, lineHeightPx: 0 }, resolved, false).keepStanzas;
+    return keep > 0 && stanza.lines.length <= keep;
+}
 /** Whether the text after a poem goes back to the baseline grid: unless
  *  the paragraph style its fence names says `snapToGrid: false`. */
 function verseSnaps(styleId, resolved) {