@quario/layout 0.2.0 → 0.4.0

package/lib/measure.js

@@ -0,0 +1,263 @@
+/**
+ * The measured table: everything that turns a buffered table into cells with
+ * heights, and nothing that puts them on a page.
+ *
+ * The split is not where a reader expects it. The table engine's emitting
+ * half — slicing a row across a break, carrying the header over, deciding
+ * whether to break at all — is bound to the band flow's cursor, and
+ * `quario-70jg.15` measured that it can never leave: **emitting a table is
+ * participating in the page break, and the page break owns the block layer.**
+ * So what closes is the measurement, and only that.
+ *
+ * One door in. `measureTable` is the single entry `quario-70jg.14` collapsed
+ * the two into, which is what makes this a module with a name rather than a
+ * region with two.
+ *
+ * Nothing here reads the cursor, so nothing here can page — which is what
+ * buys a suite that can say something about a column width without a `Flow`,
+ * a recording canvas, or ten imports.
+ */
+
+/** @import { Canvas } from './canvas.js' */
+
+import { CELL_PAD, insetOf, unbox } from "./box.js";
+import { col, merge, rowHeight, sizeOf, vshift } from "./style.js";
+import { atoms, heightOf, wrap } from "./text.js";
+
+/** @typedef {{ cells: any[], spans: number[] | null }} Voting */
+/** The column geometry a row is drawn against.
+ * @typedef {{ xOffsets: number[], widths: number[] }} Columns */
+/** One measured row: its cells with their lines, and the height they came to.
+ * @typedef {{ cells: any[], h: number, style?: any, spans?: number[] | null }} TableRow */
+
+/** The offsets a spanning row's merged columns start at. */
+/** @type {(xOffsets: number[], spans: number[] | null) => number[]} */
+let spanOffsets = (xOffsets, spans) => (spans ? overSpans(spans, (at) => xOffsets[at]) : xOffsets);
+
+// Pre-measure one cell: wrapped lines per column width come later; natural
+// width first (no wrapping except hard breaks). `mt`/`mb` go unread: SCHEMA.md
+// 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) => {
+  // A row's block reaches its cells with no box in it: the engine resolved
+  // that half onto the cells themselves before the event was emitted
+  // (SCHEMA.md, "Style declarations"), which is why the inset and the ink
+  // both read the cell and a row is never asked for a box it cannot have.
+  let style = merge(rowStyle, unbox(cell.style));
+  let inset = insetOf(cell.style, CELL_PAD);
+  let list = atoms(canvas.settings, cell.tokens, style);
+  let natural = wrap(list, Infinity, sizeOf(style, canvas.settings.base)).reduce(
+    (widest, line) => Math.max(widest, line.w),
+    0,
+  );
+  return {
+    list,
+    natural: natural + inset.l + inset.r,
+    align: style.align,
+    valign: style.valign,
+    bg: col(style.background),
+    inset,
+    style: cell.style,
+    path: cell.path,
+  };
+};
+
+/** @type {(canvas: Canvas, cells: any[], widths: number[]) => { cells: any[], h: number }} */
+let rowOf = (canvas, cells, widths) => {
+  let h = rowHeight(canvas);
+  /** @type {number[]} */
+  let owns = [];
+  let out = cells.map((cell, i) => {
+    let inner = Math.max(widths[i] - cell.inset.l - cell.inset.r, 1);
+    // A glyph or a hard break occupies; spaces alone are an empty cell.
+    let lines = cell.list.some(
+      (/** @type {{ hard: boolean, space: boolean }} */ atom) => atom.hard || !atom.space,
+    )
+      ? wrap(cell.list, inner, cell.list[0].size)
+      : [];
+    let own = heightOf(lines) + cell.inset.t + cell.inset.b;
+    if (own > h) h = own;
+    owns.push(own);
+    return { ...cell, lines };
+  });
+  // The row's height is known only now, so the slack each cell's `valign`
+  // reads is measured here, as `splitBlock` measures a slot's.
+  for (let [i, cell] of out.entries()) cell.drop = vshift(cell.valign, h - owns[i]);
+  return { cells: out, h };
+};
+
+// The column geometry one row sees. A cell covering several columns starts
+// where the first of them starts and is as wide as all of them together; a row
+// that spans nothing sees the columns themselves, and pays nothing for the
+// feature. `null` spans is that row -- every data row, and every total row
+// whose cells each cover one column.
+/** @type {(cells: any[]) => number[] | null} */
+let spansOf = (cells) =>
+  cells.some((cell) => cell.span > 1) ? cells.map((cell) => cell.span || 1) : null;
+
+// One value per cell, walking the columns each of them covers. Reached only
+// for a row that spans, so the closure it takes costs nothing per data row.
+/** @type {(spans: number[], pick: (at: number, span: number) => number) => number[]} */
+let overSpans = (spans, pick) => {
+  /** @type {number[]} */
+  let out = [];
+  let at = 0;
+  for (let span of spans) {
+    out.push(pick(at, span));
+    at += span;
+  }
+  return out;
+};
+
+/** @type {(widths: number[], spans: number[] | null) => number[]} */
+let spanWidths = (widths, spans) =>
+  spans ? overSpans(spans, (at, span) => sum(widths.slice(at, at + span))) : widths;
+
+// The widest of each column's header, rows and totals, padding included.
+//
+// A cell covering more than one column has no say in their widths (SCHEMA.md):
+// what a span states is which columns a cell reaches across, never how wide
+// they are. So a column can end up with no voter at all -- every cell above it
+// spans over it -- which only an empty table reaches, since a data row never
+// spans. It opens at the padding floor rather than at nothing, so an empty
+// table still shows the geometry it promises.
+/**
+ */
+/** @type {(cols: any[], header: Voting, rows: Voting[], totals: Voting[]) => number[]} */
+let naturalWidths = (cols, header, rows, totals) => {
+  /** @type {(number | null)[]} */
+  let widest = cols.map(() => null);
+  /** @type {(at: number, natural: number) => void} */
+  let widen = (at, natural) => {
+    let held = widest[at];
+    if (held === null || natural > held) widest[at] = natural;
+  };
+  /** @type {(row: Voting) => void} */
+  let vote = (row) => {
+    let at = 0;
+    for (let [i, cell] of row.cells.entries()) {
+      let span = row.spans ? row.spans[i] : 1;
+      if (span === 1) widen(at, cell.natural);
+      at += span;
+    }
+  };
+  vote(header);
+  for (let row of rows) vote(row);
+  for (let row of totals) vote(row);
+  return widest.map((width) => (width === null ? CELL_PAD.l + CELL_PAD.r : width));
+};
+
+/** @type {(values: number[]) => number} */
+let sum = (values) => values.reduce((total, value) => total + value, 0);
+
+// An authored `width` percentage fixes its column; the rest share what is left
+// in proportion to their natural widths. Three cases, one return each — the
+// fall-through is all-authored within budget, honoured exactly.
+//
+// There is no over-commitment case: the engine rejects a document whose fixed
+// shares leave the width-less columns nothing, so `left` is positive whenever
+// an auto column exists and the fixed shares never exceed the content width.
+// That invariant is asserted rather than trusted — falling through with auto
+// columns unplaced would draw them at zero width, an invisible failure — the
+// 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((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);
+    return natural.map((width) => (width * avail) / wanted);
+  }
+  let widths = cols.map((col, i) => (fixed[i] ? (col.width / 100) * avail : 0));
+  let auto = natural.map((width, i) => (fixed[i] ? 0 : width));
+  let left = avail - sum(widths);
+  let wanted = sum(auto);
+  // Room for the auto columns: they share what the fixed ones left.
+  if (wanted > 0) {
+    if (left <= 0) throw new Error("over-committed column widths reached the layout");
+    return widths.map((width, i) => (fixed[i] ? width : (auto[i] * left) / wanted));
+  }
+  return widths;
+};
+
+// A buffered table, in the one shape `table` lays out: its columns come from
+// the opening event, its rows are the row events themselves, and its total is
+// the total row's cells. Both readers build it here — the replay, collecting
+// events as they arrive, and the region buffer, reading them back off what it
+// held — so a new table event kind cannot reach one and miss the other.
+/** @type {(events: any[]) => any} */
+let tableOf = (events) => {
+  let opening = events[0];
+  return {
+    columns: opening.columns.map((/** @type {any} */ col) => ({ ...col })),
+    // The header row arrives whole (docs/adr/0053), so both readers -- the
+    // replay and the region buffer -- take the same list rather than each
+    // rebuilding it from the columns.
+    header: opening.header.cells,
+    headerStyle: opening.header.style,
+    rows: events.filter((event) => event.type === "row"),
+    // The events themselves, as `rows` are: a total row is a row, and the
+    // buffer files each corrected height under the event it was measured from.
+    totals: events.filter((event) => event.type === "total-row"),
+  };
+};
+
+/**
+ * @typedef {{ widths: number[], head: any, laid: any[], totalRows: any[] }} Measured
+ */
+// Measure a buffered table at a given width: the column widths every cell has
+// a say in, then each row laid out against them. Everything here is
+// arithmetic over the cells, so the region's buffer can ask for it before
+// anything is drawn — which is the only way a row's real height is known
+// early enough to balance on (bead `quario-cgk`).
+/** @type {(canvas: Canvas, buffered: any, avail: number) => Measured} */
+let measureTable = (canvas, buffered, avail) => {
+  let cols = /** @type {any[]} */ (buffered.columns);
+  /** @type {(cells: any[], style: any, spans: number[] | null) => Voting & { style: any }} */
+  let measured = (cells, style, spans) => ({
+    cells: cells.map((/** @type {any} */ cell) => cellOf(canvas, cell, style)),
+    spans,
+    style,
+  });
+  let header = measured(buffered.header, buffered.headerStyle, spansOf(buffered.header));
+  // A data row's cells are the columns' own, so nothing in one can span
+  // (SCHEMA.md, "Span"). Asking each row anyway would scan every cell of the
+  // table to rediscover what the schema already guarantees.
+  let rows = buffered.rows.map((/** @type {any} */ row) => measured(row.cells, row.style, null));
+  let totals = buffered.totals.map((/** @type {any} */ row) =>
+    measured(row.cells, row.style, spansOf(row.cells)),
+  );
+  let widths = columnWidths(cols, naturalWidths(cols, header, rows, totals), avail);
+  // Each row wraps against the geometry it sees, which is the columns' own
+  // unless one of its cells spans.
+  /** @type {(row: Voting & { style: any }) => any} */
+  let laidOut = (row) => ({
+    ...rowOf(canvas, row.cells, spanWidths(widths, row.spans)),
+    spans: row.spans,
+    style: row.style,
+  });
+  return {
+    widths,
+    head: laidOut(header),
+    laid: rows.map(laidOut),
+    totalRows: totals.map(laidOut),
+  };
+};
+
+// What this row draws against: the grid's own columns, or the merged geometry
+// a spanning row sees. Read at draw time rather than kept on the row, because
+// `rebase` moves the offsets under it every time the table crosses a strip.
+//
+// Typed on the geometry rather than on the flow's `Grid`, which is the seam
+// this module sits on: a grid carries a cursor and this never reads one, so
+// asking for the whole record would claim a coupling that is not here.
+/** @type {<T extends Columns>(grid: T, row: TableRow) => Columns} */
+let gridOf = (grid, row) =>
+  row.spans
+    ? {
+        xOffsets: spanOffsets(grid.xOffsets, row.spans),
+        widths: spanWidths(grid.widths, row.spans),
+      }
+    : grid;
+
+export { gridOf, measureTable, sum, tableOf };

