@quario/pdf 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -7,6 +7,48 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.0] - 2026-09-01
+
+### Added
+
+- **The report default sets the document's face and base size.** A report's
+  top-level `style` replaces this target's own baseline, so its `size` scales
+  row heights and band gaps with the type rather than leaving them at a size
+  nothing is set in. It is the layer _under_ the band-role defaults: a report
+  declaring `size: 12` still renders its report header at 14, and an item's own
+  style wins over both.
+
+- **`uppercase` draws capitals.** With no text-transform to defer to, this
+  target capitalises the string before measuring it, so wrapping and column
+  widths are those of the text actually drawn. The mapping is Unicode default
+  case, never the host's locale, so output stays byte-reproducible.
+
+- **Splits lay out across the content width.** Each slot is measured and
+  wrapped inside its own share, all slots draw from a common top, and the
+  split takes the height of its tallest slot so the band below clears them
+  all. **A split is never broken across a page**: one that does not fit the
+  remaining height moves whole, exactly as an image does, and one taller than
+  any page renders in full past the bottom margin. The split's own style is
+  the layer under each slot's, and its `background` fills the whole split
+  behind them.
+
+### Changed
+
+- **A bare `Date` draws as ISO 8601 UTC, the same on every machine.** Cell
+  text and outline bookmark titles for `Date` values used `String(date)`,
+  which bakes the host's timezone and locale into the document — at odds with
+  this target's byte-reproducibility guarantee. Both now render through the
+  engine's shared display rule, so a `Date` group key titles its bookmark
+  with the same ISO text its cells draw.
+
+### Removed
+
+- **`options.baseSize`.** A document's type size is the document's own, so it
+  is the report's `style.size` — portable, travelling with the definition to
+  every target — rather than a host option one target honoured. Text with
+  nothing declared still renders at 10 points. Replace `pdf({ baseSize: 11 })`
+  with `"style": { "size": 11 }` on the report.
+
 ## [0.1.0] - 2026-08-27
 
 ### Added

package/README.md

