@jokerized/decksmith 0.1.0

package/dist/types/emit/kit.d.ts

@@ -0,0 +1,256 @@
+/**
+ * The seam between the deck shell and the explanatory vocabulary.
+ *
+ * `composition.ts` owns the document: head, theme CSS, scene wrappers, the root
+ * timeline, the slideshow island. An archetype emitter owns one scene's insides
+ * and nothing else. Adding a domain means adding an emitter — the shell never
+ * learns what a camera frustum or an orderbook is.
+ */
+import type { Archetype, BeatOf, Format, Source } from "../types.js";
+/**
+ * `.scene`'s padding, in reference px. `contentW`/`contentH` are what is left.
+ *
+ * They live here rather than in `theme.ts` or `title.ts` because both of those
+ * need them and neither may import the other: `baseCss` writes the padding into
+ * the stylesheet, every archetype does arithmetic against what is left. They
+ * were the same two numbers in both places by maintenance rather than by
+ * construction, and a stylesheet that disagrees with the arithmetic clips at the
+ * canvas edge, which no gate reads.
+ */
+export declare const PAD_X = 110;
+export declare const PAD_Y = 84;
+/**
+ * The canvas every absolute measurement in this codebase was chosen against.
+ *
+ * The type scale, the padding, the font floor, the gaps and the stroke weights
+ * were all picked by eye on a 1920x1080 slide. That was fine while 1920x1080 was
+ * the only canvas, and became wrong the moment a second one existed: a 76px
+ * headline is 3.96% of the width at 1920 and 7.04% at 1080, so the same slide
+ * design arrives 78% heavier in portrait. It reads as shouting, and it is why a
+ * vertical deck cannot carry anything complicated — the type has eaten the room
+ * the content needed.
+ */
+export declare const REF_W = 1920;
+/**
+ * HOW FAR A NARROW CANVAS TRAVELS BACK TOWARDS THE REFERENCE ONE. The whole
+ * typographic argument of this file is this one number.
+ *
+ * An archetype lays out in REFERENCE SPACE — one unit system, `refWidth` wide, at
+ * the target's aspect ratio — and `baseCss` scales the finished scene onto the
+ * real canvas exactly once. So every absolute measurement in the vocabulary (the
+ * type scale, the 40px floor, ~171 gap/radius/stroke literals) becomes a fraction
+ * of the canvas rather than a count of its pixels, without any of them being
+ * touched.
+ *
+ * `refWidth = REF_W^k · width^(1-k)`, so:
+ *
+ *   k = 0   reference space IS the canvas. What shipped before this existed.
+ *   k = 1   the portrait deck is the landscape deck, photographically reduced:
+ *           type is the same PERCENTAGE of the width in both.
+ *
+ * k = 1 is the tempting answer and it is too far. Equal percentage-of-width only
+ * means equal legibility if the two screens subtend the same angle, and they do
+ * not: a 13" laptop is ~29cm wide at ~55cm (0.52 rad), a phone ~7cm at ~30cm
+ * (0.23 rad). The phone is worth about half. Halving the angular size of every
+ * glyph to buy room is trading the wrong way — 40px at k=1 lands at 8.1 CSS px on
+ * a 390px-wide phone, which is not text any more.
+ *
+ * k = 1/2 is the geometric mean of the two readings, and it is what the 390px
+ * screenshots support: the floor lands at 30 canvas px (10.8 CSS px on the phone,
+ * against 14.4 today) and the content box grows 1.33x in each direction — 1.78x
+ * the area, which is the room the extra table rows and pipeline stages come from.
+ *
+ * Identity at 1920 for every k, since `1920^k · 1920^(1-k) = 1920`. That is what
+ * keeps the shipping 16:9 deck byte-identical: at k anything, `zoomOf` returns
+ * exactly 1 there and `baseCss` emits no scaling rule at all.
+ */
+export declare const REF_PULL = 0.5;
+/**
+ * The width of the unit system an archetype lays out in.
+ *
+ * Rounded to an integer so `contentW` is an integer and the emitted geometry is
+ * the same kind of number it has always been — `n()` prints two decimals, and a
+ * content box of 1272.7924 would put a long tail on half the coordinates in the
+ * document for no benefit.
+ */
+export declare function refWidth(format: Format): number;
+/**
+ * The reference canvas keeps the TARGET's aspect ratio, not the reference one.
+ *
+ * This is what lets `isPortrait` and every branch under it keep working: the
+ * reference canvas for `short-9x16` is 1440x2560, which is still 9:16. Reference
+ * space is a change of unit, never a change of shape.
+ */
+export declare function refHeight(format: Format): number;
+/**
+ * Reference px per canvas px — what `baseCss` scales the scene by.
+ *
+ * WIDTH, not height and not diagonal. Text wraps against width, so width is what
+ * decides how much a given type size costs; a taller canvas at the same width
+ * buys lines, not room per line.
+ *
+ * Exactly 1 at 1920 wide, because `refWidth` returns exactly 1920 there.
+ */
+export declare function zoomOf(format: Format): number;
+/**
+ * `.scene`'s padding, and the box it leaves an archetype to draw in.
+ *
+ * These live here rather than in `theme.ts` or `title.ts` because both need them
+ * and neither may import the other: `baseCss` writes the padding into the
+ * stylesheet, every archetype does arithmetic against what is left. They were the
+ * same two numbers in both places by maintenance rather than construction, and a
+ * stylesheet that disagrees with the arithmetic clips at the canvas edge, which
+ * no gate reads.
+ *
+ * Reference px, so the gutter is the same FRACTION of every canvas without
+ * anything here knowing the canvas: 110 of 1440 is 110 of 1920 once the scene has
+ * been scaled. A canvas-px gutter took 20.4% of the width at 1080 against 11.5%
+ * at 1920 — nearly twice the proportional margin on the canvas that can least
+ * afford it.
+ */
+export declare function contentW(format: Format): number;
+export declare function contentH(format: Format): number;
+export interface Theme {
+    bg: string;
+    fg: string;
+    muted: string;
+    dim: string;
+    rule: string;
+    panel: string;
+    accent: string;
+    /** Highlight tones, addressed by `tone: "a" | "b" | "c" | "d"`. */
+    tones: {
+        a: string;
+        b: string;
+        c: string;
+        d: string;
+    };
+    fontStack: string;
+}
+export interface EmitContext {
+    source: Source;
+    format: Format;
+    theme: Theme;
+    /**
+     * This scene's root element id, e.g. `"s3"`. Every GSAP selector must be
+     * scoped with it — an unscoped class selector reaches into other scenes and
+     * `hyperframes lint` rejects it (`unscoped_gsap_selector`).
+     */
+    sid: string;
+}
+/**
+ * A value in a GSAP vars payload that is JavaScript rather than data.
+ *
+ * `ease: dsZoom` names a function the scene's own `measure` declared, and
+ * `scale: dsFramed.k` reads a number it measured. Neither is expressible as a
+ * number or a string — a string would be quoted, and `ease: "dsZoom"` is a GSAP
+ * ease NAME that does not exist, so GSAP falls back to `power1.out` and the
+ * camera lands on the wrong curve with every gate green. So raw JS is a distinct
+ * kind of value, spelled at the call site, rather than a string the serialiser
+ * has to guess about.
+ */
+export interface Raw {
+    readonly __raw: string;
+}
+export declare function raw(js: string): Raw;
+export type VarValue = number | string | boolean | Raw | Vars | readonly VarValue[];
+/** A GSAP vars payload — the `{ opacity: 0, y: 14 }` half of a `fromTo`. */
+export interface Vars {
+    readonly [key: string]: VarValue;
+}
+/**
+ * ONE TWEEN. Invariant 2 — "every tween is `fromTo`" — is this interface.
+ *
+ * It used to be a line of GSAP source text, which had three consequences worth
+ * the change. A `from()` was a review question rather than a type error. The
+ * animation vocabulary was invisible to the type checker: `duration` and
+ * `duraiton` were the same string. And `pace()` had to recover the position
+ * argument by running a regex over the emitted statement —
+ * `/,\s*(-?\d*\.?\d+)\s*\)\s*;?\s*$/` — which is a parser for a language nobody
+ * had written a grammar for, sitting on the path every deck's timing goes
+ * through.
+ *
+ * `from` is REQUIRED and there is no other constructor, so a tween that does
+ * not declare where it starts cannot be written down. That is what makes the
+ * invariant checkable by `tsc` instead of by a human reading a diff.
+ *
+ * `at` is a position in seconds from the scene's start, ALREADY ROUNDED by
+ * whoever built the tween (invariant 10). The serialiser prints it and rounds
+ * nothing: two roundings on one number is how a byte moves.
+ */
+export interface Tween {
+    readonly target: string;
+    readonly from: Vars;
+    readonly to: Vars;
+    readonly at: number;
+}
+export declare function fromTo(target: string, from: Vars, to: Vars, at: number): Tween;
+/**
+ * THE ONE PLACE A TWEEN BECOMES GSAP TEXT.
+ *
+ * Byte-for-byte what fifty-eight call sites used to build by hand: one space
+ * inside each brace, `", "` between entries, `key: value`. The spacing is not
+ * cosmetic — the deck's regression test is that two builds of one storyboard
+ * are byte-identical, and the cheapest proof this refactor changed nothing is
+ * that it also matches every build made before it.
+ */
+export declare function tweenText(t: Tween): string;
+export interface Scene {
+    /** The scene's inner HTML. The wrapper `<div class="scene clip">` is added by the shell. */
+    html: string;
+    /**
+     * Tweens appended to this scene's own paused timeline, with times RELATIVE to
+     * the scene's start. `Tween` is a `fromTo` by construction — `from()` records
+     * its end state when the timeline is built and breaks under the arbitrary
+     * seeking that deck navigation performs.
+     */
+    tl: Tween[];
+    /** Statements run as the document parses, before anything else, e.g.
+     * `katex.render(...)`. Anything that CHANGES layout belongs here, so that a
+     * `measure` below reads the finished document. */
+    setup?: string[];
+    /**
+     * SEAM B. Statements run once inside the ready gate's barrier — after
+     * `document.fonts.ready` and after every image has decoded — and immediately
+     * before this scene's timeline is built, in the same closure, so a `tl` entry
+     * can read a variable declared here.
+     *
+     * Declaring any makes the scene DEFERRED: `sceneHtml` wraps the timeline in a
+     * builder that the gate awaits instead of registering it during parse. That is
+     * how a scene measures the rendered document — font metrics have arrived, and
+     * the answer is taken at one instant for the whole deck rather than whenever
+     * some tween first happens to render.
+     *
+     * WHY IT CANNOT BE DONE IN `setup`, AND WHY NOT LAZILY EITHER. `setup` runs
+     * during parse, before webfonts resolve, so it measures fallback metrics —
+     * measured at 8.6px of travel error in `experiments/014-seam-b`. Lazily, on a
+     * tween's first render, is worse: `hyperframes render` shards frames
+     * contiguously across workers, so "first render" is a different point in the
+     * deck in every worker, and the same input then renders differently at 1 worker
+     * and at 2 — measured at 39 of 594 frames and 14.96 dB, a camera landing 18px
+     * off, against 7 frames of antialiasing once deferred. Both failures are
+     * invisible to every gate. `cameraMeasure` carries the numbers and the controls.
+     *
+     * INVARIANT 11 IS THE TRAP HERE. This is not a callback on a tween. `seek()`
+     * passes `suppressEvents`, so measuring from an `onUpdate` — the obvious way to
+     * "measure late" — renders a frozen video with every gate green. Measurement
+     * happens before the timeline exists, and what it produces is ordinary tween
+     * values.
+     */
+    measure?: string[];
+    /**
+     * Hold points in seconds from the scene's start — where a presenter should
+     * pause. The shell converts these to absolute island fragment times.
+     */
+    holds: number[];
+    /** CSS this archetype needs. Deduplicated by the shell, emitted once. */
+    css?: string;
+}
+export type Emitter<A extends Archetype> = (beat: BeatOf<A>, ctx: EmitContext) => Scene;
+/** Escape text destined for HTML text content or a quoted attribute. */
+export declare function esc(s: string): string;
+export declare function mathy(raw: string): string;
+/** Whether a scene needs the KaTeX pass. Cheap enough to ask per scene. */
+export declare const TEX_MARK = "ds-tex";
+/** Escape a string for embedding inside a single-quoted JS literal. */
+export declare function js(s: string): string;

