@jokerized/decksmith 0.9.2 → 0.9.4

package/dist/types/build/piece.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The script for piece `id`, whose author file `name` (the figure's `src`)
+ * holds `author`.
+ *
+ * The MIT notice rides at the top of every assembled file because the file IS a
+ * copy of the kit, shipped inside someone else's deck.
+ */
+export declare function assemblePiece(id: string, name: string, author: string): Promise<string>;

package/dist/types/emit/animate-runtime.d.ts

@@ -0,0 +1,149 @@
+/**
+ * The runtime an animate PIECE runs on: a registry the piece's script fills,
+ * a `mount` the scene's `measure` calls, and the `dsAnimate` GSAP plugin that
+ * draws the piece as part of being seeked.
+ *
+ * A piece is a figure (`kind: "piece"`, src/types.ts) whose asset is a script:
+ * an animate scene file, assembled by src/build/piece.ts with the vendored kit
+ * (src/build/animate/) into ONE factory registered here under the figure's id.
+ * `claim-figure` draws it on a `<canvas>`. See
+ * .planning/2026-10-09-animate-piece-design.md and the spike that measured it.
+ *
+ * SEEK, NOT PLAY (invariant 1). animate's `renderFrame(t, canvas)` is a pure
+ * function of `t` — it repaints from a clean sheet every call — so the plugin's
+ * `render` is the only thing that ever draws, and it runs as part of the seek.
+ * Nothing here runs on a callback (invariant 11).
+ *
+ * THE TWEEN VALUE IS THE PIECE'S OWN TIME, IN SECONDS. One convention, chosen
+ * because it is the one the spike rendered and watched:
+ *
+ *   tl.fromTo("#s2-pc", { dsAnimate: 0 }, { dsAnimate: S, duration: S, ease: "none" }, at)
+ *
+ * where `S` is the figure's `seconds`. The tween's value at ratio `r` is
+ * `r * S`, a piece-local second, and the tween runs at 1:1 with the deck's
+ * clock. A 0-to-1 value would work too (design A wrote it), but two conventions
+ * in one codebase is how one of them gets the other's arithmetic.
+ *
+ * THE LAST-FRAME CLAMP. morph.js picks its frame as
+ * `round(t * FPS) % NFRAMES`, so the tween's end, `t = S`, is frame NFRAMES —
+ * which wraps to frame 0. The piece would snap back to its first pose for the
+ * whole hold after it. `pieceTime` stops at `(n - 1) / fps`, the last frame
+ * that exists.
+ *
+ * A DRAWING ERROR IS A PAGE ERROR. The hyperframes runtime runs every seek
+ * inside a `catch` that reports only to a hook the page must install, so an
+ * error thrown from `render` vanished: lint, check, verify and render all
+ * exited 0 over a canvas frozen on its last good pose (the spike's Q2). So
+ * `render` hands the error to `reportError` — the browser's own "uncaught
+ * exception" path, synchronous, which `hyperframes check` records as a
+ * `page_error` and so fails `decksmith verify` — and then rethrows it for any
+ * caller that does not swallow. `render` still exits 0; verify is the gate.
+ *
+ * ONE DRAW PER FRAME. hyperframes' transport seek moves the timeline three
+ * times per captured frame (`N`, `N + .001`, `N`), and each one used to repaint
+ * the whole piece. morph.js draws a pure function of `round(t * FPS)` (with
+ * `sub` unset), so a second draw of the same frame on the same canvas paints
+ * the same pixels: `render` skips it. The memo is per canvas, cleared before a
+ * draw and set only after it returns: a draw that throws leaves the canvas
+ * half-painted, so it must not be remembered as holding any frame.
+ *
+ * Bundled to an IIFE by `scripts/build.mjs` as `dist/ds-animate.js` and loaded
+ * by a deck only when some scene names `dsAnimate` (PLUGINS in
+ * composition.ts). The pure halves are exported for the tests, which is why the
+ * window registration at the bottom is guarded.
+ */
+/** What the scene's `measure` passes `mount`: the numbers the factory's head needs. */
+export interface PieceConfig {
+    /** The piece's length — the figure's `seconds`. */
+    seconds: number;
+    /** Frames per second the piece is baked at. */
+    fps: number;
+    /** The deck's font stack, for the kit's `HAND`. No text is drawn; see `mount`. */
+    hand: string;
+}
+/** What a piece's factory hands back: animate's seekable draw, and its frame count. */
+export interface Piece {
+    rf: (t: number, canvas: HTMLCanvasElement) => unknown;
+    n: number;
+    fps: number;
+}
+/** A piece's script registers one of these under its figure id. */
+export type PieceFactory = (cfg: PieceConfig & {
+    width: number;
+    height: number;
+}) => Piece;
+/**
+ * The attribute `claim-figure` writes on a piece's `<canvas>`. It says the
+ * canvas is 2D by construction: `mount` takes its 2D context before anything
+ * draws, and a canvas holding a 2D context can never hold a WebGL one. The
+ * capture path (`openDeck`, src/render/capture.ts) reads it to exempt the
+ * canvas from its no-WebGL refusal, which otherwise refused every piece on a
+ * checker without GL and so skipped the whole fidelity gate (the spike's Q4).
+ */
+export declare const PIECE_ATTR = "data-ds-piece";
+/** Filled by each piece's script as the document parses. */
+export declare const pieces: Record<string, PieceFactory>;
+/** A mounted piece: what draws it, and the frame its canvas last finished drawing. */
+interface Host {
+    id: string;
+    piece: Piece;
+    drawn: number;
+}
+/**
+ * The piece-local second to draw at tween value `t`: `t`, but never past the
+ * last frame — see THE LAST-FRAME CLAMP above.
+ */
+export declare function pieceTime(t: number, piece: {
+    n: number;
+    fps: number;
+}): number;
+/**
+ * Build piece `id` against `canvas`. Called from the scene's `measure`, inside
+ * the ready gate, so it runs once, before the timeline that tweens it exists.
+ * A throw from the factory — the author's file runs here, not at script load —
+ * leaves the scene's timeline unregistered, which `check` already reports.
+ *
+ * THE CONTEXT IS TAKEN HERE, FIRST, with `willReadFrequently`, so the raster
+ * mode is fixed from frame 0 rather than flipped by whatever reads it back
+ * later (.planning/2026-09-06-canvas-seek-purity.md).
+ */
+export declare function mount(canvas: HTMLCanvasElement | null, id: string, cfg: PieceConfig): void;
+/** A piece frame that threw under `sweep`. */
+export interface BrokenFrame {
+    id: string;
+    /** The frames that threw, in order. */
+    frames: number[];
+    /** The first one's message. */
+    message: string;
+}
+/**
+ * EVERY FRAME OF EVERY MOUNTED PIECE, drawn once, for the gate.
+ *
+ * A DRAWING ERROR IS A PAGE ERROR only at the times something seeks to, and
+ * `hyperframes check` samples a long deck coarsely: a throw confined to a short
+ * window — a bridge's sub-phase, one frame — could fall between its samples,
+ * pass verify, and ship half-painted frames from a render that exits 0. So
+ * `fidelity` calls this once and fails on what it returns.
+ *
+ * Drawn on a scratch canvas of the same size, never the mounted one: `renderFrame`
+ * reads nothing of its canvas but the context, and the deck's canvas and its
+ * frame memo stay exactly as the timeline left them. Each draw runs under the
+ * text trap, as the plugin's does. Nothing is reported to the page; the caller
+ * reads the result.
+ */
+export declare function sweep(): BrokenFrame[];
+interface PluginState {
+    host: Host;
+    canvas: HTMLCanvasElement;
+    end: number;
+}
+/**
+ * `dsAnimate` as a GSAP property. The tween's ease must be "none": the value is
+ * a clock, and an ease would play the piece at a varying speed.
+ */
+export declare const DSAnimatePlugin: {
+    name: string;
+    init(this: PluginState, target: HTMLCanvasElement, value: unknown): void;
+    render(ratio: number, d: PluginState): void;
+};
+export {};

package/dist/types/emit/archetypes/claim-figure.d.ts

@@ -1,5 +1,19 @@
+/**
+ * A claim from the source, shown next to the figure that backs it.
+ *
+ * The layout is chosen from the figure's own aspect ratio rather than being a
+ * parameter: EXPERIMENT-002 full-bled a 1.98-aspect figure and pushed its
+ * caption 200px off-canvas. Only a genuine strip earns the full width.
+ */
+import type { Figure } from "../../types.js";
 import { type Fit } from "../fit.js";
-import type { Emitter } from "../kit.js";
+import type { Emitter, Tween } from "../kit.js";
+/**
+ * The shortest beat that plays a piece of `seconds`: its entrance, the piece,
+ * and the tail before its hold. Exported for the planner, which has to be told
+ * it before it picks a beat's length (src/plan/prompt.ts).
+ */
+export declare const pieceBeatSeconds: (seconds: number) => number;
 type Mode = "tall" | "wide" | "beside";
 /** One way to draw the beat, predicted. */
 export interface Arrangement {
@@ -13,5 +27,74 @@ export interface Arrangement {
 }
 /** The arrangement to draw: the classic mode unless another fills clearly more. */
 export declare function choose(options: readonly Arrangement[]): Arrangement;
+/** What the plate holds, and the tag its height cap and its drift rule name. */
+export interface Plate {
+    html: string;
+    /** `img`, `video` or `canvas`. One CSS rule is written, for whichever is actually there. */
+    el: "img" | "video" | "canvas";
+}
+/**
+ * A CLIP WE HOLD THE FILE FOR IS A `<video>`. EVERYTHING ELSE IS AN `<img>`.
+ *
+ * A PLAYER-PAGE CLIP IS NOT AN ERROR PATH, and that is the whole of why this
+ * branches on `href` rather than on `kind`. `href` is present exactly when the
+ * video's bytes were unavailable — src/types.ts calls it "Absent for a clip we
+ * hold the file for" — and the still is then everything any format can show,
+ * which is what `renderSource` already promises the planner in those words
+ * ("its still is all any format will ever show"). Refusing there would delete a
+ * beat the planner was told it could spend, over a picture that draws perfectly
+ * well.
+ *
+ * The `<img>` branch is byte-for-byte the markup every still has always had, so
+ * a deck with no clip in it is the deck it was.
+ *
+ * AND IT STAYS AN `<img>` NOW THAT `deck.html` CAN BUILD A REAL PLAYER FROM THE
+ * SAME FIGURE. `emitDeck` asks `embedUrl` for the frame-able form of this
+ * `href` and writes it into a deck-only island, so a presented deck offers
+ * click-to-play where the mp4 shows the still. None of that reaches here, and it
+ * must not: this markup goes into `index.html`, which is the document the
+ * renderer CAPTURES. A third-party frame there breaks invariant 4 twice over —
+ * virtual time is propagated only into same-origin frames, so the embed would
+ * play at wall-clock speed while the deck is seeked; and the compile-time
+ * localiser has no pattern for an iframe's src, so every render would refetch it
+ * from the network. `scanDeterminism` refuses a literal `<iframe` in a
+ * composition, and test/emit.test.ts ("never embeds a document it does not own")
+ * asserts the vocabulary never writes one — or this figure's watch URL — to
+ * begin with.
+ *
+ * SHARED WITH `stage`, which is why the refusals name `who` (the archetype and
+ * beat) rather than assuming claim-figure, and why a piece's canvas may be
+ * given a `buffer` size: a stage canvas is the frame, not the figure's box.
+ */
+export declare function plate(fig: Figure, sid: string, who: string, start: number | undefined, buffer?: {
+    width: number;
+    height: number;
+}): Plate;
+/**
+ * What a piece adds to the scene: the statement that mounts it, ONE `fromTo`
+ * that plays it, and the hold after its last frame.
+ *
+ * THE TWEEN IS THE ONLY THING THAT DRAWS (invariants 1 and 11). Its value is
+ * the piece's own second — `0` to `seconds` over `seconds`, ease "none" —
+ * and the `dsAnimate` plugin draws that second as part of the seek
+ * (src/emit/animate-runtime.ts). No callback, no CSS animation: before the
+ * tween the canvas holds frame 0, after it the last frame, so holds and slide
+ * edges are static.
+ *
+ * `hand` is the deck's font stack, for the kit's `HAND`: a piece draws no text,
+ * and the kit's `measureText` should still never name a family the deck does
+ * not declare (invariant 9).
+ *
+ * REFUSED BY NAME rather than clamped: a piece with no length has no clock, a
+ * `src` not ending in `.js` is a script verify never scans, and
+ * a beat too short for the piece would end it mid-motion with the hold clamped
+ * on top of a moving frame. `who` names the archetype and beat, because
+ * `stage` plays a piece through this too.
+ */
+export declare function pieceTimeline(fig: Figure, sid: string, who: string, seconds: number, hand: string): {
+    tween: Tween;
+    mount: string;
+    hold: number;
+};
 export declare const claimFigure: Emitter<"claim-figure">;
 export {};

package/dist/types/emit/archetypes/equation-walk.d.ts

@@ -102,7 +102,7 @@ export declare function chipSetup(sid: string, term: Term): string;
  * asserted something false. `statements` and the `size` cap below are what make
  * the claim true.
  */
-export declare function equationSize(tex: string): number;
+export declare function equationSize(tex: string, v2?: boolean): number;
 /** Estimated rendered width of a display, in ems. */
 export declare function texUnits(tex: string): number;
 /**
@@ -119,5 +119,5 @@ export declare function texUnits(tex: string): number;
 export declare function chipFit(sid: string, terms: Term[]): string[];
 /** One row per term: a chip KaTeX fills in `setup`, and the label. Shared with the morph. */
 export declare function legendRows(sid: string, terms: Term[], theme: Theme): string;
-export declare function legendCss(theme: Theme): string;
+export declare function legendCss(theme: Theme, v2?: boolean): string;
 export declare const equationWalk: Emitter<"equation-walk">;

package/dist/types/emit/archetypes/hero-number.d.ts

@@ -0,0 +1,21 @@
+import type { Emitter } from "../kit.js";
+/** Bars only when the shorter is at most this share of the longer — see the header. */
+export declare const NEAR = 0.85;
+/**
+ * How many full turns reel `i` (0 the leftmost) makes before it lands: one for the most
+ * significant, up to three for the least — a counter's right-hand wheels spin
+ * fastest.
+ */
+export declare function turnsOf(i: number): number;
+/**
+ * `s` as a plain number, or undefined. Thousands separators are allowed; a
+ * fraction, a percentage or a multiplier is not a length on one scale with
+ * anything, so it is not drawn as one.
+ */
+export declare function plainNumber(s: string): number | undefined;
+/**
+ * `value - compare`, signed, at the finer of the two's decimal places, with the
+ * unit: "+0.83 dB". Only called when both are plain numbers.
+ */
+export declare function signedDelta(value: string, compare: string, unit?: string): string;
+export declare const heroNumber: Emitter<"hero-number">;

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

@@ -4,8 +4,8 @@ export declare const emitters: {
     [A in Archetype]: Emitter<A>;
 };
 /**
- * Dispatch a beat to its emitter. The cast is the one place the pairing is taken
- * on trust: `emitters[beat.archetype]` is a union of thirteen emitters and TypeScript
+ * Dispatch a beat to its emitter, over its backdrop when it has one. The cast is the one place the pairing is taken
+ * on trust: `emitters[beat.archetype]` is a union of sixteen emitters and TypeScript
  * will not narrow the key and the beat together. The table above already proves
  * every archetype has exactly one emitter of the right shape.
  */

package/dist/types/emit/archetypes/kinetic.d.ts

@@ -0,0 +1,2 @@
+import type { Emitter } from "../kit.js";
+export declare const kinetic: Emitter<"kinetic">;

package/dist/types/emit/archetypes/pipeline.d.ts

@@ -77,12 +77,24 @@ export interface PipeLayout {
  * `budget` is the height the SVG may take (the region less the wrapper's margin
  * and the note); `region` is the whole body region, which bounds a box's height
  * at `GROWN_BOX_H` of it — the plan's `MAX_BOX_H = 0.8·region.h`. The label's
- * preferred size grows by `GROWTH` and `fitBoxes` still shrinks it to the width.
+ * preferred size is `TYPE_SCALE.body` and `fitBoxes` still shrinks it to the width.
  */
 export interface PipeGrow {
     budget: number;
     region: number;
 }
+/**
+ * The split of `label` into at most `k` lines whose WIDEST line is narrowest,
+ * with no line an orphan (`ORPHAN_SHARE`) — fewer lines when every split into
+ * `k` leaves one, so the grown row takes the bigger type only when it reads.
+ *
+ * `balance` breaks once a line has taken its share, which never breaks a
+ * two-word label whose first word is the shorter: "Split attributes" stays one
+ * line at k = 2, so asking for two lines bought nothing and the grown row held
+ * every label at the one-line size (46px, in 545px boxes). Labels are a handful
+ * of words, so every placement of the `k - 1` breaks is simply tried.
+ */
+export declare function splitEven(label: string, k: number, face: Face): string[];
 /**
  * All the geometry, with no SVG in sight.
  *
@@ -90,6 +102,6 @@ export interface PipeGrow {
  * archetype must never get wrong, and asserting it against numbers beats
  * asserting it against a rendered string.
  */
-export declare function pipeLayout(stageW: number, stages: readonly Stage[], loop?: Loop, face?: Face, grow?: PipeGrow): PipeLayout;
+export declare function pipeLayout(stageW: number, stages: readonly Stage[], loop?: Loop, face?: Face, grow?: PipeGrow, size?: number): PipeLayout;
 export declare const pipeline: Emitter<"pipeline">;
 export {};

package/dist/types/emit/archetypes/stage.d.ts

@@ -0,0 +1,57 @@
+/**
+ * One figure that owns the whole frame.
+ *
+ * Every other archetype draws inside the scene's padded content box under a
+ * headline, so a deck of them is one layout repeated: headline top, body below,
+ * the figure in a framed plate. A stage beat is the other kind of slide — a
+ * product UI, a scene, a photo or an animate piece edge to edge, with no plate,
+ * border or side column, and the words (if any) set over it.
+ *
+ * WHAT KEEPS THE WORDS READABLE IS THE SCRIM, NOT THE PICTURE. The media is
+ * arbitrary — a white paper figure, a dark night scene — so the text is always
+ * white over a black scrim whose solid part covers the whole text block at
+ * `SCRIM` alpha. At 0.55 black over a pure-white pixel the background is
+ * 115/255, which white text clears at about 4.8:1 — over the 4.5:1 bar for
+ * body text, though every stage line is large text (3:1) — so the contrast
+ * gate passes on any picture rather than on the one it was tried with. It was
+ * 0.66 (7:1), which read as a grey slab over a light picture. The solid extent is
+ * DERIVED from the text block's measured height and width, and is
+ * bounded on BOTH axes (`scrimFor`): a scrim that ran the whole width dimmed
+ * the picture's subject wherever it shared the words' rows.
+ *
+ * THE TEXT IS NEVER SHRUNK. Headline and line have fixed sizes above the 40px
+ * floor (invariant 5). Text that does not fit its placement's column in
+ * `MAX_HEAD_LINES` / `MAX_LINE_LINES` takes the next wider column (`WIDER`),
+ * so the words cover more of the picture rather than the slide being dropped;
+ * only text that will not fit across the whole content width is refused by
+ * name, the same answer callout and split-compare give.
+ *
+ * THE CAPTION RESERVE IS LEFT CLEAR. The media and its scrim stop `reserveRef`
+ * above the bottom edge, so a deck that asked for burned captions keeps the
+ * strip it asked for (`ink_in_caption_reserve`). Nothing that MOVES is that
+ * box: the entrance scales an inner wrapper the box clips, so no frame of it
+ * reaches the strip either.
+ */
+import type { STAGE_PLACEMENTS } from "../../types.js";
+import type { Emitter } from "../kit.js";
+type Placed = Exclude<(typeof STAGE_PLACEMENTS)[number], "none">;
+/**
+ * The scrim for a text block `textH` tall whose longest line is `textW` wide,
+ * in reference px of a scrim box `boxW` x `boxH`. The words' own width, not
+ * their column's: a one-line headline in a 62% column left the scrim solid over
+ * picture the words never reach. Solid over the block and `SCRIM_MARGIN` past it,
+ * then a `SCRIM_FADE` to clear — so the picture is untouched away from the
+ * words, on both axes.
+ *
+ * TWO GRADIENTS, MULTIPLIED: `background` runs along one axis and `mask` along
+ * the other, so the scrim's alpha is the product — solid only where both are,
+ * which is the block plus its margin. Two `background` layers cannot do this:
+ * layers composite as a union, and a union of two full-length bands is the
+ * header bar across the slide this archetype exists to avoid.
+ */
+export declare function scrimFor(placement: Placed, textH: number, textW: number, boxW: number, boxH: number): {
+    background: string;
+    mask: string;
+};
+export declare const stage: Emitter<"stage">;
+export {};

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

@@ -0,0 +1,114 @@
+/**
+ * A diagram drawn over a full-bleed picture.
+ *
+ * The founder's bar is explainer-video motion, and what he hates is a deck of
+ * cards on one pale ground. Stage gives a picture the whole frame but has no
+ * room for a mechanism; the diagram archetypes draw the mechanism on the pack's
+ * ground. A `backdrop` (src/types.ts) puts the second over the first: the
+ * picture covers the frame and drifts, a scrim darkens it, and the panels are
+ * drawn as dark glass with light ink.
+ *
+ * ONE WRAPPER, NOT FOUR EMITTERS TAUGHT A SECOND PALETTE. Every archetype paints
+ * through its `Theme` — panel, ink, rule, tones — so the archetype is emitted
+ * unchanged with the GLASS theme (`glass`) and this file adds the picture under
+ * it. Geometry, holds and stop counts are therefore the archetype's own: only
+ * colours move, which is also why the measuring passes (`planCut`, `narrate`,
+ * `timing`) can run through it without disagreeing with the build.
+ *
+ * THE ARCHETYPES' CSS IS UNSCOPED (`.panel{background:…}`) and the shell emits
+ * each distinct block once for the whole deck, so a glass `.panel` rule would
+ * repaint every callout in the deck — or lose to a pale one emitted later. So a
+ * backdrop scene's stylesheet is scoped to the scene (`scopeCss`), raising every
+ * one of its rules by the same one id, so their order among themselves is kept.
+ *
+ * WHAT KEEPS THE WORDS READABLE IS THE SCRIM, NOT THE PICTURE — stage's rule,
+ * applied to the whole frame because a diagram's words are everywhere. At
+ * `SCRIM` black over a pure-white pixel the ground is 97/255; every glass ink —
+ * `MUTED`, and each tone after `readable` lifts it — clears 4.5:1 on that, so
+ * the contrast gate passes on any picture rather than on the one tried. Text on
+ * a glass panel sits on the panel's own fill over that, darker still.
+ *
+ * `DIM` ALONE IS HELD TO 3:1, and on purpose. It is what an archetype steps
+ * back to — bar-compare paints every bar it is not pointing at in it — so it
+ * must be DARKER than every lifted tone, or the bars in the background are the
+ * brightest marks on the slide (round 1 of the 2026-10-09 ko e2e: dim at
+ * luminance 0.76 over tones at 0.71-0.74, in every pack). Tones sit at 4.5:1,
+ * so dim goes below that; 3:1 is the contrast audit's floor for large text,
+ * which all audience text is (invariant 5: never below 40px).
+ */
+import type { Backdrop, Beat, Figure } from "../types.js";
+import type { EmitContext, Scene, Theme } from "./kit.js";
+/** Black at this alpha over the whole picture — see the header. */
+export declare const SCRIM = 0.62;
+/** The backdrop a beat asks for, if its archetype takes one. */
+export declare function backdropOf(beat: Beat): Backdrop | undefined;
+/**
+ * The figure a beat's backdrop resolves to, or undefined when it has none.
+ *
+ * A PENDING backdrop — a brief `illustrate` has not drawn — is drawn without
+ * one rather than refused: the planner's own passes (`assertInsideResolves`)
+ * emit beats before `illustrate` runs, and `assertRefsResolve` refuses a
+ * pending brief before any build gets here.
+ */
+export declare function backdropFigure(beat: Beat, ctx: EmitContext): Figure | undefined;
+/** Contrast of `hex` on the worst-case ground. */
+export declare function onWorstGround(hex: string): number;
+/**
+ * The theme a backdrop scene is drawn in: the pack's type and forms, glass
+ * colours, and its tones lifted only as far as they must go to read on the
+ * scrim (`readable`).
+ */
+export declare function glass(theme: Theme): Theme;
+/**
+ * Every top-level rule of `css` raised by the scene's id. A selector already
+ * rooted at the scene (`#s3 .panel`) repeats the id (`#s3#s3 .panel`, the same
+ * element) so it stays exactly one id above the rules it used to beat; any
+ * other selector is put under the scene. At-rules — the `.ds-live` ambient
+ * rule, already scoped by its own construction — are left alone.
+ */
+export declare function scopeCss(css: string, sid: string): string;
+/**
+ * `scene`, emitted with the `glass` theme, set over `fig`.
+ *
+ * The picture sits UNDER the archetype's own html at `z-index:-1` inside a
+ * scene that isolates its stacking, so no in-flow element has to be told it is
+ * on a picture. It stops `reserveRef` above the bottom edge, as stage's does,
+ * so a deck with burned captions keeps its strip clear.
+ *
+ * `fit` is dropped: the fill gate measures ink off the frame's modal colour,
+ * and a full-bleed picture has none, so its prediction could only disagree.
+ */
+export declare function overBackdrop(scene: Scene, fig: Figure, ctx: EmitContext, seconds: number): Scene;
+/**
+ * The FIELD a full-bleed archetype stands on when it has no picture: the
+ * pack's accent taken toward black until it is no lighter than half the
+ * scrim's worst-case ground (`WORST_GROUND`). Every `glass` ink is held to
+ * 4.5:1 on that ground, so on a darker one each clears it with room to spare —
+ * the same proof, not a second palette. Keeps the hue, so a deck's fields are
+ * its own colour rather than one stock navy. Not `#rrggbb`: the glass ground.
+ */
+export declare function fieldColour(accent: string): string;
+/**
+ * Which of the pack's colours a field takes, by the scene's place in the deck:
+ * the accent and each tone that is not the accent, in turn. Round 2 of the
+ * 2026-10-09 ko e2e set five field beats on one identical blue, and two hero
+ * numbers 19 s apart read as the same slide with new digits. Neighbours differ
+ * whenever the pack has two colours, and beats two apart whenever it has three
+ * — the variety rule never lets two of one archetype touch, so two apart is the
+ * nearest the same layout comes. By the scene id, not a counter, so every pass
+ * that emits one beat (planCut, narrate, the Director) agrees with the build.
+ */
+export declare function fieldStep(theme: Theme, sid: string): {
+    colour: string;
+    focus: string;
+};
+/**
+ * `scene`, emitted with the `glass` theme, set over a field of the pack's
+ * accent (`fieldColour`) — what `hero-number` and `kinetic` stand on without a
+ * `backdrop`, so that neither is ever a card on the pale ground.
+ *
+ * The field is never lighter than its flat colour: what moves over it is a
+ * vignette of black, drifting slowly across the beat on a `fromTo`, so the
+ * frame is alive without any pixel of it rising toward the inks.
+ */
+export declare function overField(scene: Scene, ctx: EmitContext, seconds: number): Scene;

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

@@ -455,6 +455,14 @@ export interface Scene {
     holds: number[];
     /** CSS this archetype needs. Deduplicated by the shell, emitted once. */
     css?: string;
+    /**
+     * The scene's entrances ARE what it says, so the v2 motion grammar must not
+     * re-voice them (`restyleEntrance` in ./motion.ts). Set by `kinetic`, whose
+     * phrases each arrive with a move of their own: re-voiced into the deck's one
+     * verb for the scene, four phrases arrived the same way and the beat was a
+     * paragraph fading in. In memory only, never serialised.
+     */
+    ownEntrances?: boolean;
     /**
      * The archetype's own prediction of how full its final hold is — v2 only.
      * In memory, never serialised into the composition (like `parts`); the shell

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

@@ -68,6 +68,20 @@ export declare function variantOf(ctx: EmitContext, archetype: Archetype): strin
  * not, whatever their text says.
  */
 export declare function signature(archetype: Archetype, look?: Look): string;
+/**
+ * Whether an archetype has chrome a look places. A `stage` sets its words over
+ * the picture where its own `placement` param says, so the `top` in its classic
+ * look is not on the slide: counted as top chrome, every stage inflated
+ * `modalChrome` and charged the beat after two of them for a "third top in a
+ * row" nobody could see.
+ */
+export declare function chromeless(archetype: Archetype): boolean;
+/**
+ * `signature`, for a beat. A stage's is where its words sit — the one thing
+ * that tells two stages apart at a glance — rather than the `top` its look
+ * carries, which every stage shares.
+ */
+export declare function beatSignature(beat: Beat, look?: Look): string;
 /**
  * Whether the canvas is wide enough to set a headline in a column beside the
  * body. 16:9 only in practice: at 1:1 the rail would be 292px and a 64px