@jokerized/decksmith 0.9.3 → 0.9.4

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

@@ -26,15 +26,14 @@
  *    this module) all still agree. Emphasis lives strictly inside a hold window
  *    and is back at rest before the window closes, so every frame a gate
  *    captures at a hold is the frame v0.8.0 would have captured there.
- * 4. Up, never down. Emphasis grows a part (`LIFT`) and never shrinks one: the
- *    type floor reads declared sizes, so a part scaled below 1 at a hold would
- *    pass at a size it is not drawn at.
+ * 4. Nothing is scaled. Emphasis is light (`glow`), so the type floor's declared
+ *    sizes are the drawn ones at every hold.
  *
  * INTERFACE, for the other v2 tracks (player, fit, style, layout):
  *
- * - `planMotion(seed, beats)` → which entrance verb each scene uses, which seam
- *   joins each pair, and the order emphasis kinds are tried in. A style pack
- *   that wants to bias the grammar should filter `ENTRANCES`/`SEAMS` before
+ * - `planMotion(seed, beats)` → which entrance verb each scene uses (a fade),
+ *   which seam joins each pair, and the order emphasis kinds are tried in. A
+ *   style pack that wants to bias the grammar should filter `SEAMS` before
  *   calling it rather than post-edit its answer, so the no-repeat rules still
  *   hold.
  * - `restyleEntrance(scene, sid, verb)` rewrites an emitted scene's own
@@ -50,26 +49,20 @@
 import type { Archetype, BeatRole } from "../types.js";
 import { type Scene, type Tween } from "./kit.js";
 /**
- * How a scene's parts arrive. Six, so the no-repeat rule always has at least
- * four to choose from after excluding the previous scene's verb and a capped
- * `rise`.
- *
- * | verb  | what moves                                   | ease          |
- * |-------|----------------------------------------------|---------------|
- * | rise  | fade up from below (v0.8.0's, kept, capped)  | power3.out    |
- * | slide | in from the reading side                     | expo.out      |
- * | snap  | scale up from 0.9 with a small overshoot     | back.out(1.7) |
- * | focus | out of a blur (HTML) / short rise (SVG)      | circ.out      |
- * | wipe  | clip-path opens left to right (HTML)         | power4.inOut  |
- * | mask  | clip-path opens bottom-up while rising (HTML)| power4.out    |
- *
- * `focus`, `wipe` and `mask` touch `filter`/`clip-path`, which are only applied
- * to HTML elements this module can SEE are HTML (an id whose tag it read in the
- * scene's markup). An SVG part or a class selector gets the verb's transform
- * fallback instead, because clip-path on an SVG child clips against a reference
- * box nobody measured.
- */
-export declare const ENTRANCES: readonly ["rise", "slide", "snap", "focus", "wipe", "mask"];
+ * How a scene's parts arrive: ONE verb, a quiet opacity fade, in place.
+ *
+ * There were six — rise, slide, snap (a pop from 0.9 with overshoot), focus
+ * (out of a blur), wipe and mask (clip-path sweeps) — hashed per scene so no
+ * two adjacent scenes arrived alike. The founder's verdict on the result
+ * (2026-10-10): "graphic animation by animated UI elements is old-fashioned".
+ * Plates, chips, cards and labels sliding, popping or being swept in WERE the
+ * motion, and that is the thing he named. So a v2 archetype's parts now simply
+ * appear, and what moves is the picture: the backdrop's drift and the camera
+ * (src/emit/backdrop.ts, src/emit/camera.ts), the seams between scenes, and
+ * things inside a figure that are its content (a probe travelling a curve, a
+ * pulse travelling a pipeline). Those are not entrances and are never touched.
+ */
+export declare const ENTRANCES: readonly ["fade"];
 export type Entrance = (typeof ENTRANCES)[number];
 /**
  * How one scene hands off to the next. `dive` is the existing camera move and is
@@ -80,20 +73,34 @@ export type Entrance = (typeof ENTRANCES)[number];
  * | dissolve | opacity → 0, power2.in (v0.8.0)  | —                      |
  * | push     | xPercent 0 → −4, opacity → 0     | xPercent 4 → 0         |
  * | lift     | yPercent 0 → −4, opacity → 0     | yPercent 4 → 0         |
- * | wipe     | clip-path closes left to right   | —                      |
  * | zoom     | scale 1 → 1.04, opacity → 0      | scale 0.96 → 1         |
  *
+ * There was a fifth, `wipe`: a clip-path closing left to right. It was cut
+ * (2026-10-10) because a hard edge sweeping a whole slide is a graphic, not a
+ * picture: at 4fps the r3 deck showed it as half a robot and a lone chip on an
+ * empty slide (s4→s5), a bare blue rectangle (s8→s9). Every seam left is a
+ * fade the eye reads as a cut or a camera move.
+ *
+ * Each seam also clears the outgoing scene's TYPE first (`chromeOut`), so two
+ * headlines are never on screen together.
+ *
  * 4% is under the scene's own padding at every format (110px of 1920 is 5.7%,
  * 84px of 1080 is 7.8%), so a mid-seam frame never puts content off the canvas
  * for the layout gate's grid samples to find.
  */
