@stll/folio-core 0.32.2 → 0.33.1

package/dist/display-list/build/colors.js

@@ -0,0 +1,136 @@
+import { BLACK, WHITE } from "../primitives.js";
+//#region src/display-list/build/colors.ts
+/**
+* CSS colour → {@link DisplayColor}.
+*
+* The display list's contract is that colours are already resolved: a backend
+* never sees a custom property, a named OOXML highlight, or `currentColor`.
+* Every such value is collapsed here, at the one place that still knows what
+* the editor's stylesheet means.
+*/
+/**
+* The editor's document custom properties, materialised. A PDF has no theme
+* and no stylesheet: `--doc-canvas` is the paper, `--doc-canvas-text` the ink,
+* `--suggestion-color` the AI-proposal hue (`renderParagraph.ts`'s
+* `SUGGESTION_COLOR_CSS` fallback).
+*/
+const DOC_CANVAS = WHITE;
+const DOC_CANVAS_TEXT = BLACK;
+const SUGGESTION_COLOR = {
+	r: 109,
+	g: 59,
+	b: 214,
+	a: 1
+};
+const TRANSPARENT = {
+	r: 0,
+	g: 0,
+	b: 0,
+	a: 0
+};
+/** Word's automatic-colour keywords (`w:color w:val="auto"`). */
+const AUTOMATIC_COLOR_VALUES = /* @__PURE__ */ new Set([
+	"auto",
+	"windowtext",
+	"currentcolor",
+	"inherit"
+]);
+/**
+* OOXML's named highlight palette (§17.18.40) plus the CSS basic colours the
+* bridge can pass through. Kept small on purpose: the bridge resolves named
+* highlights to hex before layout, so this is a safety net for the values that
+* still arrive as names.
+*
+* A `Map`, not an object: the key is an authored string, and an object lookup
+* would answer `constructor`, `toString` or `__proto__` from the prototype and
+* hand a function to {@link parseHex}.
+*/
+const NAMED_COLORS = /* @__PURE__ */ new Map([
+	["black", "#000000"],
+	["blue", "#0000ff"],
+	["cyan", "#00ffff"],
+	["darkblue", "#000080"],
+	["darkcyan", "#008080"],
+	["darkgray", "#808080"],
+	["darkgrey", "#808080"],
+	["darkgreen", "#008000"],
+	["darkmagenta", "#800080"],
+	["darkred", "#800000"],
+	["darkyellow", "#808000"],
+	["gray", "#808080"],
+	["grey", "#808080"],
+	["green", "#00ff00"],
+	["lightgray", "#c0c0c0"],
+	["lightgrey", "#c0c0c0"],
+	["magenta", "#ff00ff"],
+	["red", "#ff0000"],
+	["silver", "#c0c0c0"],
+	["white", "#ffffff"],
+	["yellow", "#ffff00"]
+]);
+const DOC_CUSTOM_PROPERTIES = {
+	"--doc-canvas": DOC_CANVAS,
+	"--doc-canvas-text": DOC_CANVAS_TEXT,
+	"--suggestion-color": SUGGESTION_COLOR
+};
+const HEX_PATTERN = /^#?(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/iu;
+const RGB_PATTERN = /^rgba?\(\s*([\d.]+%?)\s*[, ]\s*([\d.]+%?)\s*[, ]\s*([\d.]+%?)\s*(?:[,/]\s*([\d.]+%?)\s*)?\)$/iu;
+const VAR_PATTERN = /^var\(\s*(--[\w-]+)\s*(?:,\s*(.+))?\)$/iu;
+const clampChannel = (value) => Math.min(255, Math.max(0, Math.round(value)));
+const clampAlpha = (value) => Math.min(1, Math.max(0, value));
+const parseHex = (raw) => {
+	const hex = raw.replace(/^#/u, "");
+	const expand = (part) => Number.parseInt(part.repeat(2), 16);
+	if (hex.length === 3 || hex.length === 4) return {
+		r: expand(hex[0]),
+		g: expand(hex[1]),
+		b: expand(hex[2]),
+		a: hex.length === 4 ? expand(hex[3]) / 255 : 1
+	};
+	if (hex.length === 6 || hex.length === 8) return {
+		r: Number.parseInt(hex.slice(0, 2), 16),
+		g: Number.parseInt(hex.slice(2, 4), 16),
+		b: Number.parseInt(hex.slice(4, 6), 16),
+		a: hex.length === 8 ? Number.parseInt(hex.slice(6, 8), 16) / 255 : 1
+	};
+};
+const parseComponent = (raw, scale) => raw.endsWith("%") ? Number.parseFloat(raw) / 100 * scale : Number.parseFloat(raw);
+const parseRgb = (raw) => {
+	const match = RGB_PATTERN.exec(raw);
+	if (!match) return;
+	const r = clampChannel(parseComponent(match[1], 255));
+	const g = clampChannel(parseComponent(match[2], 255));
+	const b = clampChannel(parseComponent(match[3], 255));
+	const alphaRaw = match[4];
+	return {
+		r,
+		g,
+		b,
+		a: alphaRaw === void 0 ? 1 : clampAlpha(parseComponent(alphaRaw, 1))
+	};
+};
+/**
+* Resolve an authored CSS colour. Returns `undefined` for a value this module
+* cannot turn into concrete channels (`color-mix()`, `oklch()`, an unknown
+* name) so the caller can report it rather than paint a guess.
+*/
+const parseDisplayColor = (color) => {
+	if (color === void 0) return;
+	const trimmed = color.trim();
+	if (trimmed.length === 0) return;
+	const lower = trimmed.toLowerCase();
+	if (lower === "transparent" || lower === "none") return TRANSPARENT;
+	if (AUTOMATIC_COLOR_VALUES.has(lower)) return DOC_CANVAS_TEXT;
+	const varMatch = VAR_PATTERN.exec(trimmed);
+	if (varMatch) {
+		const known = DOC_CUSTOM_PROPERTIES[varMatch[1].toLowerCase()];
+		if (known) return known;
+		return parseDisplayColor(varMatch[2]);
+	}
+	const named = NAMED_COLORS.get(lower);
+	if (named !== void 0) return parseHex(named);
+	if (HEX_PATTERN.test(trimmed)) return parseHex(trimmed);
+	return parseRgb(lower);
+};
+//#endregion
+export { DOC_CANVAS, DOC_CANVAS_TEXT, SUGGESTION_COLOR, TRANSPARENT, parseDisplayColor };

package/dist/display-list/build/floatingImages.d.ts

@@ -0,0 +1,24 @@
+import { ImageRun, Page, ParagraphBlock } from "../../layout-engine/types.js";
+import { PageGeometry } from "../../layout-painter/anchoredImagePosition.js";
+import { DisplayPrimitive } from "../types.js";
+import { BuildContext } from "./buildContext.js";
+//#region src/display-list/build/floatingImages.d.ts
+declare const pageGeometryOf: (page: Page) => PageGeometry;
+type FloatingImagePlacement = {
+  readonly run: ImageRun;
+  /** `w:wrap behind` paints under the body text; everything else paints over it. */
+  readonly behindDoc: boolean;
+  readonly primitives: readonly DisplayPrimitive[];
+};
+type CollectFloatingImagesOptions = {
+  readonly block: ParagraphBlock;
+  /** The paragraph fragment's y, page-absolute. */
+  readonly fragmentYPx: number;
+  readonly geometry: PageGeometry;
+  readonly context: BuildContext;
+  /** Runs already placed on this page, so a split paragraph cannot double-paint. */
+  readonly placed: Set<ImageRun>;
+};
+declare const collectFloatingImages: ({ block, fragmentYPx, geometry, context, placed }: CollectFloatingImagesOptions) => readonly FloatingImagePlacement[];
+//#endregion
+export { CollectFloatingImagesOptions, FloatingImagePlacement, collectFloatingImages, pageGeometryOf };

package/dist/display-list/build/floatingImages.js

@@ -0,0 +1,41 @@
+import { isFloatingImageRun } from "../../layout-engine/types.js";
+import { resolveAnchoredImagePosition } from "../../layout-painter/anchoredImagePosition.js";
+import { paintImage } from "./imagePrimitives.js";
+//#region src/display-list/build/floatingImages.ts
+const pageGeometryOf = (page) => ({
+	pageWidth: page.size.w,
+	pageHeight: page.size.h,
+	marginLeft: page.margins.left,
+	marginTop: page.margins.top,
+	marginRight: page.margins.right,
+	marginBottom: page.margins.bottom,
+	...page.authoredMargins === void 0 ? {} : { authoredMargins: page.authoredMargins },
+	contentWidth: page.size.w - page.margins.left - page.margins.right,
+	contentHeight: page.size.h - page.margins.top - page.margins.bottom
+});
+const collectFloatingImages = ({ block, fragmentYPx, geometry, context, placed }) => {
+	const placements = [];
+	for (const run of block.runs) {
+		if (run.kind !== "image" || !isFloatingImageRun(run) || placed.has(run)) continue;
+		placed.add(run);
+		const anchor = resolveAnchoredImagePosition(run, fragmentYPx - geometry.marginTop, geometry);
+		placements.push({
+			run,
+			behindDoc: run.wrapType === "behind",
+			primitives: paintImage({
+				source: run,
+				rect: {
+					xPx: geometry.marginLeft + anchor.x,
+					yPx: geometry.marginTop + anchor.y,
+					widthPx: run.width,
+					heightPx: run.height
+				},
+				context,
+				label: "floating image"
+			})
+		});
+	}
+	return placements;
+};
+//#endregion
+export { collectFloatingImages, pageGeometryOf };

package/dist/display-list/build/fontTable.d.ts

@@ -0,0 +1,31 @@
+import { EmbeddedFont } from "../../fonts/embeddedFonts.js";
+import { DisplayFontFace, DisplayFontRef } from "../types.js";
+import { FontStyle } from "../../layout-engine/measure/measureTypes.js";
+//#region src/display-list/build/fontTable.d.ts
+type FontFaceRequest = {
+  readonly fontFamily: string;
+  readonly alternateFontFamily?: string;
+  readonly bold?: boolean;
+  readonly italic?: boolean;
+  /**
+   * The style the run measures with. The face's font-box ratios come from the
+   * measurer, not from a table of our own, so a backend places a baseline
+   * where the engine placed it.
+   */
+  readonly measureStyle: FontStyle;
+};
+declare class FontTable {
+  private readonly faces;
+  private readonly indexByKey;
+  private readonly embeddedByKey;
+  /**
+   * `embeddedFonts` are the package's own faces (`fonts/embeddedFonts.ts`).
+   * Without them a face the measurer used but no host can supply travels as a
+   * family name a backend has no way to resolve.
+   */
+  constructor(embeddedFonts?: readonly EmbeddedFont[]);
+  intern({ fontFamily, alternateFontFamily, bold, italic, measureStyle }: FontFaceRequest): DisplayFontRef;
+  snapshot(): readonly DisplayFontFace[];
+}
+//#endregion
+export { FontFaceRequest, FontTable };

package/dist/display-list/build/fontTable.js

@@ -0,0 +1,97 @@
+import { ptToPx } from "../../layout-engine/measure/measureHelpers.js";
+import { getFontMetrics } from "../../layout-engine/measure/measureProvider.js";
+import { resolveFontFamily } from "../../utils/fontResolver.js";
+//#region src/display-list/build/fontTable.ts
+const CSS_NORMAL_WEIGHT = 400;
+const CSS_BOLD_WEIGHT = 700;
+const GENERIC_FAMILIES = {
+	serif: "serif",
+	"sans-serif": "sans-serif",
+	monospace: "monospace",
+	cursive: "cursive",
+	fantasy: "fantasy"
+};
+const DEFAULT_GENERIC = "sans-serif";
+const splitFallbackStack = (cssFallback) => cssFallback.split(",").map((entry) => entry.trim().replace(/^["']|["']$/gu, ""));
+/**
+* The category `resolveFontFamily` chose. It is the last CSS generic in the
+* stack it built, which is where `detectFontCategory` puts it; reading it back
+* is cheaper and less brittle than re-deriving the category from the name.
+*/
+const genericOf = (stack) => {
+	for (let index = stack.length - 1; index >= 0; index -= 1) {
+		const generic = GENERIC_FAMILIES[stack[index].toLowerCase()];
+		if (generic !== void 0) return generic;
+	}
+	return DEFAULT_GENERIC;
+};
+const faceKey = (family, weight, italic) => `${family.toLowerCase()} ${weight} ${italic ? "i" : "r"}`;
+/**
+* Package faces keyed by every family name a run can resolve to.
+*
+* `resolveFontFamily` substitutes the scoped `folio-embedded-{nonce}-{name}`
+* family only while the document's embedded-family map is installed; a build
+* that never installed it resolves the same run to the authored name. Both
+* names therefore key the same face, and the bytes are interned by id so one
+* face's binary appears once however many names reach it.
+*/
+const indexEmbeddedFonts = (faces) => {
+	const byId = /* @__PURE__ */ new Map();
+	const byKey = /* @__PURE__ */ new Map();
+	for (const face of faces) {
+		const id = `${face.family}:${face.weight}:${face.style}`;
+		const embedded = byId.get(id) ?? {
+			id,
+			bytes: face.bytes
+		};
+		byId.set(id, embedded);
+		const italic = face.style === "italic";
+		byKey.set(faceKey(face.family, face.weight, italic), embedded);
+		byKey.set(faceKey(face.originalFamily, face.weight, italic), embedded);
+	}
+	return byKey;
+};
+var FontTable = class {
+	faces = [];
+	indexByKey = /* @__PURE__ */ new Map();
+	embeddedByKey;
+	/**
+	* `embeddedFonts` are the package's own faces (`fonts/embeddedFonts.ts`).
+	* Without them a face the measurer used but no host can supply travels as a
+	* family name a backend has no way to resolve.
+	*/
+	constructor(embeddedFonts = []) {
+		this.embeddedByKey = indexEmbeddedFonts(embeddedFonts);
+	}
+	intern({ fontFamily, alternateFontFamily, bold, italic, measureStyle }) {
+		const stack = splitFallbackStack(resolveFontFamily(fontFamily, alternateFontFamily).cssFallback);
+		const family = stack.at(0) ?? fontFamily;
+		const weight = bold ? CSS_BOLD_WEIGHT : CSS_NORMAL_WEIGHT;
+		const isItalic = italic === true;
+		const key = faceKey(family, weight, isItalic);
+		const existing = this.indexByKey.get(key);
+		if (existing !== void 0) return existing;
+		const metrics = getFontMetrics(measureStyle);
+		const fontSizePx = ptToPx(measureStyle.fontSize ?? metrics.fontSize);
+		const scale = fontSizePx > 0 ? 1 / fontSizePx : 0;
+		const index = this.faces.length;
+		const embedded = this.embeddedByKey.get(key);
+		this.faces.push({
+			family,
+			weight,
+			italic: isItalic,
+			generic: genericOf(stack),
+			fallbacks: stack.slice(1).filter((entry) => GENERIC_FAMILIES[entry.toLowerCase()] === void 0),
+			fontBoxAscentRatio: metrics.fontBoxAscent * scale,
+			fontBoxDescentRatio: metrics.fontBoxDescent * scale,
+			...embedded === void 0 ? {} : { embedded }
+		});
+		this.indexByKey.set(key, index);
+		return index;
+	}
+	snapshot() {
+		return this.faces;
+	}
+};
+//#endregion
+export { FontTable };

package/dist/display-list/build/furniture.d.ts

@@ -0,0 +1,86 @@
+import { document_d_exports } from "../../types/document.js";
+import { FootnoteContent, HeaderFooterContent, Page } from "../../layout-engine/types.js";
+import { DisplayPrimitive } from "../types.js";
+import { BuildContext } from "./buildContext.js";
+import { PageBorders } from "./pageBorderPrimitives.js";
+import { PageComposer } from "./regions.js";
+//#region src/display-list/build/furniture.d.ts
+/**
+ * Everything the builder cannot derive from a `Layout`. Every field is
+ * optional, and every one of them means the same thing when absent: the
+ * construct is not painted, and it is reported wherever the layout or the
+ * caller's `documentFeatures` shows the document had one.
+ */
+type PageFurnitureInputs = {
+  /**
+   * `w:pgBorders` for the section. Absent: no border is painted, and the gap is
+   * reported unless `documentFeatures` says the document has none.
+   */
+  readonly pageBorders?: PageBorders;
+  /** Resolves `w:themeColor` on a page border. Absent: authored colours only. */
+  readonly theme?: document_d_exports.Theme | null;
+  /**
+   * The watermark for every page with no more specific match in
+   * {@link watermarkByHeaderRId}. Absent with that map also absent: no
+   * watermark is painted, and the gap is reported unless `documentFeatures`
+   * says the document has none.
+   */
+  readonly watermark?: document_d_exports.Watermark;
+  /**
+   * Per-header-rId watermarks, authoritative when present: a page whose active
+   * header carries none paints none, rather than inheriting {@link watermark}.
+   */
+  readonly watermarkByHeaderRId?: ReadonlyMap<string, document_d_exports.Watermark>;
+  /**
+   * Resolved `data:` source for a picture watermark. Absent: the picture is
+   * reported, because the relationship id → asset mapping belongs to the
+   * package layer and the builder does no I/O.
+   */
+  readonly watermarkImageSrc?: string;
+  /**
+   * The header for every page, or for pages 2+ when `titlePg` is set. Absent
+   * with the per-rId map also absent: no header is painted, and a page whose
+   * `headerFooterRefs` name one says so through `unsupported`.
+   */
+  readonly headerContent?: HeaderFooterContent;
+  /** The footer counterpart of {@link headerContent}. */
+  readonly footerContent?: HeaderFooterContent;
+  /** Headers by part relationship id, for section-scoped and even/odd headers. */
+  readonly headerContentByRId?: ReadonlyMap<string, HeaderFooterContent>;
+  /** Footers by part relationship id. */
+  readonly footerContentByRId?: ReadonlyMap<string, HeaderFooterContent>;
+  /** The first page's header when `titlePg` is set and the layout carries no section refs. */
+  readonly firstPageHeaderContent?: HeaderFooterContent;
+  /** The first page's footer when `titlePg` is set and the layout carries no section refs. */
+  readonly firstPageFooterContent?: HeaderFooterContent;
+  /** `w:titlePg` for the first section. Absent: the first page is not special-cased. */
+  readonly titlePg?: boolean;
+  /** Overrides `w:pgMar`'s `w:header`. Absent: the page's own margin is used. */
+  readonly headerDistancePx?: number;
+  /** Overrides `w:pgMar`'s `w:footer`. Absent: the page's own margin is used. */
+  readonly footerDistancePx?: number;
+  /**
+   * Footnote bodies by `w:footnote` id. Absent, or missing an id a page
+   * carries: the band still opens with its rule and reserves the paginator's
+   * height, and the missing bodies are reported.
+   */
+  readonly footnoteContentById?: ReadonlyMap<number, FootnoteContent>;
+};
+/**
+ * Furniture split by where it sits in the page's paint order: `behind` goes
+ * under the body, `above` over it. `renderPage.ts` establishes both.
+ */
+type PageFurniturePrimitives = {
+  /** Painted under the body: a back page border, the watermark. */
+  readonly behind: readonly DisplayPrimitive[];
+  /** Painted over it, into the composer, so its regions nest. */
+  readonly above: (composer: PageComposer) => void;
+};
+type PaintPageFurnitureOptions = {
+  readonly page: Page;
+  readonly furniture: PageFurnitureInputs;
+  readonly context: BuildContext;
+};
+declare const paintPageFurniture: ({ page, furniture, context }: PaintPageFurnitureOptions) => PageFurniturePrimitives;
+//#endregion
+export { PageFurnitureInputs, PageFurniturePrimitives, PaintPageFurnitureOptions, paintPageFurniture };

package/dist/display-list/build/furniture.js

@@ -0,0 +1,98 @@
+import { applySectionHeaderFooterOptions, selectSectionHeaderFooterRIds } from "../../layout-painter/renderPage.js";
+import { paintHeaderFooter } from "./headerFooterPrimitives.js";
+import { paintPageBorders } from "./pageBorderPrimitives.js";
+import { paintFootnoteArea } from "./pageFurniture.js";
+import { UNSUPPORTED_CONSTRUCT } from "./unsupported.js";
+import { paintWatermark } from "./watermarkPrimitives.js";
+//#region src/display-list/build/furniture.ts
+const suppliesHeaderFooter = (furniture) => furniture.headerContent !== void 0 || furniture.footerContent !== void 0 || furniture.headerContentByRId !== void 0 || furniture.footerContentByRId !== void 0 || furniture.firstPageHeaderContent !== void 0 || furniture.firstPageFooterContent !== void 0;
+const suppliesWatermark = (furniture) => furniture.watermark !== void 0 || furniture.watermarkByHeaderRId !== void 0;
+/**
+* The header, footer and watermark this page paints, chosen by the painter's
+* own rule (`w:titlePg` first-page swap, `w:evenAndOddHeaders`, section-scoped
+* parts) rather than by a second implementation of it.
+*/
+const selectForPage = (page, furniture) => {
+	const source = {
+		...furniture.headerContent === void 0 ? {} : { headerContent: furniture.headerContent },
+		...furniture.footerContent === void 0 ? {} : { footerContent: furniture.footerContent },
+		...furniture.headerContentByRId === void 0 ? {} : { headerContentByRId: furniture.headerContentByRId },
+		...furniture.footerContentByRId === void 0 ? {} : { footerContentByRId: furniture.footerContentByRId },
+		...furniture.watermark === void 0 ? {} : { watermark: furniture.watermark },
+		...furniture.watermarkByHeaderRId === void 0 ? {} : { watermarkByHeaderRId: furniture.watermarkByHeaderRId }
+	};
+	const selected = { ...source };
+	if (applySectionHeaderFooterOptions(page, selected, source)) return selected;
+	if (furniture.titlePg !== true || page.number !== 1) return selected;
+	if (furniture.firstPageHeaderContent === void 0) delete selected.headerContent;
+	else selected.headerContent = furniture.firstPageHeaderContent;
+	if (furniture.firstPageFooterContent === void 0) delete selected.footerContent;
+	else selected.footerContent = furniture.firstPageFooterContent;
+	return selected;
+};
+/**
+* Name a header or footer the page asks for and the caller did not supply. A
+* backend cannot tell a page with no header from a page whose header never
+* reached the producer.
+*/
+const reportMissingStories = (page, furniture, selected, context) => {
+	if (page.headerFooterRefs === void 0) return;
+	if (!suppliesHeaderFooter(furniture)) {
+		context.unsupported.report(UNSUPPORTED_CONSTRUCT.headerFooterContent, context.pageIndex, "the page names header and footer parts, but no story content was supplied to the builder");
+		return;
+	}
+	const { headerRId, footerRId } = selectSectionHeaderFooterRIds(page);
+	const namesHeader = headerRId !== void 0;
+	const namesFooter = footerRId !== void 0;
+	const headerCarriedAWatermark = headerRId !== void 0 && furniture.watermarkByHeaderRId?.has(headerRId) === true;
+	if (namesHeader && !headerCarriedAWatermark && selected.headerContent === void 0) context.unsupported.report(UNSUPPORTED_CONSTRUCT.headerFooterContent, context.pageIndex, "the header part this page selects was not among the supplied stories");
+	if (namesFooter && selected.footerContent === void 0) context.unsupported.report(UNSUPPORTED_CONSTRUCT.headerFooterContent, context.pageIndex, "the footer part this page selects was not among the supplied stories");
+};
+const paintPageFurniture = ({ page, furniture, context }) => {
+	const selected = selectForPage(page, furniture);
+	reportMissingStories(page, furniture, selected, context);
+	const borders = furniture.pageBorders === void 0 ? [] : paintPageBorders({
+		page,
+		borders: furniture.pageBorders,
+		...furniture.theme === void 0 ? {} : { theme: furniture.theme },
+		context
+	});
+	const paintsBorderBehind = furniture.pageBorders?.zOrder === "back";
+	const watermark = !suppliesWatermark(furniture) || selected.watermark === void 0 ? [] : paintWatermark({
+		page,
+		watermark: selected.watermark,
+		...furniture.watermarkImageSrc === void 0 ? {} : { imageSrc: furniture.watermarkImageSrc },
+		context
+	});
+	const above = (composer) => {
+		paintFootnoteArea({
+			composer,
+			page,
+			context,
+			...furniture.footnoteContentById === void 0 ? {} : { contentById: furniture.footnoteContentById }
+		});
+		if (selected.headerContent !== void 0) paintHeaderFooter({
+			composer,
+			page,
+			section: "header",
+			content: selected.headerContent,
+			...furniture.headerDistancePx === void 0 ? {} : { distancePx: furniture.headerDistancePx },
+			context
+		});
+		if (selected.footerContent !== void 0) paintHeaderFooter({
+			composer,
+			page,
+			section: "footer",
+			content: selected.footerContent,
+			...furniture.footerDistancePx === void 0 ? {} : { distancePx: furniture.footerDistancePx },
+			context
+		});
+		if (!paintsBorderBehind) composer.push(borders);
+	};
+	return {
+		behind: [...paintsBorderBehind ? borders : [], ...watermark],
+		above
+	};
+};
+//#endregion
+export { paintPageFurniture };

package/dist/display-list/build/glyphs.d.ts

@@ -0,0 +1,55 @@
+import { DisplayRunAdjustments } from "../types.js";
+import { FontStyle } from "../../layout-engine/measure/measureTypes.js";
+//#region src/display-list/build/glyphs.d.ts
+type Glyphs = {
+  readonly text: string;
+  readonly advancesPx: number[];
+  readonly widthPx: number;
+  /** Whether these advances were measured with kerning on. */
+  readonly kerning: boolean;
+  /** Whether they were measured as small capitals. */
+  readonly smallCaps: boolean;
+  /**
+   * What went into the advances beyond the glyphs' own widths. Absent when
+   * nothing did, which keeps the common run's primitive as small as it was.
+   */
+  readonly adjustments?: DisplayRunAdjustments;
+};
+type BuildGlyphsOptions = {
+  readonly text: string;
+  readonly style: FontStyle;
+  readonly allCaps: boolean;
+  /** Justification delta applied to every compressible space. */
+  readonly spaceDeltaPx: number;
+  /**
+   * A line-edge space run Word keeps addressable but paints with no advance
+   * (the painter zeroes the split-off span's font size instead).
+   */
+  readonly collapsed: boolean;
+};
+/**
+ * `measureRun` returns `charWidths` indexed by UTF-16 unit with the trailing
+ * unit of a surrogate pair set to 0, because that is what ProseMirror offsets
+ * need. The display list wants code points, so the pair folds into one entry.
+ * An uppercase transform that expands a code point (ß → SS) keeps the source
+ * advance on the first output code point and gives the rest zero, so the sum
+ * still equals what the measurer decided the line on.
+ */
+declare const buildGlyphs: (options: BuildGlyphsOptions) => Glyphs;
+/**
+ * Everything a measured run contributes to a `glyphRun`.
+ *
+ * One helper rather than three fields at each emission site: what went into the
+ * advances has to travel with them, and a call site that carried the advances
+ * and forgot the adjustments would silently paint a run the line was not fitted
+ * with.
+ */
+declare const glyphRunText: (glyphs: Glyphs) => {
+  adjustments?: DisplayRunAdjustments;
+  text: string;
+  advancesPx: number[];
+  kerning: boolean;
+  smallCaps: boolean;
+};
+//#endregion
+export { BuildGlyphsOptions, Glyphs, buildGlyphs, glyphRunText };

package/dist/display-list/build/glyphs.js

@@ -0,0 +1,103 @@
+import { measureRun, measureTextWidth } from "../../layout-engine/measure/measureProvider.js";
+import { FONT_KERNING_MODE, getFontKerningMode } from "../../layout-engine/measure/textMeasurementPolicy.js";
+import { getHorizontalScaleFactor } from "../../utils/horizontalScale.js";
+//#region src/display-list/build/glyphs.ts
+/**
+* Text → one advance per code point, taken from the measure seam.
+*
+* Shared by everything that paints glyphs (body lines, list markers, tab
+* leaders, watermark text) so no caller invents a width of its own: the numbers
+* here are the numbers line breaking and pagination were decided on.
+*/
+/**
+* `measureRun` returns `charWidths` indexed by UTF-16 unit with the trailing
+* unit of a surrogate pair set to 0, because that is what ProseMirror offsets
+* need. The display list wants code points, so the pair folds into one entry.
+* An uppercase transform that expands a code point (ß → SS) keeps the source
+* advance on the first output code point and gives the rest zero, so the sum
+* still equals what the measurer decided the line on.
+*/
+const buildGlyphs = (options) => {
+	const { text, style, allCaps, spaceDeltaPx, collapsed } = options;
+	const adjustments = adjustmentsOf(options);
+	const { charWidths } = measureRun(text, style);
+	const advancesPx = [];
+	let painted = "";
+	let widthPx = 0;
+	let unitOffset = 0;
+	const shapedScale = shapedScaleOf(text, style, charWidths);
+	for (const char of text) {
+		const measured = (charWidths[unitOffset] ?? 0) * shapedScale;
+		unitOffset += char.length;
+		const advance = collapsed ? 0 : measured + (char === " " ? spaceDeltaPx : 0);
+		widthPx += advance;
+		let isFirst = true;
+		for (const outputChar of allCaps ? char.toLocaleUpperCase() : char) {
+			painted += outputChar;
+			advancesPx.push(isFirst ? advance : 0);
+			isFirst = false;
+		}
+	}
+	return {
+		text: painted,
+		advancesPx,
+		widthPx,
+		kerning: getFontKerningMode(style) === FONT_KERNING_MODE.enabled,
+		smallCaps: style.fontVariant === "small-caps",
+		...adjustments === void 0 ? {} : { adjustments }
+	};
+};
+/**
+* What every per-character width has to be multiplied by for the run to occupy
+* the width the line was fitted at.
+*
+* The two numbers come from the same measurer and differ by what shaping does
+* across a boundary: a pair that kerns or ligates is narrower in the string
+* than the two characters are apart. Line breaking used the string's width, so
+* that is the run's width, and advances that summed to anything else would
+* declare an extent no backend paints.
+*
+* Spread over every character rather than dropped on the last, because the
+* difference is not one boundary's: concentrating it would move the run's final
+* glyph by the whole of it.
+*/
+const shapedScaleOf = (text, style, charWidths) => {
+	const perCharacterPx = charWidths.reduce((total, width) => total + width, 0);
+	if (perCharacterPx <= 0) return 1;
+	return measureTextWidth(text, style) / perCharacterPx;
+};
+/**
+* The three adjustments named, or nothing when none applies.
+*
+* A collapsed run carries no advances at all, so it has nothing to reapply
+* either: naming a spacing on a run painted at zero width would have a backend
+* widen what the line was fitted without.
+*/
+const adjustmentsOf = ({ style, spaceDeltaPx, collapsed }) => {
+	const horizontalScale = getHorizontalScaleFactor(style.horizontalScale);
+	const letterSpacingPx = collapsed ? 0 : (style.letterSpacing ?? 0) * horizontalScale;
+	const wordSpacingPx = collapsed ? 0 : spaceDeltaPx;
+	if (letterSpacingPx === 0 && wordSpacingPx === 0 && horizontalScale === 1) return;
+	return {
+		letterSpacingPx,
+		horizontalScale,
+		wordSpacingPx
+	};
+};
+/**
+* Everything a measured run contributes to a `glyphRun`.
+*
+* One helper rather than three fields at each emission site: what went into the
+* advances has to travel with them, and a call site that carried the advances
+* and forgot the adjustments would silently paint a run the line was not fitted
+* with.
+*/
+const glyphRunText = (glyphs) => ({
+	text: glyphs.text,
+	advancesPx: glyphs.advancesPx,
+	kerning: glyphs.kerning,
+	smallCaps: glyphs.smallCaps,
+	...glyphs.adjustments === void 0 ? {} : { adjustments: glyphs.adjustments }
+});
+//#endregion
+export { buildGlyphs, glyphRunText };