package/lib/page.js

@@ -3,8 +3,15 @@
  * it is written. Owned here because every consumer of the list — the PDF
  * target, the viewer, the editor — lays out on the same page, and a size that
  * meant one thing on screen and another on paper would be a silent lie.
+ *
+ * The derivation belongs with the validation: `frame` below turns a validated
+ * page and margin into the geometry everything downstream lays out in, so a
+ * page becomes a content box here and `canvas.js` only takes the answer,
+ * rather than the drawing surface defining the page it draws on. Deriving a
+ * frame is not owning its lifetime, and this module claims only the first:
+ * `adopt` (`canvas.js`) narrows `top`/`bottom` once for the page bands, and
+ * `reserve` (`layout.js`) mints the frame it narrows from.
  */
-import { frame } from "./canvas.js";
 
 // The named sizes. `@quario/pdf` used to own this table, and the two element
 // packages restated it; the layout package is where all three now read it.
@@ -80,11 +87,42 @@ export let pageBox = (page, at = "page") => {
   return { width, height, margin: marginOf(page?.margin, width, height, at + ".margin") };
 };
 
+// The page box and the content box, and nothing whatever else: geometry, all
+// of it derived below from a page and a margin. Fixed for the document — the
+// one exception is `top`/`bottom`, which the page bands narrow once through
+// `adopt` (`canvas.js`), while the first page is still untouched. Everything
+// else that holds for a whole render is that module's `Settings`; a frame
+// carrying either half of that was a type with two lifetimes, and the copy that
+// kept a probe reading the same locale as the draw had to be written out by
+// hand.
+/**
+ * @typedef {{ width: number, height: number, margin: number,
+ *   content: number, top: number, bottom: number }} Frame
+ */
+
+// A frame from the page box: 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. A render reaches a frame through
+// `geometry` below and never through this; the package entry carries neither,
+// so no host reaches one at all. Exported for `layout.js`, which re-derives the
+// page frame a canvas presents, and for the suites that build a fixture frame
+// — the day that re-derivation goes, the export stands for the suites alone,
+// and they should take `geometry` rather than keep it standing.
+/** @type {(width: number, height: number, margin: number) => Frame} */
+export let frame = (width, height, margin) => ({
+  width,
+  height,
+  margin,
+  content: width - 2 * margin,
+  top: height - margin,
+  bottom: margin,
+});
+
 /**
  * The page box and the content box in one, for a render: the host's size,
  * and whichever margin the host and the opening event agreed on.
  *
- * @type {(page: any, opening?: any) => import('./canvas.js').Frame}
+ * @type {(page: any, opening?: any) => Frame}
  */
 export let geometry = (page = {}, opening) => {
   let { width, height } = pageBox(page, "options.page");

package/lib/paint.js

@@ -123,7 +123,9 @@ let loadFaces = async (fonts) => {
 };
 
 // Every bitmap decoded so far, by the bytes it was decoded from: one logo on
-// every page is decoded once.
+// every page is decoded once. A rejection is remembered too, so a file the
+// browser refused is refused from memory ever after — a caller repainting the
+// same page never pays for a second decode of bytes that will not decode.
 /** @type {WeakMap<Uint8Array, Promise<ImageBitmap>>} */
 let BITMAPS = new WeakMap();
 
@@ -204,17 +206,30 @@ let PAINTERS = { rect: paintRect, line: paintLine, text: paintText, mark: paintM
 
 /** @type {(ctx: CanvasRenderingContext2D, op: Op, bitmaps: Map<Op, ImageBitmap>) => void} */
 let paintOp = (ctx, op, bitmaps) => {
-  if (op.kind === "image")
-    ctx.drawImage(/** @type {ImageBitmap} */ (bitmaps.get(op)), op.x, op.y, op.w, op.h);
-  else PAINTERS[op.kind](ctx, op);
+  // An image with no bitmap did not decode, and is drawn as nothing. The map
+  // is the one place that is known: `decode` keeps no entry for a file the
+  // browser refused, so there is no second flag to read and no way to ask
+  // this question twice.
+  if (op.kind === "image") {
+    let bitmap = bitmaps.get(op);
+    if (bitmap) ctx.drawImage(bitmap, op.x, op.y, op.w, op.h);
+  } else PAINTERS[op.kind](ctx, op);
 };
 
-// Every image on the page, decoded together rather than one after another.
+// Every image on the page, decoded together rather than one after another,
+// and each settling on its own: gathering with `Promise.all` made one file the
+// browser refused the whole page's failure, thrown before the first draw op.
+// `paint`'s own doc says why that is the wrong price. An image that did not
+// decode has no entry here, which is how `paintOp` knows.
 /** @type {(page: Page) => Promise<Map<Op, ImageBitmap>>} */
 let decode = async (page) => {
   let images = page.ops.filter((op) => op.kind === "image");
-  let bitmaps = await Promise.all(images.map(bitmapOf));
-  return new Map(images.map((op, i) => [op, bitmaps[i]]));
+  let bitmaps = await Promise.all(images.map((op) => bitmapOf(op).catch(() => null)));
+  return new Map(
+    /** @type {[Op, ImageBitmap][]} */ (
+      images.map((op, i) => [op, bitmaps[i]]).filter(([, bitmap]) => bitmap)
+    ),
+  );
 };
 
 /**
@@ -230,6 +245,14 @@ let decode = async (page) => {
  * superseded call reach a canvas still on screen — which is what the viewer's
  * stage retires a page for (docs/adr/0046).
  *
+ * **An image the browser will not decode is drawn as nothing, and the page is
+ * drawn around it.** The engine vouched for the magic numbers and the layout
+ * read the size out of the header, so a file corrupt past that point is not
+ * known to be bad until here; costing the whole page for it — every other op
+ * and the marking with it — is a worse answer than costing the image. What is
+ * lost is what could not be drawn. A caller wanting the failure instead should
+ * decode before it paints.
+ *
  * @param {CanvasRenderingContext2D} ctx The context to paint on.
  * @param {Page} page One page of a `Layout`.
  * @param {{ scale?: number, fonts?: any }} [options]

package/lib/settings.js

@@ -0,0 +1,88 @@
+/**
+ * Everything that holds for a whole render and is not geometry — the render's
+ * `Settings`, and the one reading of what a report default amounts to.
+ *
+ * A `Frame` (canvas.js) is a page's geometry; a `Settings` is the other half:
+ * the faces to measure against, the report default narrowed to `base` and
+ * `family`, and the three intl facts a formatted value resolves in. A canvas
+ * holds one by reference, so a measuring canvas built for a probe reads exactly
+ * what the listing canvas reads and a band cannot be reserved against one
+ * locale and drawn in another. This module owns what a settings *is* and how a
+ * report's opening event becomes one; canvas.js draws with it, text.js measures
+ * against it, and neither has to know what `style.size` or `style.family`
+ * amount to.
+ */
+import { familyName } from "./fonts.js";
+import { sizeOf } from "./style.js";
+
+// This layout'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;
+
+/**
+ * Everything that holds for a whole render and is not geometry: the faces to
+ * measure against, the report default narrowed to `family` and `size` (landing
+ * in `family` and `base` here), and the three intl facts a formatted value
+ * resolves in.
+ *
+ * A canvas holds one of these by reference, never a copy, which is the whole
+ * reason it is an object. A measuring canvas built off the same settings reads
+ * exactly what the listing canvas reads, so a page band cannot be reserved
+ * against one locale and drawn in another — an agreement that used to rest on
+ * a hand-written copy staying in step.
+ *
+ * `family` is null when the report declares none, and each of the intl three is
+ * undefined when the engine settled none.
+ *
+ * @typedef {{ fonts: import('./fonts.js').Fonts, base: number,
+ *   family: string | null, locale?: string, currency?: string,
+ *   timeZone?: string }} Settings
+ */
+
+/**
+ * The render's settings, complete by construction from the opening event the
+ * target already peeked. The report default is narrowed to `family` and `size`,
+ * and each replaces this target's own baseline outright: row heights and band
+ * gaps scale with the document's type rather than staying at a size nothing is
+ * set in, and text declaring no family is set in the document's. Reading the
+ * pair here is the whole of this target's reading of docs/adr/0033 — the default
+ * reaches a node as a fallback the settings carry, never as a layer merged into
+ * its style, so a document-wide fact costs no allocation however many cells a
+ * report has.
+ *
+ * `sizeOf` and `familyName` are this target's one reading each of what a
+ * declared size and family amount to, so they read the default here too — both
+ * reach this unchecked from a computed style, and two spellings of that
+ * leniency would drift. Each falls back to this target's own baseline, so a
+ * default declaring one of the pair leaves the other at the baseline, and one
+ * whose value is unusable leaves the baseline standing.
+ *
+ * Built once and never settled again: these hold for a whole render, so there
+ * is no event that could set them a second time — a second settling is not
+ * refused, it is unexpressible. `opening` is null when the stream is empty (no
+ * report to read a default from), which yields the bare baseline: the target's
+ * own size, no family, and the intl three unset. Those three are read straight
+ * off the event whether or not it declares them — a formatted value is the only
+ * thing that reads them, and an empty stream produces none, so an unset one
+ * never reaches `Intl`.
+ *
+ * @param {import('./fonts.js').Fonts} fonts The loaded faces.
+ * @param {any} [opening] The peeked `report-start` event, or null.
+ * @returns {Settings}
+ */
+let settings = (fonts, opening) => {
+  let event = opening || {};
+  let style = event.style || {};
+  return {
+    fonts,
+    base: sizeOf(style, BASE),
+    family: familyName(style) || null,
+    locale: event.locale,
+    currency: event.currency,
+    timeZone: event.timeZone,
+  };
+};
+
+export { settings };

package/lib/style.js

@@ -69,24 +69,26 @@ let sizeOf = (style, base) => (Number.isFinite(style.size) && style.size > 0 ? s
 // Style blocks layer outward-in: row under cell, split under slot. Those are
 // the two innermost of the four layers; the outer two reach a node without
 // being merged into it -- the band-role default through `roled` below, and the
-// report default through the render's settings, as `canvas.js`'s
-// `adoptSettings` explains.
+// report default through the render's settings, as `settings.js` explains.
 /** @type {(under: any, over: any) => any} */
 let merge = (under, over) => (under ? (over ? { ...under, ...over } : under) : over || {});
 
 // Band-role omakase defaults — the third of those four layers, over the report
 // default and under the author's own, which therefore always wins. Only the
-// headline roles carry one; the XLSX target carries the same two,
-// byte-identical, in `packages/xlsx/lib/index.js`, and they move together
-// (SCHEMA.md states the pair for both). A target can only import public engine helpers, so there is
-// nowhere to share this from and the two copies are synced by hand.
+// headline roles carry one, and SCHEMA.md states the pair. A target can only
+// import public engine helpers, so there is nowhere to share this from and the
+// copies are separate on purpose.
 //
 // `@quario/html` deliberately carries none of this, nor the leading, padding
 // and band gap below: its consumer has a stylesheet and the `q-*` classes are
 // the seam. The rule is docs/adr/0014-a-target-supplies-defaults-only-where-its-consumer-has-no-seam.md —
 // a target supplies defaults only where its consumer has no seam to supply
-// them. `@quario/html/style.css` is what supplies them there; keep the three in
-// agreement.
+// them.
+//
+// `test/omakase-defaults.test.js` is what holds the copies in agreement. This
+// comment names the gate rather than listing the files, because the list is
+// what rotted: it used to name partners that did not exist, and the two
+// comments disagreed on how many there were.
 /** @type {Record<string, any>} */
 let ROLES = { "report-header": { bold: true, size: 14 }, "group-header": { bold: true } };
 
@@ -98,10 +100,13 @@ let roled = (event) =>
     ? { ...event, style: merge(ROLES[event.role], event.style) }
     : event;
 
-// 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));
+// Two resolved colours, or the absence of one, compared by value: `col()`
+// mints a fresh object per read and interns nothing, so identity would answer
+// no for two reads of the same declaration.
+/** @type {(a: Color, b: Color) => boolean} */
+let sameChannels = (a, b) => a.r === b.r && a.g === b.g && a.b === b.b;
+/** @type {(a: Color | null, b: Color | null) => boolean} */
+let sameCol = (a, b) => (a && b ? sameChannels(a, b) : a === b);
 
 // 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
@@ -109,6 +114,15 @@ let dressed = (style) => !!(style && (style.underline || style.strikethrough));
 /** @type {(style: any) => boolean} */
 let upper = (style) => !!(style && style.uppercase);
 
+// A table row's floor height and the gap a group instance opens with. Here
+// rather than in the band flow because both are `k * LEAD * base` and LEAD is
+// here: a constant with two readers and no name drifts between them, and a
+// second copy of the multiplier would drift from the leading itself.
+/** @type {(canvas: any) => number} */
+let rowHeight = (canvas) => LEAD * canvas.settings.base;
+/** @type {(canvas: any) => number} */
+let instanceGap = (canvas) => 0.5 * LEAD * canvas.settings.base;
+
 export {
   BAND,
   BLACK,
@@ -117,9 +131,11 @@ export {
   PADX,
   PADY,
   col,
-  dressed,
+  instanceGap,
   merge,
   roled,
+  rowHeight,
+  sameCol,
   shift,
   sizeOf,
   upper,