postext 1.22.3 → 1.24.0

package/dist/vdt.d.ts

@@ -1,4 +1,4 @@
-import type { ColorPaletteEntry, DocumentMetadata, PostextResource, Resource, ResourceSafeArea, TableCellAlign, TableCellVerticalAlign, ResolvedPageConfig, ResolvedLayoutConfig, ResolvedBodyTextConfig, ResolvedHeadingsConfig, ResolvedTableStyleConfig, ResolvedNamedTableStyleConfig, TableRules, ResolvedCaptionStyleConfig, ResolvedDiagramStyleConfig, ResolvedVideoStyleConfig, ResolvedVideoPlayerOptions, VideoSource, ResolvedParagraphStyleConfig, ResolvedCalloutStyleConfig, ResolvedChipStyleConfig, CalloutSpan, CalloutPlacement, ResolvedUnorderedListsConfig, ResolvedOrderedListsConfig, ResolvedMathConfig, ResolvedPdfGenerationConfig, ResolvedPrintConfig, ResolvedFolioConfig, ResolvedDesignSlot, ResolvedPartsConfig, ResolvedHeadingStyleConfig, ResolvedTocConfig, ResolvedIndexConfig, ResolvedFootnotesConfig, ResolvedCrossRefsConfig, ResolvedCitationsConfig, ResolvedCjkConfig, CjkRegion, PageRole, PartState, PostextConfig, FolioPaperConfig, ResolvedComicsConfig } from './types';
+import type { ColorPaletteEntry, DocumentMetadata, PostextResource, Resource, ResourceSafeArea, TableCellAlign, TableCellVerticalAlign, ResolvedPageConfig, ResolvedLayoutConfig, ResolvedBodyTextConfig, ResolvedHeadingsConfig, ResolvedTableStyleConfig, ResolvedNamedTableStyleConfig, TableRules, ResolvedCaptionStyleConfig, ResolvedDiagramStyleConfig, ResolvedVideoStyleConfig, ResolvedVideoPlayerOptions, VideoSource, ResolvedParagraphStyleConfig, ResolvedCalloutStyleConfig, ResolvedChipStyleConfig, CalloutSpan, CalloutPlacement, ResolvedUnorderedListsConfig, ResolvedOrderedListsConfig, ResolvedMathConfig, ResolvedPdfGenerationConfig, ResolvedPrintConfig, ResolvedFolioConfig, ResolvedDesignSlot, ResolvedPartsConfig, ResolvedHeadingStyleConfig, ResolvedTocConfig, ResolvedIndexConfig, ResolvedFootnotesConfig, ResolvedCrossRefsConfig, ResolvedCitationsConfig, ResolvedCjkConfig, CjkRegion, PageRole, PartState, PostextConfig, FolioPaperConfig, ResolvedComicsConfig, ResolvedLineNumbersConfig, ResolvedCodeStyleConfig } from './types';
 import type { NumeralStyle } from './numbering';
 import type { MathRender } from './math/types';
 export interface BoundingBox {
@@ -77,8 +77,18 @@ export interface ResolvedConfig {
      *  hashes) as before. Read it with `resolvedComics()`, which falls back
      *  to the defaults of the document language. */
     comics?: ResolvedComicsConfig;
-}
-export type VDTBlockType = 'paragraph' | 'heading' | 'resource' | 'blockquote' | 'listItem' | 'footnoteRef' | 'mathDisplay' | 'callout';
+    /** Line numbers (`PostextConfig.lineNumbers`, #621), resolved, when the
+     *  config sets the section; absent otherwise (no numbers). */
+    lineNumbers?: ResolvedLineNumbersConfig;
+    /** Code listings and inline code (`PostextConfig.codeStyle`, #624),
+     *  resolved, when the config sets the section; absent otherwise (the
+     *  defaults apply, `resolvedCodeStyle`). */
+    codeStyle?: ResolvedCodeStyleConfig;
+}
+export type VDTBlockType = 'paragraph' | 'heading' | 'resource' | 'blockquote' | 'listItem' | 'footnoteRef' | 'mathDisplay' | 'callout'
+/** A line of a code listing (#624): one line per source line, set as
+ *  written (see `VDTLine.codeLine`), inside the listing's box. */
+ | 'code';
 export type TextAlign = 'left' | 'justify' | 'center' | 'right';
 /** One run of a chip's text: its own font (bold / italic / script, at the
  *  chip size) and advance. */
