@quario/layout 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,84 @@
+# Changelog
+
+All notable changes to @quario/layout are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-09-03
+
+### Added
+
+- **The paged display list.** `layout({ page, fonts })` is a render target
+  resolving every page of the report — ops in points from the top-left, one
+  hit box per schema node drawn, the page's `{ number, total }`, the outline
+  marks, and on an unlicensed render the marking. The algorithm is the PDF
+  target's typesetter, with its home moved here so a preview can paint the
+  same pages the document has.
+
+- **One measurer.** Base-14 families measure against `@pdf-lib/standard-fonts`'
+  AFM metrics over WinAnsi, TrueType families against `@pdf-lib/fontkit`'s
+  shaping of the same bytes the PDF embeds, so a preview breaks its lines
+  where the document breaks them.
+
+- **A box survives a page break.** An item or table row no page can hold
+  whole is drawn as slices, and a slice carries the box sides the break left
+  it: the top belongs to the first slice, the bottom to the last, and left and
+  right to every one. A declared border is never stroked through the middle of
+  the content it encloses, and a long paragraph no longer loses the box a
+  short one draws. Each slice reserves the bottom padding it may yet owe, so
+  that edge stays above the bottom margin, and each carries a hit box, so an
+  item that breaks is selectable on every page it reaches.
+
+- **`paint` and `hit`.** A Canvas 2D painter for one page, and the hit-test
+  that maps a point on a page back to the schema node drawn there.
+
+  Text is drawn in the face the document will use. A family you supply is
+  registered from your own bytes and its text drawn as the browser shapes it,
+  which is the shaping the PDF gets from the same file — so ligatures, joined
+  scripts and accents look on screen the way they will on paper. Text in the
+  built-in families is drawn character by character at the widths the layout
+  measured, because the typeface a browser has for them only stands in for the
+  one the PDF writes, and without the correction a line would drift as it ran.
+
+  Preview fidelity inside a run is not promised for a family you supply: the
+  browser and the document agree on the glyphs and their widths, and may
+  differ by a fraction on the kerning between them. Where a line breaks, how
+  wide a column is and where a page ends are the layout's, and identical.
+
+- **`pageBox`.** The page-size table and its validation, in one home for the
+  PDF target, the viewer and the editor.
+
+- **`PX_PER_POINT`.** How big a point is on screen — 96 dpi over PostScript's
+  72 — so every surface that shows a page shows it at the same size, and a
+  zoom is a factor on top of it.
+
+### Changed
+
+- **A split slot's box now fills the split's height.** Before, a slot's
+  background and border were exactly as tall as that slot's own content and
+  padding asked for, so any slot shorter than the tallest one drew a box that
+  stopped short of the row, leaving a gap between it and the row below. Now
+  every slot's box takes the split's height — the way a table cell's box
+  already takes its row's — so a bordered split row draws one straight edge
+  across it whether or not a slot wraps. Only the box stretches: a slot's text
+  stays at the top of it, and an image's picture is neither scaled nor moved.
+  A slot that renders nothing holds the full-height box too, as a hidden cell
+  does, and a slot's hit box follows its painted one. A report that relied on
+  the short box — a slot background used as a chip beside taller content —
+  now draws it full height; give that content a narrower slot of its own.
+
+- **A date string under `format: "date"` now presents as a date.** The text
+  join presents the kind through the engine's `format()` helper, which now
+  revives the two read forms. See the `quario` changelog for the forms.
+
+### Fixed
+
+- **A nested group's footer keeps the page columns.** Inside a page-column
+  region, the first footer of a group nested in it ended the region: the
+  strips collapsed and every band after it was laid out across the page, as
+  if `columns` were absent. Only the node that declared `columns` closes its
+  own region now — a nested group's header and footer are region content,
+  laid out in the strips.

package/LICENSE

