@casomoltd/tooling 0.21.2 → 0.22.0

package/README.md

@@ -26,6 +26,7 @@ Shared linting, formatting, commit config, and CLI tools for Casomo Ltd's repos.
 | `commit-msg` | Husky commit-msg hook — runs commitlint |
 | `readability` | Measure reading difficulty of page content |
 | `screenshot` | Capture a dev server page via Puppeteer |
+| `build-report` | Compile a Typst client report to PDF with the house template |
 
 ## Install
 
@@ -131,6 +132,56 @@ Add these scripts to your `package.json`:
 Screenshots are saved to `.claude/screenshots/`. Set
 `SCREENSHOT_URL` to override the default `http://localhost:3000`.
 
+## Client reports (Typst)
+
+`report/` ships the Casomo house style for client-facing PDF reports —
+a [Typst](https://typst.app) template (`casomo-template.typ`, with the
+brand mark beside it) plus the `build-report` bin that compiles a
+report to PDF:
+
+```bash
+npx build-report path/to/report.typ                # → scratch (see below)
+npx build-report report.typ -o public/report.pdf   # explicit output path
+npx build-report report.typ --watch                # recompile on save
+npx build-report report.typ --open                 # open the PDF when done
+```
+
+The compiled PDF is a build artefact, so it defaults to the same scratch
+resolution as the agent reports (see *Report output & `SCRATCH_DIR`*
+under Agents): `$SCRATCH_DIR/reports/<name>.pdf`, or
+`<repo-root>/scratch/reports/` when `SCRATCH_DIR` is unset — add
+`scratch/` to the consumer repo's `.gitignore` (this repo does). Pass
+`--out` only when the PDF is a deliverable the repo actually keeps
+(e.g. a site's `public/`).
+
+A report imports the template and applies it as a show rule; everything
+after is the body. From a consumer repo the import goes through
+`node_modules` (the bin sets the Typst root to the nearest
+`package.json`/`.git` ancestor so the path resolves):
+
+```typst
+#import "/node_modules/@casomoltd/tooling/report/casomo-template.typ": casomo-report, band
+
+#show: casomo-report.with(
+  kicker: "Delivery Report & Findings",
+  title: "The Report Title",
+  subtitle: "One-line summary.",  // optional
+)
+
+= Executive summary
+…
+```
+
+`report/example.typ` is a lorem-ipsum reference report exercising every
+feature the template styles — compile it to see the house style.
+
+Two prerequisites are external to npm (like puppeteer for
+`screenshot`, they are deliberately not dependencies): the **`typst`
+CLI** on PATH (`snap install typst` / `cargo install typst-cli`) and
+the **IBM Plex Sans / IBM Plex Mono** fonts
+([github.com/IBM/plex](https://github.com/IBM/plex)) — `build-report`
+fails loud on the former and warns on the latter.
+
 ## Quality gates
 
 There is no CI — all quality gates run locally via git hooks.
@@ -208,6 +259,7 @@ decision table) that keeps these units composing without overlap.
 | `/casomoltd:design-pass` | Map → review → refactor a package (drives `design-xray` + `code-review`) |
 | `/casomoltd:draft-design-spec` | Author a browser-reviewable HTML design spec from a brief and iterate on it before writing code (drives `design-xray`) |
 | `/casomoltd:page-design` | Structure a content/explainer page for trust — above-the-fold answer, disclosure, palette-only colour (rubric a page-design reviewer preloads) |
+| `/casomoltd:generate-report` | Scaffold a Typst client report from the house template, compile via `build-report`, verify the PDF |
 
 Enable the plugin by adding this repo as a marketplace and installing it:
 

package/bin/build-report.mjs

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+
+/**
+ * Compile a Typst client report to PDF with the Casomo house template.
+ *
+ * Usage:
+ *   build-report <report.typ> [--out <file.pdf>] [--watch] [--open]
+ *
+ * Arguments:
+ *   report.typ  The report source. It imports the house template
+ *               (report/casomo-template.typ in this package).
+ *
+ * Options:
+ *   --out, -o <file>  Output PDF path. Default follows the README's report
+ *                     output rule: $SCRATCH_DIR/reports/<name>.pdf, or
+ *                     <repo-root>/scratch/reports/ when unset (gitignore
+ *                     scratch/ in the consumer repo).
+ *   --root <dir>      Typst compile root (default: auto-detected, see below)
+ *   --watch           Recompile on save (typst watch)
+ *   --open            Open the PDF after a successful compile (ignored with
+ *                     --watch)
+ *
+ * Requirements (not npm-managed):
+ *   - the `typst` CLI on PATH (https://typst.app)
+ *   - the IBM Plex Sans / IBM Plex Mono fonts installed
+ */
+
+import {parseArgs} from "node:util";
+import {spawnSync} from "node:child_process";
+import path from "node:path";
+import fs from "node:fs";
+import {openPath} from "./utils.mjs";
+
+const {values, positionals} = parseArgs({
+  options: {
+    out: {type: "string", short: "o"},
+    root: {type: "string"},
+    watch: {type: "boolean", default: false},
+    open: {type: "boolean", default: false},
+  },
+  allowPositionals: true,
+});
+
+function fail(message) {
+  console.error(`build-report: ${message}`);
+  process.exit(1);
+}
+
+if (!positionals[0]) {
+  fail("usage: build-report <report.typ> [--out <file.pdf>] [--watch] [--open]");
+}
+const input = path.resolve(positionals[0]);
+if (!fs.existsSync(input)) fail(`no such file: ${input}`);
+if (path.extname(input) !== ".typ") fail(`expected a .typ source, got: ${input}`);
+
+// Typst refuses to read files outside its --root, and a report imports the
+// template as "/node_modules/@casomoltd/tooling/report/casomo-template.typ".
+// Prefer the ancestor whose node_modules actually holds this package — in a
+// hoisted/workspace layout that is higher than the report's own package.json —
+// falling back to the nearest package.json/.git ancestor (this repo itself,
+// where the example imports the template relative). No marker at all is an
+// error: compiling on with a wrong root would only surface later as a
+// confusing Typst import failure.
+function findRoot(from) {
+  const packageDir = path.join("node_modules", "@casomoltd", "tooling", "report");
+  let marker = null;
+  let dir = path.dirname(from);
+  for (;;) {
+    if (fs.existsSync(path.join(dir, packageDir))) return dir;
+    if (
+      marker === null &&
+      (fs.existsSync(path.join(dir, "package.json")) ||
+        fs.existsSync(path.join(dir, ".git")))
+    ) {
+      marker = dir;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  if (marker) return marker;
+  fail("no repo root found above the input (package.json/.git) — pass --root <dir>");
+}
+const root = values.root ? path.resolve(values.root) : findRoot(input);
+
+// typst is an external native binary (like puppeteer for screenshot, it is
+// deliberately not an npm dependency). One probe does double duty: ENOENT
+// means typst is missing; otherwise the output feeds the font check. Missing
+// fonts don't fail a Typst compile — it silently falls back and the PDF comes
+// out off-brand — so warn loud up front.
+const fonts = spawnSync("typst", ["fonts"], {encoding: "utf8"});
+if (fonts.error) {
+  fail(
+    "the `typst` CLI is not on PATH — install it first " +
+      "(https://typst.app, e.g. `snap install typst` or `cargo install typst-cli`).",
+  );
+}
+if (fonts.status === 0) {
+  const families = new Set(fonts.stdout.split(/\r?\n/));
+  // Keep in sync with the faces report/tokens.typ names.
+  for (const family of ["IBM Plex Sans", "IBM Plex Mono"]) {
+    if (!families.has(family)) {
+      console.warn(
+        `build-report: font "${family}" not found — the PDF will use a ` +
+          "fallback font. Install IBM Plex: https://github.com/IBM/plex",
+      );
+    }
+  }
+} else {
+  console.warn("build-report: could not verify fonts (`typst fonts` failed)");
+}
+
+// A compiled PDF is a throwaway build artefact, not a source — default it to
+// the shared scratch pool, same resolution order as the agent reports (README
+// "Report output & SCRATCH_DIR"): $SCRATCH_DIR/reports/, else a repo-local
+// scratch/reports/. --out opts out for deliverables a repo serves.
+const output = values.out
+  ? path.resolve(values.out)
+  : path.join(
+      path.resolve(process.env.SCRATCH_DIR || path.join(root, "scratch")),
+      "reports",
+      path.basename(input, ".typ") + ".pdf",
+    );
+fs.mkdirSync(path.dirname(output), {recursive: true});
+
+const mode = values.watch ? "watch" : "compile";
+const result = spawnSync("typst", [mode, "--root", root, input, output], {
+  stdio: "inherit",
+});
+if (result.status !== 0) process.exit(result.status ?? 1);
+
+// typst watch narrates its own recompiles and only returns on interrupt, so
+// the post-compile tail is for single compiles only.
+if (!values.watch) {
+  console.log(`Report compiled: ${output}`);
+  if (values.open) openPath(output);
+}

package/bin/render-report.mjs

@@ -22,9 +22,9 @@
  *   0  HTML written (and opened unless --no-open)
  *   1  Bad arguments or the input file is missing
  */
-import {spawn} from "node:child_process";
 import {existsSync, readFileSync, writeFileSync} from "node:fs";
 import {resolve} from "node:path";
+import {openPath} from "./utils.mjs";
 
 const args = process.argv.slice(2);
 const noOpen = args.includes("--no-open");
@@ -110,9 +110,5 @@ const url = `file://${resolve(htmlPath)}`;
 console.log(url);
 
 if (!noOpen) {
-  // text/html must be associated with a browser, not a mail client; if the
-  // opener mis-routes on Linux, run e.g.
-  //   xdg-mime default firefox_firefox.desktop text/html
-  const opener = process.platform === "darwin" ? "open" : "xdg-open";
-  spawn(opener, [url], {detached: true, stdio: "ignore"}).unref();
+  openPath(url);
 }

package/bin/utils.mjs

@@ -2,10 +2,23 @@
  * Shared helpers for CLI bin scripts.
  */
 
+import {spawn} from "node:child_process";
 import path from "node:path";
 import fs from "node:fs";
 import {pathToFileURL} from "node:url";
 
+/**
+ * Open a file or URL with the platform opener, detached so the CLI can exit.
+ *
+ * text/html must be associated with a browser, not a mail client; if the
+ * opener mis-routes on Linux, run e.g.
+ *   xdg-mime default firefox_firefox.desktop text/html
+ */
+export function openPath(target) {
+  const opener = process.platform === "darwin" ? "open" : "xdg-open";
+  spawn(opener, [target], {detached: true, stdio: "ignore"}).unref();
+}
+
 /**
  * Load an optional per-repo config file from cwd.
  *

package/bin/verify-pack.mjs

@@ -17,6 +17,7 @@ const ALLOWED_PREFIXES = [
   "knip/",
   "jscpd/",
   "readability/",
+  "report/",
 ];
 const ALLOWED_FILES = ["README.md", "package.json", "LICENSE", "LICENSE.md"];
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@casomoltd/tooling",
-  "version": "0.21.2",
+  "version": "0.22.0",
   "description": "Casomo's shared dev config: ESLint, Prettier, commitlint, knip & jscpd presets and dev CLIs (git hooks, readability, screenshots)",
   "license": "MIT",
   "repository": {
@@ -15,6 +15,7 @@
     "knip/",
     "jscpd/",
     "readability/",
+    "report/",
     "README.md"
   ],
   "scripts": {
@@ -33,6 +34,7 @@
     "./readability": "./readability/index.mjs"
   },
   "bin": {
+    "build-report": "./bin/build-report.mjs",
     "check-tags": "./bin/check-tags.sh",
     "check-version": "./bin/check-version.sh",
     "commit-msg": "./bin/commit-msg.sh",

package/report/casomo-arrow-white.svg

@@ -0,0 +1,14 @@
+<svg viewBox="0 0 135.467 135.467" xmlns="http://www.w3.org/2000/svg">
+  <path
+    fill="none"
+    stroke="#fff"
+    stroke-width="10.583"
+    stroke-linecap="round"
+    stroke-linejoin="round"
+    d="M 27.752,77.13
+      118.744,77.565
+      66.064,36.496
+      67.733,58.482
+      27.68,58.337 Z"
+  />
+</svg>

package/report/casomo-template.typ

@@ -0,0 +1,66 @@
+// casomo-template.typ — shared house style for Casomo client reports.
+//
+// The single import point. Internals live in the sibling component files —
+// tokens.typ (fonts, rule weights, legal identity) · styles.typ (document
+// type rules) · table.typ (flat tables) · components.typ (band, callout,
+// keyfig, num) · mark.typ (brand mark) · footer.typ · cover.typ — and this
+// file re-exports the author-facing API, so a report needs only:
+//
+//   #import "casomo-template.typ": casomo-report, band, callout, keyfig, num
+//   #show: casomo-report.with(
+//     kicker: "Delivery Report & Findings",
+//     title: "The Report Title",
+//     subtitle: "One-line summary of what was delivered.",  // optional
+//   )
+//
+//   = Executive summary
+//   …
+//
+// Components follow the house minimal direction — flat, hairline dividers,
+// one separation device per element — translated to the report's own
+// identity: monochrome, IBM Plex. Conventions transfer; the site's palette
+// and web faces do not.
+//
+// Asset paths resolve relative to the file using them, so the report/ files
+// stay together as one directory. Importers only need this directory inside
+// the compile root (`typst compile --root …` — the `build-report` bin sets
+// this). Compile with `build-report <report.typ>`; needs the `typst` CLI
+// plus the IBM Plex Sans / IBM Plex Mono fonts installed.
+
+#import "components.typ": band, callout, keyfig, num
+#import "styles.typ": document-styles
+#import "table.typ": table-styles
+#import "footer.typ": report-footer
+#import "cover.typ": cover-page
+
+#let casomo-report(
+  kicker: none,
+  title: none,
+  subtitle: none,
+  author: "David Mohamad",
+  email: "info@casomoltd.com",
+  body,
+) = {
+  // Copyright year tracks the compile date — a report is (re)issued when it is
+  // (re)compiled, so the year is never stale.
+  let year = datetime.today().display("[year]")
+
+  show: document-styles
+  show: table-styles
+
+  set page(
+    paper: "a4",
+    margin: (top: 2.5cm, bottom: 2.5cm, left: 2.5cm, right: 2.5cm),
+    header: none,
+    footer: report-footer(year),
+  )
+
+  cover-page(kicker, title, subtitle, author, email, year)
+
+  // --- Table of contents ---
+  page[
+    #outline(title: "Contents", indent: auto, depth: 2)
+  ]
+
+  body
+}

package/report/components.typ

@@ -0,0 +1,56 @@
+// components.typ — the author-facing body components: band dividers, mono
+// figures, callouts, and key figures. (How a band heading *renders* lives
+// with the other heading rules in styles.typ; this file owns the semantics.)
+#import "tokens.typ": mono-font, intent-bar
+
+// Band dividers — unnumbered group headers that organise the contents and the
+// body into sections (e.g. Delivery / Advisories / Decisions / Hand-over)
+// without numbers and without disturbing the 1..N section numbering. Optional:
+// reports that don't want grouped sections simply never call band().
+#let band(title, note: none) = {
+  heading(level: 1, numbering: none, outlined: true)[#title]
+  if note != none {
+    text(size: 9.5pt, style: "italic", fill: luma(110))[#note]
+    v(0.1em)
+  }
+}
+
+// Figures set in IBM Plex Mono so numerals read as data and align
+// digit-for-digit down a column; labels and prose stay in Plex Sans. Sized
+// down slightly to match the sans x-height. Use in numeric table cells and
+// for inline figures: num[£29,970].
+#let num(value) = text(font: mono-font, size: 0.92em, value)
+
+// A note the reader must not miss — a thick left bar carries the emphasis,
+// no box, no fill. `label` bolds the intent: callout(label: "Warning:")[…].
+#let callout(body, label: none) = block(
+  above: 1.3em,
+  below: 1.3em,
+  width: 100%,
+  stroke: (left: intent-bar),
+  inset: (left: 12pt, top: 3pt, bottom: 3pt),
+  {
+    set text(size: 10pt)
+    set par(justify: false)
+    if label != none {
+      strong(label)
+      h(0.4em)
+    }
+    body
+  },
+)
+
+// A lifted headline metric — big mono figure over a muted caption, carried
+// by the same left bar: keyfig("£30,639", [Band 5, top of scale]).
+#let keyfig(value, caption) = block(
+  above: 1.4em,
+  below: 1.4em,
+  stroke: (left: intent-bar),
+  inset: (left: 12pt, top: 2pt, bottom: 2pt),
+  {
+    text(font: mono-font, weight: 700, size: 20pt, value)
+    linebreak()
+    v(1pt)
+    text(size: 9.5pt, fill: luma(110), caption)
+  },
+)

package/report/cover.typ

@@ -0,0 +1,38 @@
+// cover.typ — the cover page: kicker over the title, the author block, and
+// the brand badge with the legal line. Suppresses the running footer.
+#import "tokens.typ": sans-font, company-name, company-registration
+#import "mark.typ": casomo-mark
+
+#let cover-page(kicker, title, subtitle, author, email, year) = page(footer: [])[
+  #set text(font: sans-font)
+
+  #v(1fr)
+
+  #text(size: 12pt, fill: luma(100))[#kicker]
+  #v(8pt)
+  #text(size: 28pt, weight: "bold")[#title]
+  #if subtitle != none {
+    v(10pt)
+    text(size: 12pt, fill: luma(100))[#subtitle]
+  }
+
+  #v(24pt)
+  #text(size: 11pt, fill: luma(80))[
+    Author: #author \
+    Email: #link("mailto:" + email)[#email] \
+    Prepared on #datetime.today().display("[day] [month repr:long] [year]")
+  ]
+
+  #v(1fr)
+
+  #grid(
+    columns: (28pt, 1fr),
+    column-gutter: 12pt,
+    align: (horizon, horizon),
+    casomo-mark(size: 28pt, arrow: 20pt, radius: 5pt),
+    text(size: 10pt)[
+      #sym.copyright #year #company-name \
+      #company-registration
+    ],
+  )
+]

package/report/example.typ

@@ -0,0 +1,88 @@
+// example.typ — lorem-ipsum reference report for the Casomo house template.
+//
+// Exercises every structural feature the template styles (cover, contents,
+// band dividers, numbered headings to depth 3, lists, flat tables with mono
+// numerals, callouts, key figures, code, figures, links, cross-references)
+// so a single compile verifies the whole style.
+//
+//   build-report report/example.typ
+
+#import "casomo-template.typ": casomo-report, band, callout, keyfig, num
+
+#show: casomo-report.with(
+  kicker: "Example Report — Template Reference",
+  title: "Lorem Ipsum Dolor Sit Amet",
+  subtitle: "A placeholder report exercising every feature of the Casomo house style.",
+)
+
+= Executive summary
+
+#lorem(60)
+
+- *First finding* — #lorem(18)
+- *Second finding* — #lorem(22)
+- *Third finding* — #lorem(15)
+
+#keyfig("£30,639", [Lorem ipsum dolor sit amet — the headline metric, lifted.])
+
+#callout(label: "Note:")[#lorem(28)]
+
+#band("Part One", note: "Band dividers group sections without disturbing numbering.")
+
+= Background
+
+#lorem(70)
+
+== Prior work
+
+#lorem(45) See @approach for how this shaped the approach, or the
+#link("https://www.casomoltd.com")[Casomo website] for context.
+
+== Constraints
+
++ #lorem(14)
++ #lorem(16)
++ #lorem(12)
+
+= Approach <approach>
+
+#lorem(50)
+
+== Method detail
+
+#lorem(30)
+
+```ts
+export function loremIpsum(dolor: string): string {
+  return `sit amet, ${dolor} adipiscing elit`;
+}
+```
+
+#band("Part Two")
+
+= Results
+
+#lorem(40)
+
+#figure(
+  table(
+    columns: (auto, 1fr, auto, auto),
+    align: (left, left, right, right),
+    table.header([Item], [Description], [Annual], [Monthly]),
+    [Alpha], [#lorem(8)], num[£29,970], num[£2,497.50],
+    [Beta], [#lorem(9)], num[£31,876], num[£2,656.33],
+    [Gamma], [#lorem(7)], num[£36,483], num[£3,040.25],
+  ),
+  caption: [#lorem(16)],
+) <results-table>
+
+#lorem(35) The headline figures sit in @results-table.
+
+#callout(label: "Warning:")[#lorem(20)]
+
+= Recommendations
+
+#lorem(30)
+
+- #lorem(20)
+- #lorem(17)

package/report/footer.typ

@@ -0,0 +1,15 @@
+// footer.typ — the running page footer: brand mark, legal line, page X / N.
+#import "tokens.typ": sans-font, company-name, company-registration
+#import "mark.typ": casomo-mark
+
+#let report-footer(year) = context {
+  set text(size: 9pt, font: sans-font)
+  grid(
+    columns: (20pt, 1fr, auto),
+    column-gutter: 8pt,
+    align: (horizon, horizon, horizon),
+    casomo-mark(),
+    [#sym.copyright #year #company-name, #company-registration],
+    [#counter(page).display() / #counter(page).final().first()],
+  )
+}

package/report/mark.typ

@@ -0,0 +1,13 @@
+// mark.typ — the brand mark: the white arrow clipped in a black rounded
+// square. One definition renders both placements (footer small, cover large).
+// The SVG path resolves relative to this file, so both stay in report/.
+#let casomo-mark(size: 20pt, arrow: 14pt, radius: 4pt) = box(
+  width: size,
+  height: size,
+  radius: radius,
+  fill: black,
+  clip: true,
+  align(center + horizon)[
+    #image("casomo-arrow-white.svg", width: arrow)
+  ],
+)

package/report/styles.typ

@@ -0,0 +1,56 @@
+// styles.typ — the document-wide type rules: base faces, paragraph rhythm,
+// the heading scale (including how a band() divider renders), list spacing,
+// link/ref colour, and figure captions. Table rules live in table.typ.
+#import "tokens.typ": sans-font, mono-font
+
+#let document-styles(body) = {
+  // Faces — tokens.typ owns the names; build-report.mjs preflights them.
+  set text(font: sans-font, size: 11.5pt)
+  set par(justify: true, leading: 0.95em)
+  set heading(numbering: "1.1")
+  show raw: set text(font: mono-font)
+
+  // Lists: a broader marker and a clear gap between items, so multi-line
+  // bullet items read as distinct points rather than blending into one block.
+  // The inter-item spacing is deliberately wider than the in-item leading.
+  set list(marker: text(size: 1.15em, fill: luma(55))[•], spacing: 1.15em)
+  set enum(spacing: 1.15em)
+
+  // Numbered headings get a size by level; an unnumbered level-1 heading is a
+  // band() group divider (components.typ), rendered as a smallcaps label with
+  // a rule across the page. Reports that never call band() only ever hit the
+  // numbered branch.
+  show heading: it => {
+    if it.numbering == none {
+      block(above: 1.6em, below: 0.7em, width: 100%, breakable: false)[
+        #set text(size: 14pt, weight: "bold", fill: luma(70))
+        #grid(
+          columns: (auto, 1fr),
+          align: (left + horizon, horizon),
+          column-gutter: 10pt,
+          smallcaps(it.body),
+          line(length: 100%, stroke: 0.6pt + luma(180)),
+        )
+      ]
+    } else {
+      let size = if it.level == 1 { 16pt } else if it.level == 2 { 13pt } else { 11pt }
+      set text(size: size)
+      it
+    }
+  }
+  show outline.entry.where(level: 1): it => {
+    if it.element.numbering == none {
+      v(11pt, weak: true)
+      strong(smallcaps(it.element.body))
+    } else {
+      it
+    }
+  }
+  show link: set text(fill: rgb("#0000cc"))
+  show ref: set text(fill: rgb("#0000cc"))
+  show figure.caption: set text(size: 9.5pt, style: "italic", fill: luma(110))
+  show figure.caption: set par(justify: true)
+  show figure.caption: set align(left)
+
+  body
+}

package/report/table.typ

@@ -0,0 +1,17 @@
+// table.typ — flat table rules: a strong rule under the header row, hairlines
+// between body rows, no vertical strokes, no outer box, no zebra, no fills.
+// The first row is styled as the header, so open every table with
+// table.header(). Right-align numeric columns via the table's `align` and set
+// the cells with num().
+#import "tokens.typ": strong-rule, hairline
+
+#let table-styles(body) = {
+  set table(
+    stroke: (x, y) => if y == 0 { (bottom: strong-rule) } else { (bottom: hairline) },
+    inset: (x: 10pt, y: 7pt),
+  )
+  show table.cell.where(y: 0): set text(weight: 600, size: 10pt)
+  // Body-par justification stretches badly in narrow cells — tables rag right.
+  show table.cell: set par(justify: false)
+  body
+}

package/report/tokens.typ

@@ -0,0 +1,17 @@
+// tokens.typ — the shared constants every report component reads.
+
+// Faces — checked by bin/build-report.mjs's font preflight; keep in sync.
+#let sans-font = "IBM Plex Sans"
+#let mono-font = "IBM Plex Mono"
+
+// The whole style runs on three separation weights: a strong rule (table
+// headers), a hairline (row separators), and an intent bar (callouts / key
+// figures). Anything heavier — boxes, fills, zebra striping — is deliberately
+// absent: the house minimal direction, one separation device per element.
+#let strong-rule = 1pt + black
+#let hairline = 0.5pt + luma(200)
+#let intent-bar = 2.5pt + black
+
+// The legal identity, printed by both the footer and the cover.
+#let company-name = "Casomo Ltd"
+#let company-registration = "Registered in the UK, 15030496"