-export declare const SEAMS: readonly ["dissolve", "push", "lift", "wipe", "zoom"];
+export declare const SEAMS: readonly ["dissolve", "push", "lift", "zoom"];
 export type Seam = (typeof SEAMS)[number] | "dive";
-/** What moves while the narrator talks about a part: grow, glow, underline. */
-export declare const EMPHASES: readonly ["pulse", "glow", "underline"];
+/**
+ * What moves while the narrator talks about a part: light, and only light. A
+ * `pulse` (the part scaled up and back) and an `underline` (a rule faded in
+ * under it) were the other two, and both are a UI element doing a move — the
+ * thing the founder called old-fashioned (2026-10-10). A glow is the part being
+ * lit, which is something a picture does.
+ */
+export declare const EMPHASES: readonly ["glow"];
 export type Emphasis = (typeof EMPHASES)[number];
 /** Every ease this module writes. A test pins that nothing else appears. */
-export declare const MOTION_EASES: readonly ["power3.out", "expo.out", "back.out(1.7)", "circ.out", "power4.inOut", "power4.out", "power2.in", "power2.inOut", "sine.out", "sine.inOut"];
+export declare const MOTION_EASES: readonly ["power3.out", "expo.out", "power2.in", "power2.inOut", "sine.out", "sine.inOut"];
 /**
  * FNV-1a, 32-bit. The seeded choice every v2 decision is made with: stable
  * across platforms and Node versions, which a `Math.random` with a seed is not.
@@ -116,23 +123,16 @@ export interface MotionPlan {
     /** Per beat, the order emphasis kinds are tried in (the first that fits wins). */
     emphases: Emphasis[][];
 }