@@ -0,0 +1,219 @@
+# Quario License Agreement
+
+> **In short:** Quario is commercial software with visible source.
+> Evaluate it free for as long as you like. Evaluation output is
+> watermarked. Anything else needs a per-developer license, after
+> which deployment is unlimited and royalty-free. This summary is not
+> the license; the full terms below govern.
+
+Version 1.0, August 2026
+
+This agreement is between you and Webstronauts, trading as Quario,
+established in the Netherlands ("we", "us"), and governs the Software
+defined below.
+
+Quario is commercial software. Its packages ship with readable source
+code, but it is not open source. No rights are granted beyond those in
+this agreement.
+
+## 1. Definitions
+
+- The **Software** is any software we publish under the Quario name,
+  including the `quario` and `@quario/*` packages, except where a
+  product states its own terms. Each release states the edition of this
+  agreement that governs it.
+- **You** means the individual exercising rights under this agreement
+  and, where that individual acts for a company or other organization,
+  that organization. In that case the organization is the licensee, and
+  the rights and limits in this agreement apply to it as a whole.
+- An **Application** is software you create that incorporates the
+  Software and adds substantial functionality beyond it. A
+  licensee-operated service that embeds the Software and renders
+  reports for your End Users is an Application under this agreement,
+  even if it does little more than render.
+- A **Developer** is any individual (employee or contractor working on
+  your behalf) who writes or maintains code that uses the Software's
+  APIs, or who creates or maintains report definitions for use with the
+  Software. That includes people who never install or run the Software
+  themselves, when their definitions are rendered by a service that
+  embeds it.
+- A **Seat** is a paid license for one named Developer, purchased from
+  us or an authorized reseller.
+- **End Users** are people who interact with the Software only through
+  an Application: running it, viewing the reports it produces, or
+  supplying parameters or other input to existing report definitions
+  the Application provides. Creating or maintaining report definitions
+  makes someone a Developer. End Users do not purchase a license; their
+  rights come from section 5.
+
+## 2. Acceptance
+
+This file is our standing offer. Anyone who exercises the evaluation
+rights in section 3 accepts them, subject to their conditions. All
+other rights arise when Seats are purchased. Where a purchase is made
+for an organization, the person completing it confirms that they are
+authorized to accept this agreement on the organization's behalf, and
+acceptance covers the whole organization. If you do not accept this
+agreement, do not use the Software.
+
+## 3. Evaluation
+
+You may download, install, and use the Software free of charge to
+evaluate it: assessing whether it suits your purposes, and building
+prototypes or proofs of concept. Evaluation covers the full feature
+set, needs no key, and has no fixed time limit. The Software marks
+evaluation output as described in section 6.
+
+Evaluation is limited to assessment: you may not distribute any
+Application containing the Software, use the Software in live business
+operations, or expose it in services offered to third parties. The
+moment your use goes beyond evaluating the Software, it requires Seats
+under section 4.
+
+## 4. Developer licenses
+
+Any use of the Software beyond section 3 requires a Seat for every
+Developer, whether or not an Application has shipped. With those Seats
+in place:
+
+- Each licensed Developer may install and use the Software on any number
+  of machines for developing Applications.
+- Automated build, test, and CI systems do not consume Seats.
+- Seats are per named individual. They may be reassigned when a
+  Developer stops working with the Software, but not shared or pooled
+  between concurrently active Developers. Contractors' work for you is
+  covered by your Seats; work they do for other clients is not.
+
+## 5. Distribution and runtime
+
+With Seats under section 4 in place, you may deploy and operate your
+Applications yourself, and distribute the Software as an embedded part
+of them, **royalty-free**: no additional fees or per-deployment
+licenses are required for any number of servers, copies, or End Users.
+You may embed your license key in an Application and ship it at no
+charge, so section 6 does not mark that Application's output.
+
+For that purpose, we grant you the right to pass through to each End
+User, and to anyone who distributes or operates your Application on your
+behalf, a limited, non-exclusive, non-transferable right to execute the
+Software only as embedded in the Application. You must not permit them
+to extract the Software from the Application or use it to develop
+software of their own.
+
+If you operate a service that embeds the Software and renders reports
+for your End Users, that service is an Application under section 1. You
+may run it royalty-free under this section, and you may put your license
+key in it as in any Application. Calling applications that only request
+renders from it need not incorporate the Software. People who use those
+applications only as End Users under section 1 get the pass-through
+rights above.
+
+You may not:
+
+- distribute the Software on its own, or as part of a product whose
+  primary purpose is to provide report-engine, report-design, or
+  document-generation capability to third-party developers;
+- expose the Software's APIs to third parties as a development tool or
+  service that substitutes for those parties buying their own Seats. A
+  licensee-operated service that embeds the Software and renders for
+  your own End Users falls outside that ban;
+- fork, mirror, repackage, rename, or wrap the Software, or republish
+  it on any package registry or code-hosting platform, other than as
+  embedded in an Application.
+
+For as long as this agreement is in force, you may not create any tool,
+library, product, or service that competes with the Software or any
+other Quario product, whether the competition is direct or indirect;
+this restriction does not survive termination. You may not remove or
+alter copyright or license notices in the Software. If your Application
+is itself a closed development product for third-party developers (OEM
+redistribution), contact us for separate terms.
+
+## 6. License keys and output marking
+
+The Software accepts a license key that evidences your Seats under
+section 4. Key checks run offline.
+
+Without a valid key, or with a key whose validity period does not cover
+the installed version's release date, the Software runs with its full
+feature set but marks its output as unlicensed. Using a key you are not
+entitled to is a material breach of this agreement.
+
+You may not remove, disable, or circumvent the key check or the output
+marking, or distribute anything that does.
+
+## 7. Term, updates, and perpetual fallback
+
+Seats are sold as an annual subscription. While the subscription is
+active, licensed Developers receive all Software versions we release,
+and support for the Software through our issue tracker and by email. We
+provide support with commercially reasonable effort; we do not guarantee
+specific response times.
+
+If the subscription lapses, your license to the versions released during
+your subscription is **perpetual, for the number of Seats held at the
+lapse**: up to that many Developers may keep using those versions, and
+your Applications may keep shipping them, forever, at no further cost.
+Versions released after the lapse require renewal. We encode this rule
+in purchased keys: a key remains valid for every version released
+during its validity period, with no end date.
+
+## 8. Source availability
+
+The Software's packages ship with readable source code so that you can
+review and debug what you run. Readable source does not grant extra
+rights: this agreement governs all use of the source, and you may
+publish the Software (modified or not) only as part of an Application
+under section 5.
+
+## 9. Ownership, trademarks, and feedback
+
+We license the Software; we retain all intellectual property rights in
+it. Report definitions, data, and output you create with the Software
+are yours. "Quario" and the Quario logo are our trademarks; this
+agreement grants no rights to use them beyond identifying the Software.
+If you send us feedback or suggestions, we may use them without
+obligation.
+
+## 10. Warranty and liability
+
+We provide the Software as is. To the fullest extent the law allows, we
+disclaim all warranties and conditions, express or implied, including
+merchantability, fitness for a particular purpose, and non-infringement.
+
+To the fullest extent the law allows: we are not liable for indirect or
+consequential damages, loss of profits, loss of data, or business
+interruption; and our total aggregate liability under this agreement is
+limited to the greater of EUR 100 and the fees you paid us in the
+twelve months preceding the event giving rise to the claim. These
+limitations do not apply where the damage results from the intent or
+deliberate recklessness (opzet of bewuste roekeloosheid) of us or our
+management, or where mandatory law does not permit them.
+
+## 11. Termination and survival
+
+If you materially breach this agreement, we may terminate it by notice.
+If the breach can be remedied, we will first allow 30 days from that
+notice to remedy it, and termination takes effect only if the breach
+remains. On termination, the licenses granted here end.
+Perpetual-fallback rights under section 7 survive termination only if
+they arose from a lapse that predates the breach, and section 5
+survives with them to the extent needed to keep exercising them.
+Sections 8 through 12 survive any termination.
+
+## 12. General
+
+Dutch law governs this agreement. Disputes go to the competent court for
+our registered office. You may not assign this agreement without our
+consent, except to a successor of your whole business; we may assign it
+to a successor of ours. If a provision is unenforceable, the remainder
+stays in force. Failure to enforce a provision does not waive it. This
+agreement, together with your order for Seats, is the entire agreement
+about the Software, unless we agree otherwise in writing.
+
+---
+
+**Purchasing and contact:** <contact@getquario.com> ·
+<https://getquario.com>
+
+Copyright © 2026 Webstronauts. All rights reserved.