package/dist/types/emit/svg.d.ts

@@ -0,0 +1,177 @@
+/**
+ * Geometry, text metrics and SVG strings. Nothing above that.
+ *
+ * Six diagrammatic archetypes draw vector graphics that the source document
+ * never contained. Left to themselves each would re-derive the same four things
+ * — how wide a label renders, where N things go across a canvas, how to draw an
+ * arrowhead, how to escape a caption — and they would each get them slightly
+ * wrong in a different way. `line-chart` shipped 3.6px from clipping because it
+ * guessed its own em-factor; that guess now lives here, once.
+ *
+ * This module knows about characters, boxes and paths. It does not know what a
+ * pipeline stage or a receptive field is — that knowledge belongs to the emitter
+ * that composes these primitives, and putting it here is how a primitive layer
+ * turns into six hand-rolled one-offs wearing a shared import.
+ */
+import { type Vars } from "./kit.js";
+export interface Pt {
+    x: number;
+    y: number;
+}
+export interface Box {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/** Raw SVG attribute names to values. `undefined` and `""` are dropped. */
+export type Attrs = Record<string, string | number | undefined>;
+/**
+ * Audience text is never smaller than this at 1920x1080. Below it a slide passes
+ * every automated gate and is unreadable from the third row, which is the only
+ * test that matters and the only one we cannot run.
+ */
+export declare const MIN_FONT = 40;
+/**
+ * Two decimals. Floating point makes `x(3)` print as `412.00000000000006`, and a
+ * render that differs from the last one by a digit is a regression test we can
+ * no longer run — byte-identical output is the cheapest correctness signal here.
+ */
+export declare function n(v: number): string;
+/**
+ * `n`, where a NUMBER rather than its text is wanted — a tween's vars payload is
+ * now a typed object, so a coordinate that used to be interpolated into a string
+ * has to arrive as the value it is. Same rounding, so `String(nv(x)) === n(x)`
+ * by construction and geometry that goes through a tween still prints exactly
+ * what the same geometry in an SVG attribute prints.
+ */
+export declare function nv(v: number): number;
+/**
+ * The `from` vars of a stroke draw-on, with the path fully hidden.
+ *
+ * The length is rounded UP rather than to two decimals, and then given a pixel
+ * of slack, because GSAP writes `strokeDashoffset` back as an integer px: a
+ * leader of length 720.21 came to rest at an offset of 720 and left 0.21px of
+ * the dash exposed at the path start, which `stroke-linecap: round` paints as a
+ * full-width dot. A yellow dot therefore sat on the grid one reveal before its
+ * own region was drawn — inside the frame, above the type floor, and invisible
+ * to every gate. Any offset between the length and twice it is still inside the
+ * pattern's gap, so the slack costs nothing.
+ */
+export declare function drawFrom(length: number): Vars;
+/** Scene-scoped element id. Every timeline selector is built from one of these. */
+export declare function id(sid: string, part: string, i?: number): string;
+/**
+ * Estimated rendered width in px. Linear in `fontSize`, which is what lets
+ * `fitBoxes` solve for a size instead of searching for one.
+ *
+ * Every archetype sizes its boxes and padding through this function. When two of
+ * them disagree about how wide "Reconstruction" is, one of them clips.
+ */
+export declare function textWidth(text: string, fontSize: number, weight?: number, tracking?: number, tabular?: boolean): number;
+/**
+ * Greedy word wrap to `maxWidth`. A word wider than the line is broken by
+ * character — which is also how Korean and Chinese wrap, since they arrive as
+ * one unbroken "word".
+ */
+export declare function wrap(text: string, fontSize: number, maxWidth: number, weight?: number, tracking?: number): string[];
+/** The SVG root. Width and height match the viewBox so px and user units agree. */
+export declare function svg(elementId: string, w: number, h: number, body: string): string;
+export declare function rect(b: Box, a?: Attrs): string;
+export declare function roundRect(b: Box, r: number, a?: Attrs): string;
+export declare function line(from: Pt, to: Pt, a?: Attrs): string;
+export declare function path(d: string, a?: Attrs): string;
+export declare function circle(c: Pt, r: number, a?: Attrs): string;
+export declare function group(children: string | string[], a?: Attrs): string;
+export interface TextOptions {
+    size: number;
+    fill?: string;
+    weight?: number;
+    anchor?: "start" | "middle" | "end";
+    /** Wrap to this width. Omit for a single line. */
+    maxWidth?: number;
+    /** Baseline separation as a multiple of `size`. */
+    lineHeight?: number;
+    /**
+     * `"baseline"` (default) puts the first baseline at `y`. `"middle"` centres the
+     * whole block on `y` — the one a caller labelling a box wants, and the one that
+     * is wrong in a different way for every line count if each emitter derives it.
+     */
+    vAlign?: "baseline" | "middle";
+    class?: string;
+    id?: string;
+}
+export declare function text(content: string, at: Pt, o: TextOptions): string;
+export interface ArrowOptions {
+    stroke: string;
+    width?: number;
+    /** e.g. `"14 12"` for a feedback loop that should read as a return path. */
+    dash?: string;
+    /** Pull the head back off the target's edge. */
+    inset?: number;
+    class?: string;
+    id?: string;
+}
+/** Emit once per scene, with every colour that scene's arrows use. */
+export declare function arrowDefs(sid: string, colors: string[]): string;
+/** A straight connector with a head at `to`. */
+export declare function arrow(sid: string, from: Pt, to: Pt, o: ArrowOptions): string;
+export interface ElbowOptions extends ArrowOptions {
+    /** The coordinate of the long middle leg: a y when `axis` is `"v"`, else an x. */
+    via: number;
+    /** `"v"` leaves and arrives vertically — the shape a feedback loop under a row wants. */
+    axis?: "v" | "h";
+    /** Corner radius, clamped to half the shortest leg. */
+    radius?: number;
+}
+/**
+ * A three-leg orthogonal connector: out, along, back in. This is what a feedback
+ * arrow needs — a straight line from the last stage to the first would cut
+ * through every box between them.
+ */
+export declare function elbow(sid: string, from: Pt, to: Pt, o: ElbowOptions): string;
+export interface Track {
+    x: number;
+    w: number;
+}
+/**
+ * `count` equal tracks spanning `width`, separated by `gap`. Use it for columns
+ * or, with the result read as `y`/`h`, for rows — the arithmetic is the same and
+ * having it twice is how a diagram ends up 1px off its own grid.
+ */
+export declare function tracks(width: number, count: number, gap: number, x0?: number): Track[];
+export interface FitRequest {
+    labels: string[];
+    width: number;
+    /** Preferred type size. Only reduced once `gap` has already reached `minGap`. */
+    size: number;
+    gap: number;
+    minGap?: number;
+    /** Inner padding per side, as a multiple of the type size. */
+    padEm?: number;
+    weight?: number;
+    x0?: number;
+}
+export interface Fit {
+    /**
+     * False when the labels cannot be set at `MIN_FONT` in `width`. The geometry is
+     * still returned so a caller can see by how much, but it will clip — the point
+     * of reporting is that the caller picks a different composition (stack them,
+     * split the beat) instead of shipping a slide nobody can read.
+     */
+    ok: boolean;
+    size: number;
+    gap: number;
+    boxes: Track[];
+    /** Width the composition would need at the floor. Present only when `!ok`. */
+    needed?: number;
+}
+/**
+ * Fit N labelled boxes across a width.
+ *
+ * Gaps go first because whitespace is cheaper than legibility, and type stops at
+ * `MIN_FONT` because below it the slide passes every gate and fails the room.
+ * `textWidth` is linear in size, so the largest size that fits is a division
+ * rather than a search.
+ */
+export declare function fitBoxes(req: FitRequest): Fit;

package/dist/types/emit/theme.d.ts

@@ -0,0 +1,65 @@
+/**
+ * The shared stylesheet, the ambient gate, and the deck's pacing.
+ *
+ * The palettes themselves moved to `./themes/` once there was more than one;
+ * this file stays the door to them, so nothing that imports `ambient` or `ink`
+ * had to be touched to gain a registry.
+ *
+ * What is left here is everything a theme does NOT decide per-theme: the reset,
+ * the scene box, the two ambient keyframes, and `pace`. Typography belongs to
+ * the archetype that draws it, not to this file. Two stylesheets describing one
+ * `.figwrap` is how a rule ends up being decided by emission order, so nothing
+ * an emitter styles is styled here as well.
+ */
+import type { Format } from "../types.js";
+import { type Scene } from "./kit.js";
+import type { DeckTheme } from "./themes/index.js";
+export { type DeckTheme, ink, mono, paper, resolveTheme, THEME_NAMES, THEMES, } from "./themes/index.js";
+/** Where `ingest` writes the subsetted font bundle, relative to the deck. */
+export declare const FONT_BUNDLE_HREF = "assets/fonts/fonts.css";
+/** A luminance breath. Safe on an element an entrance tween already moves. */
+export declare const BREATHE = "ds-breathe 6s ease-in-out infinite alternate";
+/** A 1.2% swell. Only for an element no `fromTo` targets — it writes `transform`. */
+export declare const DRIFT = "ds-drift 11s ease-in-out infinite alternate";
+/**
+ * One ambient rule for one focal element.
+ *
+ * `rest` is glued straight onto `#<sid>`, so the selector cannot escape its own
+ * scene however the caller writes it — `" .dot:last-of-type"` and `"-r2 td"` are
+ * both scoped. Reduced motion is the default: stillness needs no gate, motion
+ * does.
+ */
+export declare function ambient(sid: string, rest: string, animation: string): string;
+export declare function baseCss(theme: DeckTheme, format: Format): string;
+/**
+ * Every time in a finished scene, multiplied by `speed`.
+ *
+ * `prefs.animationSpeed` sits under `look` beside `theme` for a reason: it is
+ * the same kind of decision, and this is the same place to apply it. It is
+ * applied to the emitted Scene rather than inside `tween()` because half of a
+ * timeline's arithmetic never passes through `tween()` — an emitter works out
+ * `settled = rowsIn + stagger * rows + 0.45`, hands the result to `holdsWithin`,
+ * and only the two endpoints ever reach a helper. Scaling the finished scene
+ * catches the tween, its stagger and its position with one rule, and scaling
+ * `holds` by the identical factor is what keeps a hold on the frame it was
+ * authored for. A hold that drifts off its tween lands navigation on a
+ * half-built slide, which no gate can see.
+ *
+ * This used to scale the emitted STATEMENT TEXT, and recovered the position
+ * argument with `/,\s*(-?\d*\.?\d+)\s*\)\s*;?\s*$/` — a regex parsing GSAP out
+ * of a string, on the path every deck's timing goes through. `Tween` is a typed
+ * object now, so the position is a field and the durations are fields, and this
+ * is the arithmetic it always wanted to be.
+ *
+ * The caller must scale the beat's own `seconds` by the same factor, or a
+ * slowed deck cuts its last reveal off and a hurried one sits on a finished
+ * slide. That is the shell's arithmetic, not a scene's, so it is not done here.
+ *
+ * Ambient CSS is left alone: it loops forever and nothing waits on it, so its
+ * period is a property of the room rather than of the deck's pace.
+ *
+ * `speed === 1` returns the scene untouched — identity by construction, not by
+ * arithmetic that happens to round back. That is what keeps a default deck
+ * byte-identical to one built before this existed.
+ */
+export declare function pace(scene: Scene, speed: number): Scene;

package/dist/types/emit/themes/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The theme registry.
+ *
+ * A theme is a name and a palette, and that is the whole extension point: a new
+ * one is a file here plus a line in `THEMES`, and nothing in the shell or in any
+ * archetype learns it exists. Emitters read `ctx.theme` and never a theme name —
+ * the moment one branches on `name === "paper"` the registry has stopped being a
+ * registry and the archetype has acquired a second, invisible stylesheet.
+ *
+ * Three of them, each a position rather than a hue: dark room, lit room, and the
+ * room where colour does not survive.
+ */
+import type { Theme } from "../kit.js";
+import { ink } from "./ink.js";
+import { mono } from "./mono.js";
+import { paper } from "./paper.js";
+/**
+ * `Theme` plus what only the shared stylesheet reads.
+ *
+ * `Theme` in `kit.ts` is the archetypes' contract and stays exactly as wide as
+ * they need. Body weight is not theirs — every archetype sets its own weights —
+ * it belongs to the one `body` rule in `baseCss`, so it lives out here where a
+ * theme can carry it and an emitter cannot see it.
+ */
+export interface DeckTheme extends Theme {
+    /** `body`'s font-weight. Omitted means 400, which is what `ink` and `paper` want. */
+    bodyWeight?: number;
+}
+export declare const THEMES: Readonly<Record<string, DeckTheme>>;
+/** Sorted, so an error message and a `--help` listing agree without coordinating. */
+export declare const THEME_NAMES: readonly string[];
+/**
+ * A theme by name, or a failure that says what the names are.
+ *
+ * Throwing rather than falling back to `ink`: a misspelt theme that silently
+ * renders in the default is a whole deck built wrong, discovered at the point
+ * someone presents it.
+ */
+export declare function resolveTheme(name: string): DeckTheme;
+export { ink, mono, paper };

package/dist/types/emit/themes/ink.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The original: a deep blue-black ground with cool light on it.
+ *
+ * Written for a dark room and a projector that has one job. The four tones are
+ * four hues at roughly one value — nothing here is "the important one", because
+ * an archetype assigns them by position in a list, not by rank.
+ *
+ * Its numbers are frozen. Every render this project has ever compared against
+ * came out of them, so a nicer blue is a broken regression test.
+ */
+import type { DeckTheme } from "./index.js";
+export declare const ink: DeckTheme;

package/dist/types/emit/themes/mono.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Near-monochrome: white ground, black type, one red, used rarely.
+ *
+ * For the two rooms where colour is a lie — the conference projector with a
+ * blown lamp and a washed-out gamma, and the greyscale printer. Both destroy
+ * hue and keep value, so this theme encodes everything in value and spends its
+ * single hue on the one thing per slide that must be found.
+ *
+ * That is what makes the tones different in kind from the other two themes'.
+ * `a` is the accent; `b`, `c`, `d` are a ladder of greys about two stops apart,
+ * so they stay told apart after a photocopier has finished with them. Four hues
+ * would have collapsed into one grey, which is the failure this theme exists to
+ * avoid. The ladder bottoms out at #6f6f6f because a lighter grey drops below
+ * 4.5:1 on the panel.
+ *
+ * `bodyWeight` is the other half of it: a stop of extra weight is what keeps
+ * type legible once a bad projector has eaten the thin end of every stroke.
+ */
+import type { DeckTheme } from "./index.js";
+export declare const mono: DeckTheme;

package/dist/types/emit/themes/paper.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Light: a warm off-white ground, near-black text, one quiet accent.
+ *
+ * For a lit room, a handout, and the screenshot that ends up in a doc. It is not
+ * `ink` inverted — inverting a dark theme yields pastel tones that vanish on
+ * white, because a hue bright enough to read on #0b0d10 is by definition close
+ * to the light end.
+ *
+ * So the tones are re-picked rather than flipped, and picked to one rule: each
+ * clears 4.5:1 on both the ground and the panel, and all four sit at nearly the
+ * same value, so they read as four hues rather than as a ranking. That is the
+ * mirror of `ink`'s arrangement, arrived at from the opposite direction.
+ *
+ * The accent is deliberately dull for a light theme. Saturated blue on warm
+ * white is the one combination that looks like a default rather than a choice.
+ */
+import type { DeckTheme } from "./index.js";
+export declare const paper: DeckTheme;