-/**
- * At most this share of a deck's scenes open with `rise`, the one verb that
- * reads as v0.8.0's stock fade-up. The plan's target is "modal entrance ≤ 40%".
- */
-export declare const RISE_SHARE = 0.25;
 /**
  * The deck's motion, decided once for the whole storyboard.
  *
- * ENTRANCES: each beat hashes into the verbs still allowed to it — never the
- * previous beat's, and `rise` only while under `RISE_SHARE`. Hash-then-filter
- * rather than a rotation so two decks with the same archetype sequence still
- * move differently, which is the cross-deck sameness the critic flagged.
+ * ENTRANCES: every beat fades (`ENTRANCES`). Variety between scenes is the
+ * seams' and the pictures' job now, not the parts'.
  *
  * SEAMS are chosen by the RELATION between the two beats first, then varied:
  * same family (two quantity beats) → `push`, a lateral continuation; a role
  * boundary (`background` → `limitations`) → `zoom`, a chapter break; into or
- * out of a title → `lift`; any other family change → `wipe`; into the closing
+ * out of a title → `lift`; any other family change → `zoom` or `dissolve`; into the closing
  * beat → `dissolve`. A seam that would repeat the previous one is replaced by a
  * hashed pick from the rest. Then, for a deck of 10+ beats with fewer than three
  * kinds, the earliest replaceable seams are rotated through the missing kinds.
@@ -147,18 +147,29 @@ export declare function planMotion(seed: string, beats: readonly MotionBeat[]):
 export declare function ensureSeamKinds(seams: Seam[], want: number): void;
 /**
  * A tween this module may restyle: an opacity 0 → 1 reveal whose `from` only
- * moves opacity and position/scale, rendered immediately (the element's own
- * first appearance). Dims, restores, draw-ons, pulses and anything with
- * `immediateRender: false` are someone else's and stay exactly as emitted.
+ * moves opacity and position/scale. Dims, restores, draw-ons and colour turns
+ * are someone else's and stay exactly as emitted.
+ *
+ * `immediateRender: false` reveals COUNT. They used to be skipped as "someone
+ * else's", and they are mostly a panel's lines or a card's words staggering in
+ * after their card — the same sliding-in the founder objected to, one level
+ * down. A fade only removes keys, so it cannot become a second writer of
+ * anything the tween did not already write.
  */
 export declare function isEntrance(t: Tween): boolean;
-/** The tag of the element an `#id` selector names in this markup, if it is one. */
-export declare function tagOf(html: string, target: string): string | undefined;
 /**
  * One scene's entrances, re-voiced in `verb`. Positions and durations are
  * untouched (rule 3 at the top), so this cannot move a hold or the voice.
  */
 export declare function restyleEntrance(scene: Scene, sid: string, verb: Entrance): Scene;
+/**
+ * `restyleEntrance` for the CHROME alone: the eyebrow and headline the shell
+ * draws around a bespoke scene with the stock `chromeIn` (src/bespoke/scene.ts).
+ * The scene's own tweens are its author's and are left exactly as written; the
+ * chrome is ours, and unrestyled it slid up from y:14/22 starting at 0.15s,
+ * straight over the outgoing scene's headline (r3, s13→s14).
+ */
+export declare function restyleChrome(scene: Scene, sid: string, verb: Entrance): Scene;
 /**
  * When the incoming chrome may start, in unpaced seconds: once the outgoing
  * scene's handoff (`HANDOFF_SECONDS`, 0.4) has taken it below half opacity,
@@ -180,6 +191,27 @@ export declare const SEAM_CLEAR = 0.3;
  * tween, so a v2 deck whose plan says dissolve hands off as v0.8.0 did.
  */
 export declare function seamOut(kind: Exclude<Seam, "dive">, sid: string, at: number, over: number): Tween[];
+/**
+ * The share of a handoff the outgoing scene's TYPE takes to fade out. Its
+ * eyebrow and headline are gone by `CHROME_OUT * over` (0.16s of 0.4), well
+ * before the incoming chrome may start at `SEAM_CLEAR` (0.3), so the two
+ * headlines never share a frame. The picture keeps the whole `over` to
+ * dissolve under the next scene.
+ *
+ * WHY. The root fade alone left the outgoing headline at 23-75% while the
+ * incoming one came up at the same place: r3's s12→s13 and s13→s14 seams
+ * showed both headlines and both eyebrows overprinted for about two frames at
+ * 4fps. `power2.in` on the root holds the old type high exactly when the new
+ * type arrives, so no ease on the root alone can fix it.
+ */
+export declare const CHROME_OUT = 0.4;
+/**
+ * The outgoing half of a seam for the scene's own type: `#sid-e` and
+ * `#sid-h`, whichever of them `html` draws (a title-less scene draws no
+ * eyebrow, and a tween on an absent id is a GSAP warning). `immediateRender:
+ * false`, so it never paints at build time over the chrome's own entrance.
+ */
+export declare function chromeOut(sid: string, html: string, at: number, over: number): Tween[];
 /**
  * The INCOMING half, on the next scene's own timeline from its 0. Settles by
  * `firstHold - 0.05`, so the frame at the first stop is the frame v0.8.0 drew

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

@@ -71,6 +71,46 @@ export declare function familyOf(face: LatinFace): string;
  * draws a glyph; it is there so (body, display) pairs give distinct stacks.
  */
 export declare function stackFor(body: LatinFace, display: LatinFace): string;