package/README.md

@@ -0,0 +1,94 @@
+# @quario/layout
+
+**The paged layout of a [quario](https://www.npmjs.com/package/quario) report, as a display
+list.** `layout(options)` is a render target whose output is pages of boxes, text runs, rules
+and images in points — the layout the PDF target writes and the viewer and editor paint on screen,
+so the preview breaks its pages exactly where the document does.
+
+You install this package directly only to consume the list yourself. `@quario/pdf`, `@quario/viewer`
+and `@quario/editor` depend on it and run it for you.
+
+## Install
+
+```bash
+npm install quario @quario/layout
+```
+
+The engine is a peer. The one runtime dependency is `@pdf-lib/standard-fonts`, the metrics of the
+base-14 PDF families. To lay out with your own TrueType families, add the optional peer:
+
+```bash
+npm install @pdf-lib/fontkit
+```
+
+ESM-only, Node 22+, and browser-ready through a standards-based bundler. CSP-safe: no
+string-to-code paths anywhere.
+
+## Quick start
+
+```js
+import { layout } from "@quario/layout";
+import { quario } from "quario";
+
+const report = quario().report(schema);
+const list = await report.render(layout({ page: { size: "A4", margin: 54 } }), data);
+
+list.pages.length; // how many pages the report needs
+list.pages[0].ops; // what to draw on the first page, in order
+list.pages[0].boxes; // which schema node was drawn where
+```
+
+Every coordinate is in PostScript points from the page's top-left corner. A page carries its
+`{ number, total }`, its ops — `rect`, `line`, `image`, `text` (the string to draw, the face
+it is set in, and — for a built-in family only — the per-character advances the measurer laid it
+out with) and, on an unlicensed render, one `mark` — and its `boxes`, one per schema node drawn,
+named by the node's path.
+
+## Options
+
+| Option  | Takes                                                 | Default  |
+| ------- | ----------------------------------------------------- | -------- |
+| `page`  | `{ size: "A4" \| "letter" \| [w, h], margin }` points | A4, 54pt |
+| `fonts` | A font mapping: family name to TrueType bytes         | none     |
+
+They are the pdf target's own `page` and `fonts`: pass the same object to `layout()` and to
+`pdf()` and the two agree, because the pdf target runs this layout and paints its list.
+
+## Painting on a canvas
+
+```js
+import { hit, paint } from "@quario/layout";
+
+const canvas = document.querySelector("canvas");
+const page = list.pages[0];
+canvas.width = page.width * 2; // 2 device pixels per point
+canvas.height = page.height * 2;
+await paint(canvas.getContext("2d"), page, { scale: 2, fonts });
+
+hit(page, x, y); // -> { path, x, y, w, h } or null
+```
+
+`paint` draws a white page and every op in order. Images are decoded from the bytes on the list —
+no `img-src` grant, no URLs. `hit` answers which schema node was drawn at a point: the smallest box
+containing it.
+
+Text is drawn in the face the document will use. A family you pass as `fonts` is registered as a
+`FontFace` from your own bytes, and its runs are drawn as the browser shapes them — the same
+shaping the PDF gets from the same file, so ligatures, joined scripts and accents look on screen
+the way they will on paper. Text in the built-in families is drawn character by character at the
+measured advances, because the typeface a browser has for Helvetica, Times or Courier only stands
+in for the one the PDF writes, and without the correction a line would drift as it ran.
+
+Inside a single run of a family you supply, the preview is not promised to place glyphs exactly
+where the PDF does: both read a glyph's own advance and neither applies the font's GPOS
+positioning, so a browser may kern by a fraction more. Where a line breaks, how wide a column is,
+and where a page ends are the layout's — one measurer, so preview and document agree.
+
+`PX_PER_POINT` is how big a point is on screen — 96 dpi over PostScript's 72 — so a surface showing
+a page at 100% sizes its canvas `page.width * PX_PER_POINT` CSS pixels wide and paints at
+`PX_PER_POINT * devicePixelRatio`. Any zoom is a factor on top of that.
+
+## License
+
+quario is commercial software; evaluation is free and fully featured, with output marked as
+unlicensed. See [LICENSE](https://getquario.com/license).

package/lib/balance.js

@@ -0,0 +1,90 @@
+// The one number a balanced region decides: how tall each of its strips is
+// (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
+// does not divide: a group instance, a table row and an image each move whole.
+// A share that is not a whole number of them holds one fewer than it should,
+// and the page-bounded last strip absorbs the remainder (beads `quario-s5c`,
+// `quario-cgk`). So the height is not `measured / count` but the shortest
+// whole-line height at which placing the units in order lands them all in
+// `count` strips.
+//
+// The candidates are line multiples, for the reason the average was rounded to
+// one before this: a floor cuts between lines, so a height that is not a whole
+// number of them leaves every strip a fraction short. They are scanned from the
+// shortest upward rather than searched, because the range is bounded by the
+// lines a page holds and a scan owes nothing to an argument about the fill
+// being monotone in the height. The average is not the starting point and not
+// a lower bound: an instance drops its opening gap at a strip head, so `count`
+// of those gaps are measured that no strip ever pays.
+
+// A **unit** is one thing a strip places: `h` is what it costs mid-strip and
+// `head` what it costs when it is the first thing in a strip — which can be
+// less (a group instance drops its opening gap there) or more (a table row
+// pays for the column headings restated above it). `whole` units move
+// undivided and are the only ones `head` is read for; the rest flow, and
+// nothing that flows costs a different amount for opening a strip. What fills each of these in is the caller's, in
+// `layout.js`, which is also where the model's stated limits are.
+/**
+ * @typedef {{ whole: boolean, h: number, head: number }} Unit
+ */
+// How far one trial has filled: the strips it has opened and the height taken
+// out of the one it is in.
+/**
+ * @typedef {{ strips: number, used: number }} Fill
+ */
+
+// The height, or `null` when no candidate packs the units into `count` strips
+// and the region should fill instead. `room` is what one strip could hold at
+// most — the page — and `line` the height a floor cuts on.
+/** @type {(units: Unit[], count: number, room: number, line: number) => number | null} */
+export let balance = (units, count, room, line) => {
+  for (let lines = 1; lines * line <= room; lines++) {
+    let height = lines * line;
+    if (stripsFor(units, height) <= count) return height;
+  }
+  return null;
+};
+
+// How many strips this height needs. `Infinity` when a unit is too tall for a
+// strip of it at all — the scan answers that by looking higher, and the region
+// fills once even the page is too short.
+// The only way a height fails outright is a whole unit taller than a strip of
+// it, so that case is answered here rather than through a result both helpers
+// would have to carry.
+/** @type {(units: Unit[], height: number) => number} */
+let stripsFor = (units, height) => {
+  /** @type {Fill} */
+  let fill = { strips: 1, used: 0 };
+  for (let unit of units) {
+    if (!unit.whole) placeFlow(fill, unit, height);
+    else if (unit.head > height) return Infinity;
+    else placeWhole(fill, unit, height);
+  }
+  return fill.strips;
+};
+
+// A whole unit that would cross the floor opens the next strip instead, where
+// its opening gap is dropped — the rule `breaksFor` applies during the replay.
+/** @type {(fill: Fill, unit: Unit, height: number) => void} */
+let placeWhole = (fill, unit, height) => {
+  if (!fill.used) fill.used = unit.head;
+  else if (fill.used + unit.h <= height) fill.used += unit.h;
+  else {
+    fill.strips++;
+    fill.used = unit.head;
+  }
+};
+
+// Breakable content fills to the floor and continues in the next strip, so it
+// spills across as many as it takes rather than moving whole. No height is too
+// short for it: content that splits always goes somewhere.
+/** @type {(fill: Fill, unit: Unit, height: number) => void} */
+let placeFlow = (fill, unit, height) => {
+  fill.used += unit.h;
+  while (fill.used > height) {
+    fill.strips++;
+    fill.used -= height;
+  }
+};

package/lib/box.js

@@ -0,0 +1,143 @@
+/**
+ * The box model the layout honours: per-side padding and border, border-box,
+ * no collapse. Cell omakase (PADX / PADY) applies only where the author named
+ * no padding on that side; a named 0 wins. A border side contributes only when
+ * width, style and colour all resolve and width is positive — an incomplete
+ * result at render is nothing, not a solid black stroke.
+ */
+import { PADX, PADY, col } from "./style.js";
+
+let SIDES = ["Top", "Right", "Bottom", "Left"];
+/** @type {Record<string, number[] | null>} */
+let DASH = { solid: null, dashed: [3, 2], dotted: [1, 1.5] };
+
+/** @typedef {{ t: number, r: number, b: number, l: number }} Inset */
+
+/** @type {Inset} */
+let CELL_PAD = { t: PADY, r: PADX, b: PADY, l: PADX };
+/** @type {Inset} */
+let NO_PAD = { t: 0, r: 0, b: 0, l: 0 };
+
+/** @type {(name: string) => boolean} */
+let isBox = (name) => name.startsWith("padding") || name.startsWith("border");
+
+/** @type {(style: any) => any} */
+let unbox = (style) => {
+  if (!style) return style;
+  let names = Object.keys(style).filter((name) => !isBox(name));
+  if (!names.length) return null;
+  return Object.fromEntries(names.map((name) => [name, style[name]]));
+};
+
+/** @type {(style: any, side: string, fallback: number) => number} */
+let padOf = (style, side, fallback) => {
+  let value = style?.["padding" + side];
+  return Number.isFinite(value) && value >= 0 ? value : fallback;
+};
+
+/** @type {(width: any) => boolean} */
+let isStroke = (width) => Number.isFinite(width) && width > 0;
+/** @type {(line: any) => boolean} */
+let isLine = (line) => typeof line === "string" && Object.hasOwn(DASH, line);
+
+/**
+ * @type {(width: any, line: any, color: any) =>
+ *   { width: number, dash: number[] | null, color: any } | null}
+ */
+let strokeOf = (width, line, color) => {
+  if (!isStroke(width) || !isLine(line) || !color) return null;
+  return { width, dash: DASH[line], color };
+};
+
+/**
+ * @type {(style: any, side: string) =>
+ *   { width: number, dash: number[] | null, color: any } | null}
+ */
+let edgeOf = (style, side) => {
+  if (!style) return null;
+  return strokeOf(
+    style["border" + side + "Width"],
+    style["border" + side + "Style"],
+    col(style["border" + side + "Color"]),
+  );
+};
+
+/** @type {(style: any, side: string) => number} */
+let thick = (style, side) => {
+  let edge = edgeOf(style, side);
+  return edge ? edge.width : 0;
+};
+
+/** @type {(style: any, side: string, fallback: number) => number} */
+let inset = (style, side, fallback) => padOf(style, side, fallback) + thick(style, side);
+
+/** @type {(style: any, omakase: Inset) => Inset} */
+let insetOf = (style, omakase) => ({
+  t: inset(style, "Top", omakase.t),
+  r: inset(style, "Right", omakase.r),
+  b: inset(style, "Bottom", omakase.b),
+  l: inset(style, "Left", omakase.l),
+});
+
+/** Endpoints of one inner-centred edge, as stroke() takes them. */
+/** @type {Record<string, (x: number, yTop: number, w: number, h: number, half: number) => number[]>} */
+let SPAN = {
+  Top: (x, yTop, w, _h, half) => [x, yTop - half, x + w, yTop - half],
+  Bottom: (x, yTop, w, h, half) => [x, yTop - h + half, x + w, yTop - h + half],
+  Left: (x, yTop, _w, h, half) => [x + half, yTop, x + half, yTop - h],
+  Right: (x, yTop, w, h, half) => [x + w - half, yTop, x + w - half, yTop - h],
+};
+
+/** @type {(canvas: { stroke: Function }, x: number, yTop: number, w: number, h: number, style: any, side: string) => void} */
+let paintEdge = (canvas, x, yTop, w, h, style, side) => {
+  let edge = edgeOf(style, side);
+  if (!edge) return;
+  canvas.stroke(...SPAN[side](x, yTop, w, h, edge.width / 2), edge.width, edge.color, edge.dash);
+};
+
+/**
+ * Which slice of a broken box is being drawn. The whole box is the degenerate
+ * case: the first slice, with nothing to come, so it owns all four sides.
+ * `first`/`more` are the pair `vPad` measures with, so the ink a slice lays
+ * down and the height it was given come from one answer.
+ *
+ * @typedef {{ first: boolean, more: boolean }} Slice
+ */
+
+/** @type {Slice} */
+let WHOLE = { first: true, more: false };
+
+// The sides one slice still owns. Left and right belong to every slice; the
+// top is the first slice's and the bottom the last's, so a middle slice
+// strokes neither and no edge is ever laid down the middle of the box's own
+// content.
+/** @type {(slice: Slice) => string[]} */
+let sidesOf = ({ first, more }) =>
+  SIDES.filter((side) => (side === "Top" ? first : side === "Bottom" ? !more : true));
+
+// The same rule, as inset rather than ink: a slice is padded only on the ends
+// it owns, so its lines run flush to the break while its left and right
+// padding stay.
+/** @type {(inset: Inset, slice: Slice) => Inset} */
+let sliceInset = (inset, { first, more }) => ({
+  t: first ? inset.t : 0,
+  r: inset.r,
+  b: more ? 0 : inset.b,
+  l: inset.l,
+});
+
+/**
+ * Fill and stroke one border-box. Background is the whole rect; each edge
+ * sits inside it, centred on its own width, so a stroke does not spill past
+ * the box the caller measured. A caller drawing one slice of a box broken
+ * across pages passes which slice it is; the rest get `WHOLE`.
+ *
+ * @type {(canvas: { rect: Function, stroke: Function }, x: number, yTop: number,
+ *   w: number, h: number, style: any, bg: any, slice?: Slice) => void}
+ */
+let paintBox = (canvas, x, yTop, w, h, style, bg, slice = WHOLE) => {
+  if (bg) canvas.rect(bg, x, yTop - h, w, h);
+  if (style) for (let side of sidesOf(slice)) paintEdge(canvas, x, yTop, w, h, style, side);
+};
+
+export { CELL_PAD, NO_PAD, WHOLE, insetOf, paintBox, sliceInset, unbox };