@@ -200,6 +210,25 @@ export interface VDTLineSegment {
     /** A space of a bibliography entry's label column (#290): its width is
      *  set, so renderers paint the line segment by segment. */
     labelTab?: true;
+    /** A leader (#622): the dots of a contents row, or of a tab stop in body
+     *  text, painted over the room before the text at the stop. `'text'`:
+     *  `text` is the run of the leader character, painted like a word;
+     *  `'rule'`: a line drawn across the segment's `width` a little under the
+     *  baseline (`text` is empty). A leader is no character of the
+     *  paragraph: it is not in the line's `text`, copied or extracted text,
+     *  search or the source map; the HTML viewer hides it from assistive
+     *  technology and the tagged PDF paints it as an artifact. */
+    leader?: 'text' | 'rule';
+    /** A tab at its stop (#622; the `space` segment flagged `labelTab`, text
+     *  `'\t'`): how the stop aligns the text after it and where it stands,
+     *  px from the start edge of the measure (the measure being the line's
+     *  box less its indent: `bbox.x` is that edge plus the line's indent).
+     *  Read by outputs that cannot keep the stops exactly (the reflowable
+     *  EPUB). */
+    tab?: {
+        align: import('./types').TabStopAlign;
+        at: number;
+    };
     /** True when this segment is part of a caption's numbered label, so renderers
      *  paint it in the configured caption-label colour. */
     captionLabel?: boolean;
@@ -574,9 +603,25 @@ export interface VDTLine {
     segments?: VDTLineSegment[];
     /** Whether this is the last line of the paragraph (ragged even when justified) */
     isLastLine?: boolean;
+    /** The line ends at a forced line break the author typed inside the
+     *  paragraph (#620: a backslash ending a source line, or `\\`): it is set
+     *  at its natural width like a last line ({@link isLastLine} is set), the
+     *  paragraph goes on on the next line, copied text takes a line feed
+     *  there, the reflowable EPUB a `<br/>`. Absent otherwise. */
+    hardBreak?: true;
+    /** The line holds a tab that went to a tab stop (#622): its `space`
+     *  segment flagged `labelTab`, `text` `'\t'`, is as wide as the stop asks,
+     *  followed, when the stop has a leader, by the leader's segment and the
+     *  gap after it (an empty `space`). The widths are final: in a justified
+     *  paragraph the line is {@link ragged} and the measurer gave the slack
+     *  to the word spaces after the last tab; in a centred or right-aligned
+     *  one a last empty `space` fills the line to its measure, so every
+     *  renderer sets it from its start side. Absent otherwise. */
+    tabbed?: true;
     /** Set ragged inside a justified paragraph: a line a URL made unfillable
-     *  (its few word spaces would stretch past the loose-line threshold), or
-     *  a CJK line flagged {@link cjkLoose}. */
+     *  (its few word spaces would stretch past the loose-line threshold), a
+     *  CJK line flagged {@link cjkLoose}, or a line holding a tab stop
+     *  ({@link tabbed}). */
     ragged?: boolean;
     /** A justified CJK line that needed more inter-character spacing than the
      *  cap (½ em, or `bodyText.maxJustifyTracking` when it is set): it is set
@@ -649,10 +694,14 @@ export interface VDTLine {
      *  direction opposes its frame's (an English quotation in an Arabic book),
      *  whose indent and ragged edge fall on the other side. Absent
      *  otherwise. Its start side is the right of the span: renderers align
-     *  the line there (see {@link lineTextAlign}). */
+     *  the line there (see {@link lineTextAlign}).
+     *  Also set, flagged `wrap`, on a line set short beside a picture that
+     *  text wraps round (#627): the span is the line's narrowed measure, and
+     *  the line keeps its block's alignment in it. */
     measure?: {
         x: number;
         width: number;
+        wrap?: true;
     };
     /** How many kashidas (tatweels, U+0640) justification inserted into the
      *  line's words, for warnings and overlays. The tatweels themselves are in
@@ -676,6 +725,44 @@ export interface VDTLine {
         bayt: number;
         part: 'bayt' | 'sadr' | 'ajuz' | 'single';
     };
+    /** A line of a `:::verse` poem in the line layout (#620): the stanza it
+     *  sets (0-based, in its poem), the line of verse (0-based, counted
+     *  through the whole poem) and whether it is a turnover, the part of a
+     *  line of verse too wide for the measure set on the line after it. A
+     *  column or page never breaks between a line and its turnover.
+     *  `indent` is the line's indent (px, from the poem's start side: its
+     *  leading spaces × `indentStep`, or where a stepped line starts), set
+     *  on its first line when not 0. `stanzaEnd` is set on the last line of
+     *  a stanza another follows (copied text puts a blank line there).
+     *  `spaceRatio` is set on a line a little too wide for the measure whose
+     *  word spaces were tightened so it stays on one line: their width as a
+     *  share of their natural width (never under `bodyText.minWordSpacing`).
+     *  The widths of the line's segments are final (the block is set flush
+     *  left): renderers paint them as they are. Absent on any other line. */
+    verseLine?: {
+        stanza: number;
+        line: number;
+        turnover: boolean;
+        indent?: number;
+        stanzaEnd?: true;
+        spaceRatio?: number;
+    };
+    /** A line of a code listing (#624, a `code` block): `line` is the source
+     *  line it sets (0-based in the listing), `number` its printed number
+     *  when the listing is numbered (never on a continuation), `continued`
+     *  a continuation of a wrapped line, `highlight` a line the fence's
+     *  `highlight` names, `wrapped` a line that goes on in the next one,
+     *  `clipped` a line cut at the box's edge. The segments carry final
+     *  widths from the block's left edge (spaces are kept, never
+     *  stretched). Absent on any other line. */
+    codeLine?: {
+        line: number;
+        number?: string;
+        continued?: true;
+        highlight?: true;
+        wrapped?: true;
+        clipped?: true;
+    };
     /** The first line of an entry of a back-of-book index (`:::index`): the
      *  entry's level (0 a main entry, 1 a sub-entry…). A block of the index
      *  may set more than one entry (the page-less entries heading its
@@ -763,6 +850,13 @@ export interface VDTResourceTableLayout {
     rowEdges: number[];
     /** Which rules to stroke with `borderWidthPx` (`'grid'` when absent). */
     rules?: TableRules;
+    /** The rules of a `'booktabs'` table (#625), computed by the layout: the
+     *  renderers stroke exactly these, in `borderColor`, and skip the
+     *  {@link rules} pattern (and the rounded frame). Coordinates are
+     *  relative to the table body's top-left corner, like {@link rowEdges};
+     *  each stroke is centred on its line. `borderWidthPx` is then the
+     *  widest stroke. Absent for the other patterns. */
+    strokes?: VDTTableStroke[];
     /** Radii (px) of the outer frame's corners — top-left, top-right,
      *  bottom-right, bottom-left — from `tableStyle.borderRadius`, clamped to
      *  half the table's width and height. The frame is stroked round and the
@@ -770,6 +864,15 @@ export interface VDTResourceTableLayout {
      *  corners where it continues. Absent for a square frame. */
     frameRadii?: [number, number, number, number];
 }
+/** One rule of a table (`VDTResourceTableLayout.strokes`): a straight
+ *  line from `(x1, y1)` to `(x2, y2)`, `widthPx` thick, with butt ends. */
+export interface VDTTableStroke {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    widthPx: number;
+}
 /** A rounded outline: a rect and its corner radii (top-left, top-right,
  *  bottom-right, bottom-left). */
 export interface RoundedOutline {
@@ -953,10 +1056,18 @@ export declare function pageIsVertical(page: Pick<VDTPage, 'flow'>): boolean;
  * block set against its frame's direction), whose start side is the right
  * of its span: `left` (the start; also the last line of a justified
  * paragraph, `justify` coming back as `right`) is flush right, `right` (the
- * end) flush left, and a centred line stays centred. A justified line that
+ * end) flush left, and a centred line stays centred. A span flagged `wrap`
+ * (a line beside a wrapped picture, #627) keeps the block's alignment. A justified line that
  * is not its paragraph's last is filled across the span either way.
  */
 export declare function lineTextAlign(line: Pick<VDTLine, 'measure'>, textAlign: TextAlign): TextAlign;
+/** A rule leader (`VDTLineSegment.leader: 'rule'`, #622) at a text size of
+ *  `fontSizePx`: its centre `dy` px under the baseline and its stroke
+ *  `thickness` px, the same on every renderer. */
+export declare function leaderRuleGeometry(fontSizePx: number): {
+    dy: number;
+    thickness: number;
+};
 export declare function pageIsMirrored(page: Pick<VDTPage, 'flow'>): boolean;
 /** Map a point of a page's flow frame to page coordinates: the identity on
  *  a left-to-right horizontal page, `(page.width − y, x)` on a vertical
@@ -1074,6 +1185,11 @@ export interface ResolvedResourceBlock {
         grow: number;
         delta: number;
     };
+    /** For a floated picture scaled to the room of its slot
+     *  (`placement.shrink`, #626): the share of its width it keeps, below 1.
+     *  Absent when the picture is set at its size (or only cropped within
+     *  its safe area). */
+    shrinkScale?: number;
     /** For bitmap/svg: the out-of-band binary id to resolve at render time. */
     fileId?: string;
     /** For bitmap: the source format (e.g. `'png'`, `'jpeg'`, `'webp'`). */
@@ -1113,6 +1229,55 @@ export interface ResolvedResourceBlock {
      *  note fonts and colour. Empty otherwise. */
     continuesLines: VDTLine[];
 }
+/**
+ * A paragraph's drop cap (#623, {@link VDTBlock.dropCap}), in page
+ * coordinates of the flow frame, as a list marker's are. The block's
+ * lines do not hold it: its first line starts after it. Its plain text and
+ * source range are the paragraph's own, so the block's `sourceMap` and the
+ * first line's `plainStart` (which counts past it) read the word whole.
+ */
+export interface VDTDropCap {
+    /** The initial as printed: its letters, with an opening mark set with
+     *  the cap (`punctuation: 'with-cap'`). */
+    text: string;
+    fontString: string;
+    /** Hex. */
+    color: string;
+    /** Left edge of the initial's advance. */
+    x: number;
+    /** The baseline it stands on: that of the paragraph's line `sink`. */
+    baselineY: number;
+    /** Its advance width. */
+    width: number;
+    /** Its size (px) and how many lines it spans and sinks. */
+    fontSizePx: number;
+    lines: number;
+    sink: number;
+    /** Source range of the characters it prints (an opening mark hung or set
+     *  with it included). */
+    sourceStart?: number;
+    sourceEnd?: number;
+    /** The paragraph's plain-text range it stands for, from 0 (the first
+     *  line's `plainStart` counts past it). */
+    plainStart: number;
+    plainEnd: number;
+    /** The whole first word as the paragraph reads it, the initial
+     *  included ("Se" of "Se puso"): a tagged PDF gives it as the
+     *  `/ActualText` of the initial and the rest of the word. */
+    word: string;
+    /** How many characters of the first line's text finish that word (the
+     *  "e" of "Se"); 0 when the initial is a word of its own. */
+    wordRest: number;
+    /** An opening mark hung before the initial at text size
+     *  (`punctuation: 'hang'`), on the first line's baseline. */
+    hang?: {
+        text: string;
+        fontString: string;
+        x: number;
+        baselineY: number;
+        width: number;
+    };
+}
 /** See {@link VDTBlock.stripCaption}. */
 export interface VDTStripCaption {
     /** Index of the first caption line in the block's `lines`, and how many
@@ -1304,6 +1469,28 @@ export interface VDTBlock {
     /** Absolute page X coordinate where the prefix run starts (on the
      *  bullet's `bulletY` / `bulletBaselineY`, as the separator). */
     prefixX?: number;
+    /** A drop cap opening the paragraph (#623), on the fragment that holds
+     *  its first line only: renderers paint it beside the lines, which were
+     *  set short of it. */
+    dropCap?: VDTDropCap;
+    /** A code listing's lines (#624, `type: 'code'`): its language as the
+     *  fence names it; when its lines are numbered, the numbers' face and
+     *  colour and the room between them and the code (they are set in the
+     *  page's `lineNumbers` slot, out of the text, right-aligned before the
+     *  code); and how its lines were fitted when one was too wide. */
+    code?: {
+        lang?: string;
+        numbers?: {
+            gap: number;
+            fontString: string;
+            color: string;
+        };
+        fit?: {
+            mode: 'wrap' | 'shrink' | 'clip';
+            lines: number;
+            scale: number;
+        };
+    };
     /** List kind for `listItem` blocks — drives bullet shape and text decoration. */
     listKind?: 'unordered' | 'ordered' | 'task';
     /** When true, the canvas backend draws a strikethrough through the block's lines (completed tasks). */
@@ -1448,6 +1635,30 @@ export interface VDTColumn {
      *  level: its bottom is the level cut, and column balancing fills the
      *  column up to it even though the page does not flow on. */
     trailingCap?: boolean;
+    /** Regions of the column that text wraps round (#627): a picture or a
+     *  box narrower than the column, set at one of its sides, with the lines
+     *  beside it set short. Page coordinates of the flow frame (as `bbox`);
+     *  each covers the item and its gap on the text's side and under it, its
+     *  height in whole grid lines from its top. Absent when nothing in the
+     *  column wraps. */
+    exclusions?: VDTExclusion[];
+}
+/** A region of a column that text wraps round (see `VDTColumn.exclusions`,
+ *  #627). */
+export interface VDTExclusion {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** The side of the column it stands at, in the flow (the text runs on the
+     *  other side). */
+    side: 'left' | 'right';
+    /** The space between the item and the text beside it (px), part of
+     *  `width`. */
+    gap: number;
+    /** The id of the block that wraps the text: an inline figure's block, a
+     *  float's, or a box's frame. */
+    ownerId: string;
 }
 /** The notes set at the foot of one column (`footnotes.placement:
  *  'column'`). The note paragraphs themselves are in `VDTPage.floats` (and
@@ -1587,6 +1798,18 @@ export interface VDTDesignTextBlock {
      *  runs were ordered at that paragraph level, and an HTML line takes
      *  `dir="rtl"`. Absent for left-to-right text. */
     direction?: 'rtl';
+    /** The element lost part of a line to fit its width (#628): `mode` is
+     *  how (its `overflow`, or `'clip'` with ink past the box), `elementId`
+     *  the element's id, `slot` where its design is painted and `text` the
+     *  whole text it was given. The build reports it as a
+     *  `designTextTruncated` content warning. Absent when every line shows
+     *  whole. */
+    truncated?: {
+        elementId: string;
+        slot: VDTDesignSlotKind;
+        mode: 'ellipsis-start' | 'ellipsis-end' | 'ellipsis-middle' | 'clip';
+        text: string;
+    };
     /** Set vertically on a page or a slot whose text is horizontal
      *  (`DesignTextElement.writingMode: 'vertical-rl'`): the lines are laid
      *  out in the block's own frame, turned a quarter turn clockwise about
@@ -1953,6 +2176,28 @@ export interface VDTPage {
      *  split lines and lettering, in sheet coordinates. The page's columns
      *  are empty: nothing flows on it. */
     comic?: VDTComicPage;
+    /** The line numbers printed on the page (`lineNumbers`, #621): one text
+     *  block per number, physical like the header and footer, each flagged
+     *  `artifact` (a tagged PDF marks it so, the HTML hides it from
+     *  assistive technology and from selection). Absent on a page with
+     *  none. */
+    lineNumbers?: VDTDesignSlot;
+    /** The line each block of {@link lineNumbers} labels, in the same order:
+     *  for overlays and references. */
+    lineNumberMarks?: VDTLineNumberMark[];
+}
+/** The line a printed line number labels (#621). */
+export interface VDTLineNumberMark {
+    /** The line's number in the count. */
+    number: number;
+    /** The number as printed (in `lineNumbers.format`). */
+    label: string;
+    /** The column the line sits in (`VDTColumn.index`). */
+    columnIndex: number;
+    /** The line's block (`VDTBlock.id`) and its index in the block's
+     *  `lines`. */
+    blockId: string;
+    lineIndex: number;
 }
 /** Something the layout could not set as asked and placed anyway — a box
  *  taller than any column it could go to. Hosts surface these as warnings;
@@ -2010,8 +2255,13 @@ export interface ConfigWarning {
      *  the word it is closest to, when one is close.
      *  `unknownNumerals`: a `numerals` value that is not `'auto'`,
      *  `'latn'`, `'arab'` or `'arabext'`; the digits follow the document
-     *  language, and `used` is the digit system that gives. */
-    kind: 'unknownNumberFormat' | 'fontFamilyStack' | 'sideColumnPercentClamped' | 'columnCountClamped' | 'unknownConfigKey' | 'cjkGridClamped' | 'unknownConfigValue' | 'unknownNumerals';
+     *  language, and `used` is the digit system that gives.
+     *  `lineNumbersUnsupported`: `lineNumbers.enabled` on a vertical
+     *  document (#621), which gets no line numbers; `used` is `false`.
+     *  `wrapUnsupported`: a resource type's `defaultPlacement.wrap` in a
+     *  vertical document (#627), whose figures keep their bands whole;
+     *  `used` is `none`. */
+    kind: 'unknownNumberFormat' | 'fontFamilyStack' | 'sideColumnPercentClamped' | 'columnCountClamped' | 'unknownConfigKey' | 'cjkGridClamped' | 'unknownConfigValue' | 'unknownNumerals' | 'lineNumbersUnsupported' | 'wrapUnsupported';
     /** Where the value sits in the config, e.g.
      *  `orderedLists.levels[1].numberFormat`, `header.elements[0].fontFamily`,
      *  `headingStyles[2].layout.sideColumnPercent`. */
@@ -2078,6 +2328,13 @@ export type ContentWarning = ContentWarningBase & (
     kind: 'referencesUnreadable';
     message: string;
 }
+/** The front matter block is not valid YAML (an unclosed quote, text
+ *  after a quoted value): the document is set without its metadata.
+ *  `message` is the parser's reason, with the line and column. */
+ | {
+    kind: 'invalidFrontmatter';
+    message: string;
+}
 /** A `:::name` line whose name is neither a directive nor a container:
  *  it is set as text. */
  | {
@@ -2317,6 +2574,11 @@ export type ContentWarning = ContentWarningBase & (
     kind: 'rotateIgnoredVertical';
     resourceId: string;
 }
+/** A `:tab` in a block set in vertical text (#622): tab stops are set in
+ *  horizontal text only, so the tab is a word space. */
+ | {
+    kind: 'tabInVerticalText';
+}
 /** A comic page's `split` attribute the grammar cannot read whole (a
  *  stray character, an unclosed `[`, `/` and `|` mixed in one list, a
  *  bracketed list on its parent's axis): the readable part is used, an
@@ -2393,7 +2655,93 @@ export type ContentWarning = ContentWarningBase & (
  | {
     kind: 'comicUnknownSpeaker';
     speaker: string;
+}
+/** A line number set in the side column (`lineNumbers.position:
+ *  'side'`, #621) overlaps a side box, a side caption or another float
+ *  of that column: both are painted where they are. Points at the line
+ *  it numbers; `number` is the number as printed. */
+ | {
+    kind: 'lineNumberOverlap';
+    number: string;
+}
+/** A paragraph a drop cap opens (#623) that could not take it as
+ *  configured. `reason`: `'shortParagraph'`, fewer lines than the
+ *  initial sinks (`handling` says what `shortParagraph` did: kept the
+ *  room, shrank the initial to `lines`, or left it out); `'split'`, the
+ *  paragraph broke before the initial's last line, alone in a column
+ *  too short for it; `'joiningScript'`, its first letter joins the next
+ *  (Arabic, Syriac, N'Ko) and is not set apart; `'verticalText'`, drop
+ *  caps are set in horizontal text only; `'noLetter'`, it opens with no
+ *  letter or digit to set large (a reference, a formula, a note mark).
+ *  `text` is the paragraph's first line. Found by the layout. */
+ | {
+    kind: 'dropCap';
+    reason: 'shortParagraph' | 'split' | 'joiningScript' | 'verticalText' | 'noLetter';
+    handling?: 'reserve' | 'shrink' | 'skip';
+    lines?: number;
+    text: string;
+}
+/** `codeOverflow` (#624): a code listing has lines wider than its box,
+ *  fitted as `codeStyle.overflow` says: turned over (`'wrap'`), set
+ *  smaller (`'shrink'`, at `scale` of its size; past `minFontScale` its
+ *  lines wrap too) or cut at the box's edge (`'clip'`). `lines` counts
+ *  the source lines too wide. Found by the layout. */
+ | {
+    kind: 'codeOverflow';
+    mode: 'wrap' | 'shrink' | 'clip';
+    lines: number;
+    scale?: number;
+    lang?: string;
+}
+/** `floatShrunk` (#626): a floated picture was set smaller than its size
+ *  to fit the room of its slot (`placement.shrink`), at `scale` of its
+ *  width. `overflowPx`: at its smallest scale (`placement.minScale`) it
+ *  still runs this far past the foot of the page's text block, on a page
+ *  where it had nowhere else to go. Found by the layout; information
+ *  more than a fault, unless it overflows. */
+ | {
+    kind: 'floatShrunk';
+    resourceId: string;
+    scale: number;
+    overflowPx?: number;
+}
+/** `textWrap` (#627): a resource or a box set to wrap text round it
+ *  (`placement.wrap`, a box's `wrap`) that does not as asked.
+ *  `'tooNarrow'`: the text beside it would be narrower than
+ *  `layout.wrap.minTextWidth`, so it takes its band whole; `'fewLines'`:
+ *  it is shorter than `layout.wrap.minLinesBeside` lines, so it takes
+ *  its band whole; `'moved'`: an inline one was too tall for the room
+ *  left in its column and moved on to the next, its anchor with it;
+ *  `'verticalText'`: text wraps in horizontal text only, so in a
+ *  vertical flow it takes its band whole. `resourceId` names a
+ *  resource, `box` a box's style. Found by the layout. */
+ | {
+    kind: 'textWrap';
+    reason: 'tooNarrow' | 'fewLines' | 'moved' | 'verticalText';
+    resourceId?: string;
+    box?: string;
+}
+/** `designTextTruncated` (#628): a design text element did not fit its
+ *  width and lost part of a line: cut by an ellipsis (`mode`
+ *  `'ellipsis-*'`, its `overflow`) or clipped with ink past its box
+ *  (`'clip'`). `slot` is where the design is painted (a running head or
+ *  folio, a heading design, a part page, a contents part row),
+ *  `elementId` the element's id and `text` the whole text it was given.
+ *  One per element and page; a running head or folio once per element
+ *  and chapter (a chapter title cut on every page of its chapter is one
+ *  warning). `sourceStart` / `sourceEnd` when the text mirrors a heading
+ *  or a frontmatter field. Found by the layout. */
+ | {
+    kind: 'designTextTruncated';
+    slot: VDTDesignSlotKind;
+    elementId: string;
+    text: string;
+    mode: 'ellipsis-start' | 'ellipsis-end' | 'ellipsis-middle' | 'clip';
 });
+/** Where a design slot is painted: a running head (`'header'`), a folio
+ *  (`'footer'`), a heading design (`'heading'`), a part page or its verso
+ *  (`'part'`), a part row of the contents (`'tocRow'`). */
+export type VDTDesignSlotKind = 'header' | 'footer' | 'heading' | 'part' | 'tocRow';
 /** What a build reports in `VDTDocument.warnings`: a construct the layout
  *  had to force ({@link CalloutOverflowWarning}), with the shape it has had
  *  since postext 1.4. What the source names wrongly is in
@@ -2501,6 +2849,16 @@ export interface VDTDocument {
         title: string;
         palette?: Record<string, string>;
     }[];
+    /** The number of the last line the document counted (`lineNumbers`,
+     *  #621), printed or not; absent when line numbers are off or nothing
+     *  was counted. A host laying out a book chapter by chapter hands it to
+     *  the next chapter (`continuation.lineNumber`) when lines are counted
+     *  through the book. */
+    lastLineNumber?: number;
+    /** Set when the count of {@link lastLineNumber} started again inside
+     *  the document (a restart, a poem's `lineStart`): it does not depend on
+     *  the number the document inherited. */
+    lineNumberRestarted?: true;
 }
 /** What a design image block records of the resource picture `fileId`
  *  (already picked from `resource`): its kind, which decides whether