+/**
+ * THE V2 TYPE SCALE in px at 1920x1080 — the founder's, confirmed 2026-10-10,
+ * after "the fonts are too large": a 56px headline, 40-44px body and labels, a
+ * 40px kicker. No 160-560px hero numeral and no 64px+ kinetic type; the
+ * narration and its subtitles carry the words, so what is ON the slide is
+ * minimal and quiet.
+ *
+ * One table, read by every v2 emitter (the chrome through `TYPES` below, each
+ * archetype through `v2Text`), by src/bespoke's prompt, labels and gates, and —
+ * restated, because that file may import nothing from here — by the burned
+ * caption in src/types.ts, so a size cannot be lowered in one place and left
+ * large in another. Never under `floor`: AGENTS.md invariant 5. Classic never
+ * reads it — `--design classic` is still the complete rollback.
+ */
+export declare const TYPE_SCALE: {
+    /** The line that says the slide: headline, title slide, a hero statement. */
+    readonly headline: 56;
+    /** Body copy and the largest a label is set: labels run `label`..`body`. */
+    readonly body: 44;
+    /** The smallest a label is set; with `body`, the 40-44px label band. */
+    readonly label: 40;
+    /** Eyebrow / kicker. */
+    readonly kicker: 40;
+    /** A burned subtitle (src/types.ts `captionFontSize` restates it). */
+    readonly caption: 40;
+    /** Never under this (invariant 5). */
+    readonly floor: 40;
+    /**
+     * The largest a display equation is asked at. Not the headline's 56: KaTeX
+     * sets a sub- or superscript at 0.7em, and at 64 that is 44.8px — on the body
+     * scale, clear of the floor. Classic asked up to 108; v2 grew it to 140.
+     */
+    readonly math: 64;
+};
+/**
+ * A text size as v2 sets it: `px` held inside `[floor, cap]`. Classic passes
+ * through untouched. `cap` defaults to body/label size; a role that IS the
+ * headline passes `TYPE_SCALE.headline`.
+ */
+export declare function v2Text(v2: boolean, px: number, cap?: number): number;
 /** Today's chrome, exactly. `title.ts` exported these numbers before specs existed. */
 export declare const CLASSIC_TYPE: TypeSpec;
 /**
@@ -84,11 +124,14 @@ export declare const CLASSIC_TYPE: TypeSpec;
  * - `grotesk-plex`: Space Grotesk headline over a Plex body.
  * - `plex-serif`: a Plex headline over a serif body, the inverse of `serif-inter`.
  *
- * HEIGHT. A one-line eyebrow plus a one-line headline costs at most classic's
- * 146px in every spec, so a pack's bigger type comes out of its leading and
- * gaps rather than out of the body's room. Measured why: `serif` at 44/70 cost
- * a real deck a six-bar chart (`costsNothing` in themes/pick.ts now refuses
- * such a pack, but a pack that rarely needs refusing is the better pack).
+ * SIZE IS NOT A VOICE ANY MORE. Every spec sets the eyebrow at `TYPE_SCALE.kicker`
+ * and the headline — the title slide's included — at `TYPE_SCALE.headline`; the
+ * pairs differ in face, weight, tracking, case and leading. They used to differ
+ * in size too (60-70px headlines, 144-168px titles), and the founder's verdict
+ * on those was "the fonts are too large".
+ *
+ * HEIGHT. A one-line eyebrow plus a one-line headline costs well under classic's
+ * 146px in every spec, so nothing here takes room from the body.
  *
  * FLOORS. Every eyebrow is at least 40px (invariant 5). Title tracking is never
  * positive: `fitText` measures untracked, so only a tightening is free.

package/dist/types/images/providers.d.ts

@@ -7,6 +7,12 @@ export interface ImageRequest {
     /** `images.style`, folded into every prompt. */
     style: string;
     aspect: ImageAspect;