@@ -89,7 +89,6 @@ Page geometry is target configuration, never schema:
 ```js
 {
   page: { size: "A4", margin: 54 },   // 'A4' | 'letter' | [width, height] in points
-  baseSize: 10,                       // base font size in points
   meta: { title, author, subject },   // optional /Info — strings only, never a date
   fonts: { Inter: { regular, bold, italic, boldItalic } },  // TrueType bytes
 }
@@ -97,8 +96,9 @@ Page geometry is target configuration, never schema:
 
 `size` defaults to `A4` (595.28 × 841.89 pt); an array is a custom `[width, height]` in points. An
 unknown size name is a definition error, thrown by the factory. `margin` applies to all four sides and defaults to 54
-(0.75 in). `baseSize` defaults to 10 and style `size` declarations override it per element; line
-leading is 1.4× a line's largest font size.
+(0.75 in). Text renders at 10pt when nothing declares a size: a document's type size is the
+document's own, so it is the report's `style.size`, not a host option. Line leading is 1.4× a line's
+largest font size.
 
 ## Layout
 

package/lib/balance.js

@@ -1,5 +1,5 @@
 // The one number a balanced region decides: how tall each of its strips is
-// (ADR 0020 — balancing is a strip height, not a pass). Pure arithmetic over
+// (ADR 0027 — balancing is a strip height, not a pass). Pure arithmetic over
 // what the buffer holds, so nothing here reaches a canvas or the band flow.
 //
 // Balancing by height alone under-fills, because most of what a region holds

package/lib/canvas.js

@@ -12,7 +12,7 @@
  * mid-measure and return a silently wrong height, so `newPage` throws there.
  */
 import { degrees, drawImage, drawText, rgb } from "pdf-lib";
-import { BLACK, shift } from "./style.js";
+import { BLACK, dressed, shift } from "./style.js";
 
 // The operator builder wants explicit rotation and skew; report text has none.
 let NO_TURN = degrees(0);
@@ -23,24 +23,32 @@ let NO_TURN = degrees(0);
 /** @typedef {import('pdf-lib').PDFFont} PDFFont */
 /** @typedef {import('pdf-lib').PDFName} PDFName */
 
-// The page box and the content box. Fixed for the whole render, from the moment
-// it commits to a page: the page bands are measured against the page box and
-// take their height off `top`/`bottom` through `adopt` below, while the first
-// page is still untouched.
+// The page box and the content box. Settled at `report-start` and fixed
+// thereafter: the geometry is the factory's and never moves, while `base` and
+// `style` take the report default one event into the render, before anything is
+// measured. The page bands are measured against the page box and take their
+// height off `top`/`bottom` through `adopt` below, while the first page is
+// still untouched.
 /**
+ * `style` is the report default — the outermost style layer, resolved once per
+ * render from `report-start` and carried here so a measuring canvas built off
+ * this frame reads the same one the drawing canvas does. Null when the report
+ * declares none.
+ *
  * @typedef {{ width: number, height: number, margin: number, base: number,
- *   content: number, top: number, bottom: number }} Frame
+ *   content: number, top: number, bottom: number, style: any }} Frame
  */
 
 // A frame from the page box and the base size: how `content`/`top`/`bottom`
 // fall out of a page and a margin is derived here, once, so no caller and no
 // suite has to restate it and drift from what a real render uses.
-/** @type {(width: number, height: number, margin: number, base: number) => Frame} */
-let frame = (width, height, margin, base) => ({
+/** @type {(width: number, height: number, margin: number, base: number, style?: any) => Frame} */
+let frame = (width, height, margin, base, style = null) => ({
   width,
   height,
   margin,
   base,
+  style,
   content: width - 2 * margin,
   top: height - margin,
   bottom: margin,
@@ -84,17 +92,11 @@ let GREY = rgb(0.5, 0.5, 0.5);
 // line's ascender (the face metric already measured for baseline placement).
 // Empty lines (no width) draw nothing. Shared by the drawing adapter and the
 // layout recorder so both exercise the same path.
-/** @type {{ flag: 'underline' | 'strikethrough', at: (baseline: number, asc: number) => number }[]} */
-let DECO = [
-  { flag: "underline", at: (baseline, asc) => baseline - asc * 0.12 },
-  { flag: "strikethrough", at: (baseline, asc) => baseline + asc * 0.35 },
-];
-
 /** @type {(line: Line) => any} */
 let ink = (line) => (line.pieces[0] && line.pieces[0].color) || BLACK;
 
 /** @type {(line: Line) => boolean} */
-let wantsDeco = (line) => !!(line.w && (line.underline || line.strikethrough));
+let wantsDeco = (line) => !!line.w && dressed(line);
 
 /**
  * @type {(stroke: (x1: number, x2: number, y: number, thickness: number, color: any) => void,
@@ -105,9 +107,8 @@ let decorateLine = (stroke, line, left, baseline) => {
   let thickness = Math.max(line.asc / 12, 0.5);
   let right = left + line.w;
   let color = ink(line);
-  for (let { flag, at } of DECO) {
-    if (line[flag]) stroke(left, right, at(baseline, line.asc), thickness, color);
-  }
+  if (line.underline) stroke(left, right, baseline - line.asc * 0.12, thickness, color);
+  if (line.strikethrough) stroke(left, right, baseline + line.asc * 0.35, thickness, color);
 };
 
 /**

package/lib/fonts.js

@@ -49,8 +49,6 @@ let useFontkit = async (doc) => {
   doc.registerFontkit(fontkit);
 };
 
-let VARIANTS = ["regular", "bold", "italic", "boldItalic"];
-
 /** @type {(doc: any) => Promise<Record<string, any[]>>} */
 let embedBase = async (doc) => {
   /** @type {Record<string, any[]>} */
@@ -91,7 +89,8 @@ let familyOf = async (doc, name, def) => {
   let path = asFamily(name, def);
   /** @type {any[]} */
   let faces = [];
-  for (let variant of VARIANTS) faces.push(await embedVariant(doc, def, path, variant, faces));
+  for (let variant of ["regular", "bold", "italic", "boldItalic"])
+    faces.push(await embedVariant(doc, def, path, variant, faces));
   return faces;
 };
 

package/lib/image.js

@@ -18,9 +18,6 @@ let PER_PX = 72 / 96;
 /** @type {(bytes: Uint8Array, at: number) => number} */
 let word = (bytes, at) => (bytes[at] << 8) | bytes[at + 1];
 
-/** @type {(bytes: Uint8Array) => { w: number, h: number }} */
-let pngSize = (bytes) => ({ w: word(bytes, 18), h: word(bytes, 22) });
-
 /** @type {(code: number) => boolean} */
 let inSof = (code) => code >= 0xc0 && code <= 0xcf;
 
@@ -42,9 +39,6 @@ let jpegSize = (bytes) => {
   return { w: 0, h: 0 };
 };
 
-/** @type {(bytes: Uint8Array, format: string) => { w: number, h: number }} */
-let pixels = (bytes, format) => (format === "png" ? pngSize(bytes) : jpegSize(bytes));
-
 /**
  * The image's intrinsic size in points. The format is the engine's sniff,
  * riding on the event, so nothing here decides it a second time.
@@ -54,7 +48,8 @@ let pixels = (bytes, format) => (format === "png" ? pngSize(bytes) : jpegSize(by
  * @returns {{ w: number, h: number }} The size, in points.
  */
 export let intrinsic = (bytes, format) => {
-  let { w, h } = pixels(bytes, format);
+  // A PNG carries the two numbers in its IHDR at a fixed offset.
+  let { w, h } = format === "png" ? { w: word(bytes, 18), h: word(bytes, 22) } : jpegSize(bytes);
   // The engine vouched for the magic numbers, not for the rest of the file:
   // a truncated header reaches here as a zero, and failing loudly beats
   // drawing an image with no size (SCHEMA.md, "Image item").

package/lib/index.d.ts

@@ -26,8 +26,6 @@ export interface PdfFontFamily {
 /** Host controls, taken and validated at the factory call. */
 export interface PdfOptions {
   page?: PdfPage;
-  /** Base font size in points — the size styles override per element. Default `10`. */
-  baseSize?: number;
   meta?: PdfMeta;
   /**
    * TrueType families to embed (subset), selected from styles by

package/lib/index.js

@@ -36,29 +36,17 @@ let err = (msg) => {
   throw Error(msg);
 };
 
-/** @type {(value: any) => boolean} */
-let finite = (value) => typeof value === "number" && Number.isFinite(value);
-
 /** @type {(value: number) => boolean} */
 let positive = (value) => Number.isFinite(value) && value > 0;
 
-/** @type {(options: any) => any} */
-let pageOf = (options) => options?.page ?? {};
-
-/** @type {(options: any) => { meta: any, fonts: any }} */
-let host = (options) => ({ meta: options?.meta, fonts: options?.fonts });
-
 /** @type {(size: any) => any} */
-let named = (size) => {
+let named = (size = "A4") => {
   let dimensions = Array.isArray(size) ? size : SIZES[size];
   // oxlint-disable-next-line no-unused-expressions
   dimensions || err('options.page.size: unknown page size "' + size + '"');
   return dimensions;
 };
 
-/** @type {(page: any) => any} */
-let pageSize = (page) => named(page.size ?? "A4");
-
 /** @type {(dimensions: any) => { width: number, height: number }} */
 let pair = (dimensions) => {
   let width = +dimensions[0],
@@ -69,26 +57,19 @@ let pair = (dimensions) => {
   return { width, height };
 };
 
-/** @type {(page: any) => any} */
-let marginArg = (page) => page.margin ?? 54;
-
 /** @type {(margin: any, width: number, height: number) => number} */
-let marginOf = (margin, width, height) => {
-  let fits = finite(margin) && margin >= 0 && 2 * margin < Math.min(width, height);
+let marginOf = (margin = 54, width, height) => {
+  let fits = Number.isFinite(margin) && margin >= 0 && 2 * margin < Math.min(width, height);
   // oxlint-disable-next-line no-unused-expressions
   fits || err("options.page.margin: expected a non-negative number smaller than half the page");
   return margin;
 };
 
-/** @type {(options: any) => any} */
-let baseArg = (options) => options?.baseSize ?? 10;
-
-/** @type {(base: any) => number} */
-let baseOf = (base) => {
-  // oxlint-disable-next-line no-unused-expressions
-  (finite(base) && base > 0) || err("options.baseSize: expected a positive number of points");
-  return base;
-};
+// This target's baseline type size. Not a host option: a document's type size
+// is the document's own, so it is `style.size` on the report and the number
+// here is only what text renders at when nothing declares one. The XLSX target
+// carries the same 10 for the same reason (docs/adr/0014, docs/adr/0033).
+let BASE = 10;
 
 // The page box and the content box in one, settled here beside the validation
 // that produced them. This frame never moves at all: it serves every render the
@@ -97,30 +78,27 @@ let baseOf = (base) => {
 // band flow's, off that render's own canvas.
 /** @type {(options: any) => import('./canvas.js').Frame} */
 let geometry = (options) => {
-  let page = pageOf(options);
-  let { width, height } = pair(pageSize(page));
-  return frame(width, height, marginOf(marginArg(page), width, height), baseOf(baseArg(options)));
-};
-
-let META = [
-  ["title", "setTitle"],
-  ["author", "setAuthor"],
-  ["subject", "setSubject"],
-];
-
-/** @type {(doc: any, meta: any, entry: string[]) => void} */
-let field = (doc, meta, [key, method]) => {
-  if (typeof meta[key] === "string") doc[method](meta[key]);
+  let { page = {} } = options ?? {};
+  let { width, height } = pair(named(page.size));
+  return frame(width, height, marginOf(page.margin, width, height), BASE);
 };
 
 // Optional document information. Never a date: pdf-lib stamps the current time
 // unless told otherwise, and a timestamp would make the same input render
-// different bytes on every run.
+// different bytes on every run. Each key names the pdf-lib setter it feeds,
+// here rather than in a table, and a value of any other shape is left off.
 /** @type {(doc: any, meta: any) => void} */
 let describe = (doc, meta) => {
   doc.setCreationDate(new Date(0));
   doc.setModificationDate(new Date(0));
-  if (meta) for (let entry of META) field(doc, meta, entry);
+  let field = (/** @type {string} */ method, /** @type {any} */ value) => {
+    if (typeof value === "string") doc[method](value);
+  };
+  if (meta) {
+    field("setTitle", meta.title);
+    field("setAuthor", meta.author);
+    field("setSubject", meta.subject);
+  }
 };
 
 /** @type {(canvas: import('./canvas.js').Drawing, draw: (i: number) => void) => Promise<void>} */
@@ -132,9 +110,6 @@ let overPages = async (canvas, draw) => {
   }
 };
 
-/** @type {(opening: any) => { bands: any, marking: any }} */
-let openingOf = (opening) => ({ bands: opening?.page, marking: opening?.marking });
-
 /** @type {(canvas: import('./canvas.js').Drawing, bands: any,
  *   pages: { number: number, total: number }[]) => Promise<void>} */
 let furnish = async (canvas, bands, pages) => {
@@ -162,7 +137,8 @@ let markPages = async (canvas, marking) => {
  */
 export function pdf(options) {
   let geo = geometry(options);
-  let { meta, fonts: custom } = host(options);
+  let meta = options?.meta,
+    custom = options?.fonts;
   /** @type {(stream: any) => (data?: any) => Promise<Uint8Array>} */
   let compile = (stream) => async (data) => {
     let doc = await PDFDocument.create();
@@ -179,12 +155,13 @@ export function pdf(options) {
     // page bands off it — and hands it back with the marks. What is left on it
     // is what the passes below want: the band closures to render per page, and
     // the marking's wording to stamp.
+    // Null when nothing settled one, which reads as a document owing neither.
     let { marks, opening, pages } = finish();
-    let { bands, marking } = openingOf(opening);
+    opening = opening || {};
     // The passes below run over the finished pages, not the stream — no walk
     // at all — so they open each page themselves and breathe on their own
     // rather than through the driver.
-    await furnish(canvas, bands, pages);
+    await furnish(canvas, opening.page, pages);
     // Every image the walk and the furniture pass placed, embedded and drawn
     // now: a walk handler cannot await, and the page bands' images are not
     // placed until the pass above has run. Before the marking, so an image can
@@ -193,7 +170,7 @@ export function pdf(options) {
     // The unlicensed marking goes on last, over content and page furniture
     // alike, once per page (LICENSE section 6). Its wording rode in on
     // `report-start`; only the placement is this target's.
-    await markPages(canvas, marking);
+    await markPages(canvas, opening.marking);
     outline(doc, marks, canvas.refs);
     return doc.save();
   };

package/lib/layout.js

@@ -21,11 +21,11 @@
  * document's bands claim before anything is placed, and where they are drawn
  * on each finished page once the count is known.
  */
-import { isReportBand, text } from "quario";
+import { display, isReportBand, text } from "quario";
 import { balance } from "./balance.js";
 import { adopt, frame, measuring } from "./canvas.js";
 import { intrinsic } from "./image.js";
-import { BAND, GUTTER, LEAD, PADX, PADY, col, merge, roled, shift } from "./style.js";
+import { BAND, GUTTER, LEAD, PADX, PADY, col, roled, shift, sizeOf, stack } from "./style.js";
 import { atoms, dress, heightOf, wrap } from "./text.js";
 
 /** @typedef {import('./balance.js').Unit} Unit */
@@ -57,27 +57,38 @@ import { atoms, dress, heightOf, wrap } from "./text.js";
  * @typedef {{ bytes: Uint8Array, format: string, w: number, h: number }} Picture
  */
 /**
- * @typedef {{ lines: Line[], picture?: Picture, bg: string | null, align: any,
- *   h: number }} Block
+ * `align` is absent on a split, which has none of its own: alignment is a
+ * slot's, reached through the style layering.
+ * @typedef {{ lines: Line[], picture?: Picture, parts?: SlotPart[],
+ *   bg: string | null, align?: any, h: number }} Block
+ */
+/**
+ * One slot of a split, as laid out: the block it drew to and the width it was
+ * measured at. There is no offset — a slot's is the sum of the widths before
+ * it, which `drawSplit` accumulates as it walks them.
+ * @typedef {{ block: Block, w: number }} SlotPart
  */
 
 // How `fit` sizes a picture against the width it has: `natural` is the
 // image's own size in points, never wider than the content box; `width`
 // scales to the content box either way. The ratio is kept in both, so a
 // height is never anything but the width's consequence.
-/** @type {(canvas: Canvas, event: any, avail: number) => Picture} */
-let pictureOf = (canvas, event, avail) => {
+/** @type {(event: any, avail: number) => Picture} */
+let pictureOf = (event, avail) => {
   let { w, h } = intrinsic(event.bytes, event.format);
   let width = event.fit === "width" ? avail : Math.min(w, avail);
   return { bytes: event.bytes, format: event.format, w: width, h: (h * width) / w };
 };
 
-/** @type {(canvas: Canvas, event: any, avail: number) => Block} */
-let blockOf = (canvas, event, avail) => {
-  let style = merge(null, event.style);
+// `under` is the enclosing style a slot's own layers over — a split's, when
+// this is one of its slots. Null everywhere else, where nothing encloses.
+/** @type {(canvas: Canvas, event: any, avail: number, under?: any) => Block} */
+let blockOf = (canvas, event, avail, under = null) => {
+  let style = stack(canvas, under, event.style);
   let bg = col(style.background);
+  if (event.type === "split") return splitBlock(canvas, event, avail, style, bg);
   if (event.type === "image") {
-    let picture = pictureOf(canvas, event, avail);
+    let picture = pictureOf(event, avail);
     return { lines: [], picture, bg, align: style.align, h: picture.h };
   }
   let lines = dress(wrap(canvas, atoms(canvas, event.tokens, style), Math.max(avail, 1)), style);
@@ -118,9 +129,99 @@ let drawLines = (canvas, block, x, avail) => {
   canvas.fresh = false;
 };
 
+// An authored share fixes its slot; the width-less ones divide what is left,
+// evenly. Evenly rather than by natural width, because a split is a line of
+// furniture whose geometry should read off the document — the same answer the
+// HTML target's `flex:1` gives, so one definition places alike in both.
+// Each slot is measured at its own share and drawn from a common top, so the
+// split is as tall as its tallest slot and the line's geometry does not move
+// with the data. The split's own declarations are the layer under each slot's,
+// so a split styled `bold` reads the same here as it does through CSS
+// inheritance in the HTML target and the `under` layer in XLSX. It has no
+// `align` of its own: alignment is a slot's, reached through that layering.
+/**
+ * @type {(canvas: Canvas, event: any, avail: number, style: any,
+ *   bg: string | null) => Block}
+ */
+let splitBlock = (canvas, event, avail, style, bg) => {
+  let widths = slotWidths(event.slots, avail);
+  /** @type {SlotPart[]} */
+  let parts = [];
+  let h = 0;
+  for (let [i, slot] of event.items.entries()) {
+    let block = blockOf(canvas, slot, Math.max(widths[i], 1), style);
+    if (block.h > h) h = block.h;
+    parts.push({ block, w: widths[i] });
+  }
+  return { lines: [], parts, bg, h };
+};
+
+/** @type {(slots: { width?: number }[], avail: number) => number[]} */
+let slotWidths = (slots, avail) => {
+  let autos = 0,
+    spent = 0;
+  /** @type {(number | null)[]} */
+  let fixed = slots.map(({ width }) => {
+    // Bound to a local first: `Number.isFinite` does not narrow a property.
+    if (width === undefined || !Number.isFinite(width)) return (autos++, null);
+    let share = (width / 100) * avail;
+    spent += share;
+    return share;
+  });
+  let each = autos ? Math.max(avail - spent, 0) / autos : 0;
+  return fixed.map((width) => width ?? each);
+};
+
+// A split reaches this target as a bracket around ordinary item and image
+// events. Folding it into one event is what lets the rest of the target treat
+// it as a single block -- measured, kept together, and paged by exactly the
+// machinery every other block goes through. Stateful rather than a transform
+// over an array, because the body walk is streaming; the page-band pass drives
+// the same folder over its own list, so the two cannot drift.
+// The event types that become a `Block`. They are also exactly the three the
+// split folder owns: item and image reach `route` through it, so a slot's are
+// collected rather than placed, and `split` is minted by the folder and never
+// arrives from the stream at all.
+let BLOCKS = new Set(["item", "image", "split"]);
+
+/** @type {(emit: (event: any) => void) => (event: any) => void} */
+let splitFolder = (emit) => {
+  /** @type {{ event: any, items: any[] } | null} */
+  let bracket = null;
+  // The engine emits the bracket as one array, so `split-end` always has its
+  // opening and this never reads a null.
+  let close = () => {
+    let { event, items } = /** @type {{ event: any, items: any[] }} */ (bracket);
+    bracket = null;
+    emit({ type: "split", role: event.role, style: event.style, slots: event.slots, items });
+  };
+  return (event) => {
+    if (event.type === "split-start") bracket = { event, items: [] };
+    else if (event.type === "split-end") close();
+    else if (bracket) bracket.items.push(event);
+    else emit(event);
+  };
+};
+
+/** @type {(canvas: Canvas, block: Block, x: number, avail: number) => void} */
+let drawSplit = (canvas, block, x, avail) => {
+  if (block.bg) canvas.rect(block.bg, x, canvas.y - block.h, avail, block.h);
+  let top = canvas.y;
+  let at = x;
+  for (let part of block.parts || []) {
+    canvas.y = top;
+    drawBlock(canvas, part.block, at, part.w);
+    at += part.w;
+  }
+  // The split takes its own height whatever the slots took, so a short slot
+  // beside a wrapped one does not pull the band up.
+  canvas.y = top - block.h;
+  canvas.fresh = false;
+};
+
 /** @type {(canvas: Canvas, block: Block, x: number, avail: number) => void} */
 let drawBlock = (canvas, block, x, avail) =>
-  (block.picture ? drawPicture : drawLines)(canvas, block, x, avail);
+  (block.parts ? drawSplit : block.picture ? drawPicture : drawLines)(canvas, block, x, avail);
 
 // A region is a run of strips: what a columned node's content flows down
 // (CONTEXT.md "Strip"). `index` is the strip being filled, `top` the y every
@@ -229,17 +330,23 @@ let fitLines = (canvas, block, i, floor, fresh) => {
 /** @type {(canvas: Canvas, block: Block, floor: number) => boolean} */
 let whole = (canvas, block, floor) => canvas.y - block.h >= floor;
 
-// An image is never split: it moves whole to a fresh column. One that no
-// column can hold is scaled down to the one it lands on -- obeying the
-// guarantee literally would mean dropping it (SCHEMA.md, best-effort). It is
-// the unsplittable block, so a balanced floor never cuts it: only the page's
-// own floor can shrink it.
+// The unsplittable blocks -- a picture and a split -- move whole to a fresh
+// column rather than breaking, so a balanced floor never cuts one: only the
+// page's own floor bears on it. A picture that no column can hold is scaled
+// down to the one it lands on, since obeying the guarantee literally would
+// mean dropping it (SCHEMA.md, best-effort); a split has nothing to scale, so
+// one taller than any column renders in full past the bottom margin, the
+// posture a paragraph line taller than a page already has.
+//
+// A split also *cannot* be sliced: its own `lines` are empty -- the content
+// lives in its slots -- so the slicing path would draw nothing and leave the
+// cursor where it stood, taking everything after it down with it.
 /** @type {(state: Flow, block: Block) => void} */
-let placePicture = (state, block) => {
+let placeWhole = (state, block) => {
   advance(state);
   let canvas = state.canvas;
   let room = canvas.y - canvas.bottom;
-  if (block.h > room) shrink(block, room);
+  if (block.picture && block.h > room) shrink(block, room);
   drawBlock(canvas, block, originOf(state), widthOf(state));
 };
 
@@ -287,10 +394,16 @@ let item = (state, event, measured = null) => {
   let block = measured || blockOf(canvas, event, avail);
   // Whole block fits where it stands: one piece, no slicing.
   if (whole(canvas, block, floorOf(state))) return drawBlock(canvas, block, originOf(state), avail);
-  if (block.picture) return placePicture(state, block);
-  slice(state, block);
+  overflow(state, block);
 };
 
+// What a block does when it does not fit where it stands. A picture and a
+// split never break -- each moves whole to a fresh column; anything else flows
+// down it, breaking where `fitLines` says.
+/** @type {(state: Flow, block: Block) => void} */
+let overflow = (state, block) =>
+  block.picture || block.parts ? placeWhole(state, block) : slice(state, block);
+
 // The height a page turn carries over: the drawn headers of the groups still
 // open, which every page their instances continue onto replays. Computed rather
 // than kept — a stored total is a second copy of `open` that can drift from it.
@@ -481,9 +594,16 @@ let UNITS = {
   },
   row: restated,
   "total-row": restated,
-  image: (entry) => unsplit(entry.h, entry.h),
+  image: unbroken,
+  split: unbroken,
 };
 
+// An unsplittable block owes a strip nothing but its own height.
+/** @type {(entry: any) => Unit} */
+function unbroken(entry) {
+  return unsplit(entry.h, entry.h);
+}
+
 // A row opening a strip carries the column headings restated above it.
 /** @type {(entry: any, table: Restated) => Unit} */
 function restated(entry, table) {
@@ -664,7 +784,7 @@ let entryFor = (state, event, block, width) => {
 // decided anything. Events that are not blocks contribute an `estimate`.
 /** @type {(state: Flow, event: any, width: number) => Block | null} */
 let measureFor = (state, event, width) =>
-  event.type === "item" || event.type === "image" ? blockOf(state.canvas, event, width) : null;
+  BLOCKS.has(event.type) ? blockOf(state.canvas, event, width) : null;
 
 // Give every outline mark still waiting a position: where its content begins.
 /** @type {(state: Flow) => void} */
@@ -684,7 +804,7 @@ let pending = (state) => state.open.filter((group) => group.held.length);
 
 // A held run, as blocks. A region measured its headers while buffering them,
 // at this same width, so a replayed run reuses those rather than wrapping the
-// same text a second time (ADR 0020).
+// same text a second time (ADR 0027).
 /** @type {(canvas: Canvas, held: any[], avail: number) => Block[]} */
 let blocksOf = (canvas, held, avail) =>
   held.map((entry) => entry.block || blockOf(canvas, entry.event, avail));
@@ -805,7 +925,9 @@ let breakFor = (state, event) => {
 
 /** @type {(event: any) => any} */
 let markFor = (event) => ({
-  title: event.name + ": " + String(event.key),
+  // display(), not String(): a Date group key must title its outline bookmark
+  // with the same ISO 8601 UTC text its cells render, on every machine.
+  title: event.name + ": " + display(event.key),
   titled: false,
   depth: event.depth,
   page: -1,
@@ -848,7 +970,7 @@ let headOf = (canvas, span) => span - instanceGap(canvas);
 // gives flow spacing no meaning inside a table row, in either target.
 /** @type {(canvas: Canvas, cell: any, rowStyle: any) => any} */
 let cellOf = (canvas, cell, rowStyle) => {
-  let style = merge(rowStyle, cell.style);
+  let style = stack(canvas, rowStyle, cell.style);
   let list = atoms(canvas, cell.tokens, style);
   let natural = wrap(canvas, list, Infinity).reduce((widest, line) => Math.max(widest, line.w), 0);
   return {
@@ -945,7 +1067,7 @@ let sum = (values) => values.reduce((total, value) => total + value, 0);
 // same fail-loud posture as the measuring canvas's `newPage`.
 /** @type {(cols: any[], natural: number[], avail: number) => number[]} */
 let columnWidths = (cols, natural, avail) => {
-  let fixed = cols.map((col) => typeof col.width === "number" && Number.isFinite(col.width));
+  let fixed = cols.map((column) => Number.isFinite(column.width));
   if (!fixed.some(Boolean)) {
     // Natural widths always carry the cell padding, so the sum is never zero.
     let wanted = sum(natural);
@@ -1211,7 +1333,12 @@ let band = (canvas, items, yTop) => {
     fresh = canvas.fresh;
   canvas.y = yTop;
   canvas.fresh = false;
-  for (let event of items) drawBlock(canvas, blockOf(canvas, event, avail), canvas.margin, avail);
+  // Folded straight into the draw, the way the body walk folds straight into
+  // `route`: the folder emits in order and nothing here needs the band whole.
+  let fold = splitFolder((event) =>
+    drawBlock(canvas, blockOf(canvas, event, avail), canvas.margin, avail),
+  );
+  for (let event of items) fold(event);
   let h = yTop - canvas.y;
   canvas.y = saved;
   canvas.fresh = fresh;
@@ -1265,7 +1392,8 @@ let reserve = (geo, fonts, bands) => {
 // want it: reservation to measure against, the draw pass to hang the header
 // from.
 /** @type {(canvas: Canvas) => Frame} */
-let pageBox = (canvas) => frame(canvas.width, canvas.height, canvas.margin, canvas.base);
+let pageBox = (canvas) =>
+  frame(canvas.width, canvas.height, canvas.margin, canvas.base, canvas.style);
 
 // One finished page's furniture, drawn in the strips `reserve` left for it:
 // the header hanging from the top margin, the footer resting on the bottom
@@ -1335,6 +1463,10 @@ let flow = (canvas) => {
     // content would have taken had it never been held.
     route: () => {},
   };
+  // The body walk's own folder, emitting each finished event onward to `route`
+  // below. Declared here and bound after `route` exists.
+  /** @type {(event: any) => void} */
+  let fold;
   // A table is buffered whole before it is laid out: column widths come from
   // every cell in it, so the last row has to be in hand first.
   /** @type {any[]} */
@@ -1350,6 +1482,14 @@ let flow = (canvas) => {
   // What each event does once it is placed for real. A buffered region replays
   // through this same table, so held content lays out by exactly the path it
   // would have taken had it never been held.
+  // A block with no title of its own: held back under a group header, placed
+  // anywhere else. Both the image and the split flow this way.
+  /** @type {(event: any, block: Block | null) => void} */
+  let heldOrPlaced = (event, block) =>
+    event.role === "group-header"
+      ? holdHeader(state, event, null, block)
+      : placeItem(state, event, block);
+
   /** @type {Record<string, (event: any, block: Block | null) => void>} */
   let placed = {
     // A header is held rather than placed, and holding is bookkeeping the
@@ -1362,10 +1502,11 @@ let flow = (canvas) => {
     // An image flows exactly as an item does, held back in a group header and
     // placed anywhere else -- the block it becomes carries a height like any
     // other. It wears no role default: those describe text.
-    image: (event, block) =>
-      event.role === "group-header"
-        ? holdHeader(state, event, null, block)
-        : placeItem(state, event, block),
+    image: heldOrPlaced,
+    // A split flows exactly as an image does, for the same reason: one block,
+    // held back in a group header and placed anywhere else. It wears no role
+    // default of its own -- its slots carry theirs.
+    split: heldOrPlaced,
     "group-start": (event) => openGroup(state, event),
     "group-end": () => {
       flush(state, 0);
@@ -1405,6 +1546,7 @@ let flow = (canvas) => {
   };
 
   state.route = route;
+  fold = splitFolder(route);
 
   // Everything drawn across the page rather than down a strip: the declaring
   // node's own bands, its footer among them.
@@ -1458,10 +1600,25 @@ let flow = (canvas) => {
     buffer(state, event, block);
   };
 
+  // The report default onto the canvas, before anything is measured. Its
+  // `size` replaces this target's baseline outright, so row heights and band
+  // gaps scale with the document's type rather than staying at a size nothing
+  // is set in; the block itself becomes the outermost layer `stack` composes
+  // (docs/adr/0033). `sizeOf` is what decides a size is usable anywhere in this
+  // target, so it decides it here too -- a computed `size` reaches this
+  // unchecked, and two spellings of that leniency would drift.
+  /** @type {(style: any) => void} */
+  let adoptDefault = (style) => {
+    if (!style) return;
+    canvas.style = style;
+    canvas.base = sizeOf(style, canvas.base);
+  };
+
   return {
     handlers: {
       "report-start": (event) => {
         opening = event;
+        adoptDefault(event.style);
         if (event.columns) state.pending = { count: event.columns, owner: -1 };
         if (!event.page) return;
         // A frame of its own, never the canvas itself: `measuring` builds
@@ -1473,14 +1630,21 @@ let flow = (canvas) => {
         adopt(canvas, reserve(pageBox(canvas), canvas.fonts, event.page));
       },
       // Everything else routes: `placed` above says what each event does, and
-      // one entry point is what lets a buffered region replay through it.
-      // Only the roled item needs a word of its own on the way in.
+      // one entry point is what lets a buffered region replay through it. The
+      // three the folder owns are left out — `split` is not a stream event at
+      // all (the folder mints it) and item and image reach `route` through it.
       ...Object.fromEntries(
-        Object.keys(placed).map((type) => [
-          type,
-          type === "item" ? (event) => route(roled(event)) : (event) => route(event),
-        ]),
+        Object.keys(placed)
+          .filter((type) => !BLOCKS.has(type))
+          .map((type) => [type, (/** @type {any} */ event) => route(event)]),
       ),
+      // Item, image and both bracket events all go through the folder, which
+      // routes what is not inside a split straight onward. The item is the one
+      // that wears a band-role default on the way in.
+      "split-start": (event) => fold(event),
+      "split-end": (event) => fold(event),
+      item: (event) => fold(roled(event)),
+      image: (event) => fold(event),
       "group-end": (event) => {
         endOwned(event.depth);
         route(event);

package/lib/outline.js

@@ -49,26 +49,6 @@ let linkKids = (entry, refs, kids, n) => {
   entry.Count = n;
 };
 
-/** @type {(ctx: any, refs: any[], root: any, parent: number[], marks: any[], pageRefs: any[], i: number, mark: any) => void} */
-let writeEntry = (ctx, refs, root, parent, marks, pageRefs, i, mark) => {
-  let siblings = kidsOf(parent, parent[i]);
-  let index = siblings.indexOf(i);
-  let kids = kidsOf(parent, i);
-  let target = pageRefs[Math.min(mark.page, pageRefs.length - 1)];
-  /** @type {Record<string, any>} */
-  let entry = {
-    Title: PDFHexString.fromText(mark.title),
-    Parent: parentRef(parent, i, root, refs),
-    // `/XYZ <x> <y> null`: scroll to the mark's line, keep the zoom. The
-    // left edge is the mark's own column, so two instances sharing a y in
-    // two page columns are two distinct destinations.
-    Dest: [target, PDFName.of("XYZ"), PDFNumber.of(mark.x), PDFNumber.of(mark.y), null],
-  };
-  linkSiblings(entry, refs, siblings, index);
-  linkKids(entry, refs, kids, descendants(marks, i));
-  ctx.assign(refs[i], ctx.obj(entry));
-};
-
 /**
  * Attach an outline built from `marks` to the document.
  *
@@ -82,8 +62,24 @@ export function outline(doc, marks, pageRefs) {
   let parent = parents(marks);
   let refs = marks.map(() => ctx.nextRef());
   let root = ctx.nextRef();
-  for (let [i, mark] of marks.entries())
-    writeEntry(ctx, refs, root, parent, marks, pageRefs, i, mark);
+  for (let [i, mark] of marks.entries()) {
+    let siblings = kidsOf(parent, parent[i]);
+    let index = siblings.indexOf(i);
+    let kids = kidsOf(parent, i);
+    let target = pageRefs[Math.min(mark.page, pageRefs.length - 1)];
+    /** @type {Record<string, any>} */
+    let entry = {
+      Title: PDFHexString.fromText(mark.title),
+      Parent: parentRef(parent, i, root, refs),
+      // `/XYZ <x> <y> null`: scroll to the mark's line, keep the zoom. The
+      // left edge is the mark's own column, so two instances sharing a y in
+      // two page columns are two distinct destinations.
+      Dest: [target, PDFName.of("XYZ"), PDFNumber.of(mark.x), PDFNumber.of(mark.y), null],
+    };
+    linkSiblings(entry, refs, siblings, index);
+    linkKids(entry, refs, kids, descendants(marks, i));
+    ctx.assign(refs[i], ctx.obj(entry));
+  }
 
   let top = kidsOf(parent, -1);
   ctx.assign(

package/lib/style.js

@@ -4,13 +4,12 @@
  * render: a value of the wrong shape contributes nothing rather than reaching
  * the page.
  *
- * `finite`/`HEX` are restated per target on purpose: the coercions are each
- * target's own edge, never shared engine code.
+ * `HEX` is restated per target on purpose: the coercion is each target's own
+ * edge, never shared engine code. Finiteness is not one of those coercions —
+ * `Number.isFinite` never coerces, so this target asks it directly.
  */
 import { rgb } from "pdf-lib";
 
-/** @type {(value: any) => boolean} */
-let finite = (value) => typeof value === "number" && Number.isFinite(value);
 let HEX = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i;
 
 // Leading as a fraction of the font size, cell padding, the gap between a
@@ -51,12 +50,24 @@ let col = (value) => {
 };
 
 /** @type {(style: any, base: number) => number} */
-let sizeOf = (style, base) => (finite(style.size) && style.size > 0 ? style.size : base);
+let sizeOf = (style, base) => (Number.isFinite(style.size) && style.size > 0 ? style.size : base);
 
 // Style blocks layer outward-in: row under cell.
 /** @type {(under: any, over: any) => any} */
 let merge = (under, over) => (under ? (over ? { ...under, ...over } : under) : over || {});
 
+// The whole stack a resolved style is composed of, outermost first: the report
+// default the canvas carries, the enclosing block's style (a table row's, a
+// split's), and the node's own. This target's reading of docs/adr/0033, in one
+// place, so a third resolution funnel cannot quietly omit the outer layer.
+//
+// Only `family` is load-bearing in the outer layer: `settle` has already put
+// the report default's `size` on `canvas.base`, which `sizeOf` falls back to
+// for every drawn atom, so the size reaches the page whether or not it is
+// merged here.
+/** @type {(canvas: { style?: any }, under: any, own: any) => any} */
+let stack = (canvas, under, own) => merge(canvas.style, merge(under, own));
+
 // Band-role omakase defaults — the outermost layer of that same stack, under
 // the author's own style, which therefore always wins. Only the headline
 // roles carry one; the XLSX target carries the same two, byte-identical, in
@@ -81,4 +92,15 @@ let roled = (event) =>
     ? { ...event, style: merge(ROLES[event.role], event.style) }
     : event;
 
-export { BAND, BLACK, GUTTER, LEAD, PADX, PADY, col, merge, roled, shift, sizeOf };
+// Whether a resolved style asks for either text decoration -- one reading for
+// the wrapper that stamps it on a line and the canvas that draws it.
+/** @type {(style: any) => boolean} */
+let dressed = (style) => !!(style && (style.underline || style.strikethrough));
+
+// Whether a resolved style asks for capitals. This target has no
+// text-transform to defer to, so the reading is here beside the rest of the
+// vocabulary and `text.js` applies it before measuring.
+/** @type {(style: any) => boolean} */
+let upper = (style) => !!(style && style.uppercase);
+
+export { BAND, BLACK, GUTTER, LEAD, PADX, PADY, col, dressed, roled, shift, sizeOf, stack, upper };

package/lib/text.js

@@ -3,8 +3,9 @@
  * their resolved typography, and a greedy breaker turns those into lines. Pure
  * measurement against the font registry — nothing here touches the page.
  */
+import { display } from "quario";
 import { ascOf, face, printable, width } from "./fonts.js";
-import { LEAD, col, sizeOf } from "./style.js";
+import { LEAD, col, dressed, sizeOf, upper } from "./style.js";
 
 // What measuring needs and no more: the embedded faces to measure against
 // and the base size a style falls back to. A `Canvas` satisfies it, so
@@ -27,7 +28,15 @@ import { LEAD, col, sizeOf } from "./style.js";
  */
 
 /** @type {(token: any) => string} */
-let rawOf = (token) => ("literal" in token ? token.literal : String(token.value ?? ""));
+let rawOf = (token) => ("literal" in token ? token.literal : display(token.value));
+
+// This target has no text-transform to defer to, so `uppercase` is applied to
+// the string before it is measured -- the widths have to be the widths of what
+// is actually drawn. `toUpperCase` rather than `toLocaleUpperCase`: this
+// target's output is byte-reproducible, so the host's locale must not reach
+// the glyphs.
+/** @type {(text: string, style: any) => string} */
+let cased = (text, style) => (upper(style) ? text.toUpperCase() : text);
 
 /** @type {(font: any, line: string) => string[]} */
 let partsOf = (font, line) => printable(font, line).split(/( +)/).filter(Boolean);
@@ -61,7 +70,7 @@ let atoms = (metrics, tokens, style) => {
   let out = /** @type {Atom[]} */ ([]);
   let { font, size, color } = look(metrics, style);
   for (let token of tokens)
-    for (let [i, line] of rawOf(token).split("\n").entries())
+    for (let [i, line] of cased(rawOf(token), style).split("\n").entries())
       pushLine(out, font, size, color, i, line);
   return out;
 };
@@ -225,9 +234,6 @@ let stamp = (line, underline, strikethrough) => {
   if (strikethrough) line.strikethrough = true;
 };
 
-/** @type {(style: any) => boolean} */
-let dressed = (style) => !!(style && (style.underline || style.strikethrough));
-
 /** @type {(lines: Line[], style: any) => Line[]} */
 let dress = (lines, style) => {
   if (!dressed(style)) return lines;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quario/pdf",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "The browserless, paginated PDF render target for quario — in the makings, not yet released",
   "homepage": "https://getquario.com",
   "license": "SEE LICENSE IN LICENSE",
@@ -42,13 +42,13 @@
     "@arethetypeswrong/cli": "^0.18.3",
     "@pdf-lib/fontkit": "^1.1.1",
     "@size-limit/preset-small-lib": "^13.0.3",
-    "quario": "^0.1.0",
+    "quario": "^0.2.0",
     "size-limit": "^13.0.3",
     "typescript": "^7.0.2"
   },
   "peerDependencies": {
     "@pdf-lib/fontkit": "^1.1.1",
-    "quario": "^0.1.0"
+    "quario": "^0.2.0"
   },
   "peerDependenciesMeta": {
     "@pdf-lib/fontkit": {