+    /**
+     * The picture covers the frame — a stage or a backdrop — rather than sitting
+     * on a plate. Absent means a plate, which is every request made before this
+     * existed, so their prompts and cache keys do not move.
+     */
+    bleed?: boolean;
     /**
      * `images.model`, for the separate backend only; the Codex and tool rungs
      * ignore it. Carried on the request rather than baked into the provider

package/dist/types/plan/codex.d.ts

@@ -1,7 +1,7 @@
-import type { Prefs } from "../prefs.js";
+import { type Prefs } from "../prefs.js";
 import { type Source, type Storyboard } from "../types.js";
 /** The schema for one run. `role` is present only when the paper arc was asked for. */
-export declare function schemaFor(prefs: Pick<Prefs, "genre">): unknown;
+export declare function schemaFor(prefs: Pick<Prefs, "genre" | "bespoke" | "design">): unknown;
 /**
  * The default-preferences schema, unchanged and still exported: `general` hides
  * `role`, so these bytes are what they have always been.
@@ -18,6 +18,8 @@ export interface CodexOptions {
     prefs?: Prefs;
     /** Swappable so a test can drive the real parse path without spawning anything. */
     run?: Runner;
+    /** Told what the first plan broke, before the one repair round is asked for. */
+    onRepair?: (broken: readonly string[]) => void;
 }
 export interface RunnerArgs {
     prompt: string;

package/dist/types/plan/direct.d.ts

@@ -42,7 +42,7 @@ export interface Direction {
 export interface LookSummary {
     beats: number;
     distinct: number;
-    /** Share of beats whose chrome sits on top of the slide (title excluded from the numerator). */
+    /** Share of beats whose chrome sits on top of the slide (title and chromeless beats excluded from the numerator). */
     modalChrome: number;
     /** Adjacent pairs with the same signature. */
     adjacentRepeats: number;

package/dist/types/plan/duration.d.ts

@@ -43,7 +43,7 @@
  * planner, no TTS and no ffmpeg.
  */
 import type { Prefs } from "../prefs.js";
-import type { Source } from "../types.js";
+import { type Source } from "../types.js";
 /**
  * Characters of text per second of speech.
  *

package/dist/types/plan/prompt.d.ts

@@ -1,4 +1,4 @@
-import type { Prefs } from "../prefs.js";
+import { type Prefs } from "../prefs.js";
 import { type Source } from "../types.js";
 /**
  * How many sentences each archetype wants, because it is how many stops it has.

package/dist/types/plan/refs.d.ts

@@ -6,8 +6,8 @@ export interface PendingIllustration {
     where: string;
 }
 /**
- * Every pending slot, in beat order. A claim-figure without a `figureId` is
- * pending by construction — the schema insists on one of the two — and a
+ * Every pending slot, in beat order. A claim-figure or stage without a
+ * `figureId` is pending by construction — the schema insists on one of the two — and a
  * split-compare side is pending only when it carries a brief, because a side
  * with neither is a list.
  */

package/dist/types/plan/variety.d.ts

@@ -0,0 +1,74 @@
+/**
+ * VARIETY: the plan-level rule that a deck must not be one layout repeated.
+ *
+ * The measured failure this answers (2026-10-09, a 14-beat Korean paper deck,
+ * no figures, planned with `--images`): 5 split-compare, 5 pipeline, 2 callout,
+ * 1 title, 1 bar-compare, ZERO illustrations — and beats 2 to 12 alternated
+ * split-compare / pipeline / split-compare / pipeline for nine slides running.
+ * RULE 1's "not the same archetype twice in a row" held at every pair, and the
+ * deck still read, slide after slide, as the same two cards on a pale ground.
+ * The prompt said a stage MAY carry an illustration; the planner never did.
+ *
+ * So the rule is a minimum, not an invitation, and it is CHECKED: the prompt
+ * (src/plan/prompt.ts) states these numbers by importing them from here, and
+ * `codexPlanner` (src/plan/codex.ts) runs `varietyFindings` on what comes back,
+ * asks once for a repair, and refuses a plan that still breaks it. One table,
+ * read by both, so the sentence the model is given and the check it is held to
+ * cannot drift apart.
+ *
+ * WHAT IT DELIBERATELY DOES NOT DO. It never rewrites a beat. Turning a pipeline
+ * into a stage needs a picture brief only the planner can write honestly, and
+ * reordering beats breaks the narration's argument. A plan that breaks the rule
+ * goes back to the planner with the reasons, which is the only repair that
+ * keeps the deck's content the planner's.
+ */
+import type { Prefs } from "../prefs.js";
+import type { Archetype, Beat, Design, Storyboard } from "../types.js";
+/** A deck this long must carry stage beats. Below it there is no room to spend one. */
+export declare const STAGE_MIN_BEATS = 8;
+/** At least one stage per this many beats, when the deck may ask for pictures. */
+export declare const STAGE_EVERY = 4;
+/** Longest A/B/A/B run allowed: three beats (A, B, A) is a return; four is a rut. */
+export declare const MAX_ALTERNATION = 3;
+/**
+ * At least this share of a deck's beats are SCENES — a picture owns or backs
+ * them — when the deck may ask for pictures. Three stages in fourteen still left
+ * nine beats of cards on the pack's pale ground in the 2026-10-09 ko e2e; a
+ * diagram with a `backdrop` is drawn over a picture, so "most beats are scenes"
+ * no longer costs the diagram.
+ */
+export declare const SCENE_SHARE = 0.6;
+/**
+ * The archetypes that draw boxes, cards or rows of them — what the founder
+ * means by slideware. A backdrop puts them in a scene but they are still
+ * panels: round 1 of the 2026-10-09 ko e2e had ten of fourteen beats as
+ * scenes, and nine of fourteen were still panels over pictures.
+ */
+export declare const PANEL_ARCHETYPES: ReadonlySet<Archetype>;
+/** At most this share of a picture deck's beats are panels: five of fourteen. */
+export declare const PANEL_SHARE = 0.36;
+/** How many panel beats a deck of `beats` may carry, given whether it may ask for pictures. */
+export declare function panelsAllowed(beats: number, images: Prefs["images"]): number;
+/** How many stage beats a deck of `beats` must carry, given the picture cap. */
+export declare function stagesRequired(beats: number, images: Prefs["images"]): number;
+/** How many beats of a deck of `beats` must be scenes (`SCENE_SHARE`), given the picture cap. */
+export declare function scenesRequired(beats: number, images: Prefs["images"]): number;
+/**
+ * Whether a picture owns or backs this beat: a stage, a split-compare side
+ * with a picture, or a diagram over a `backdrop`. A brief counts as a figure
+ * does — it is a picture by the time anyone sees the deck. A hero number and a
+ * kinetic claim are scenes with or without one: with none they fill the frame
+ * with a field of colour, never the pale ground — and so, in v2, is a
+ * bar-compare.
+ *
+ * NOT a claim-figure or an annotated-figure: both draw their figure as a card
+ * on the pack's pale ground (neither goes through `overBackdrop` or
+ * `overField`), so counting them let a plan meet `SCENE_SHARE` with exactly
+ * the cards-on-paper the share exists to refuse.
+ */
+export declare function isScene(beat: Beat, design?: Design): boolean;
+/**
+ * Every way `storyboard` breaks the variety rule, as sentences the planner can
+ * act on. Empty is a pass.
+ */
+export declare function varietyFindings(storyboard: Storyboard, images: Prefs["images"], design?: Design): string[];

package/dist/types/prefs.d.ts

@@ -44,6 +44,16 @@ export declare function prefsFromFlags(flags: PrefFlags): PrefsPatch;
  * storyboard planned under v2.
  */
 export declare function designFor(prefs: Pick<Prefs, "design">, recorded?: Design): Design;
+/**
+ * The bespoke pass a build runs, with every default filled in, or undefined.
+ * ON BY DEFAULT UNDER V2: every beat is drawn by a generated scene and the
+ * archetype is only its fallback. `--no-bespoke` (`"bespoke": {"enabled":
+ * false}`) turns it off; classic never runs it, so a classic deck keeps its
+ * bytes.
+ */
+export declare function bespokeFor(prefs: Pick<Prefs, "bespoke">, design: Design): {
+    prefs: NonNullable<Prefs["bespoke"]>;
+} | undefined;
 /** The flag surface the CLI exposes. Every one optional: absent means unstated. */
 export interface PrefFlags {
     slides?: string | number;
@@ -71,7 +81,7 @@ export interface PrefFlags {
     imageModel?: string;
     imageStyle?: string;
     imageMax?: string | number;
-    /** `--bespoke`: generated scenes for a few mechanism beats (v2 only). */
+    /** `--bespoke` / `--no-bespoke`: generated scenes for every beat (v2 only; on by default there). */
     bespoke?: boolean;
     bespokeCalls?: string | number;
     bespokeSeconds?: string | number;
@@ -80,3 +90,12 @@ export interface PrefFlags {
     bespokeCache?: string;
     bespokeArt?: string | number;
 }
+/**
+ * Commander gives a plain `--flag` `undefined` until it is passed, which is
+ * exactly the "unstated" that `prefsFromFlags` needs — except for `--no-x`,
+ * which defaults to `true` and would therefore outrank the config file on every
+ * run. So the negation is read as a negation and nothing else. `--images` is
+ * the other one read by hand: it is a boolean, and the loop below only knows
+ * strings.
+ */
+export declare function flagsFromOptions(o: Record<string, unknown>): PrefFlags;

package/dist/types/render/captions.d.ts

@@ -27,11 +27,10 @@ export interface CaptionBand {
  * cues. Hidden by default and revealed one at a time, so what is measured is
  * exactly what is captured.
  *
- * The scrim is `box-decoration-break: clone`, which gives each LINE its own box
- * — the same treatment ASS's `BorderStyle=4` produces, and the only one that
- * reads as a caption rather than as a letterbox: a single box around a block
- * whose second line is two words wide is a wide black bar with a short line
- * floating in it.
+ * There is no scrim (2026-10-10): the founder asked for a quiet lower third,
+ * not a box, so each line is white type with a close dark halo. The span keeps
+ * `box-decoration-break: clone` and its padding so every line's halo lies
+ * inside the rectangle `measure` reports and the band is captured with it.
  *
  * `line-height` is set from a measurement, not from a ratio. The inline box is
  * as tall as the font's content area plus the padding, and that is a number only

package/dist/types/render/capture.d.ts

@@ -103,6 +103,13 @@ export interface DeckPage {
     shoot(): Promise<Buffer>;
     /** For callers that need to read the DOM at a stop, as `fidelity` does. */
     page: Page;
+    /**
+     * Every uncaught error the page has raised since it opened, in order. The
+     * runtime swallows a throw inside a seek, so this is the only place an
+     * animate piece's drawing error (`reportError`) surfaces: without it a seek
+     * resolves over a stale or half-painted canvas.
+     */
+    errors: string[];
     close(): Promise<void>;
 }
 export interface OpenOptions {