@jokerized/decksmith 0.9.5 → 0.9.6

package/dist/types/bespoke/pipeline.d.ts

@@ -201,7 +201,7 @@ export interface BespokeResult {
  * What a cached verdict was reached under: the browser's gates and the static
  * `card_row`. A rejection stamped otherwise is asked about again.
  */
-export declare const GATE_STAMP = "gates-7+cards-2:0.08/0.6/0.8/0.2/0.12";
+export declare const GATE_STAMP = "gates-8+cards-2:0.08/0.6/0.8/0.2/0.12";
 /** A second critique starts only with this much of the wall-time cap left, seconds. */
 export declare const SECOND_SECONDS = 420;
 /** Repair rounds after the final gates, each one probe build of the repaired scenes only. */

package/dist/types/bespoke/scene.d.ts

@@ -13,6 +13,12 @@ export interface BespokeEntry {
     holds: number[];
     /** The beat's illustration, when it has one: `<image data-art="1">` shows it (src/bespoke/art.ts). */
     art?: ArtRef;
+    /**
+     * The section name above the headline when the beat's archetype has no
+     * `eyebrow` of its own (a stage, a kinetic beat): a literal scene's `eyebrow`
+     * slot. The archetype's own eyebrow wins.
+     */
+    eyebrow?: string;
     /**
      * The narration cues on the scene's clock and its length, from the same
      * timing the cue windows came from: what the shell's camera is timed to
@@ -29,6 +35,12 @@ export interface BespokeEntry {
     grammar?: Grammar;
     /** A data scene's build (src/bespoke/databuild.ts), stamped on the scene for the deck gate. */
     build?: DataBuild;
+    /**
+     * Clip the body to its box, as a camera scene is. A literal scene (src/literal/) sets it:
+     * its pictures move inside their own clipped panels (a push-in on a detail), and the
+     * clip is what tells the layout gate that what they carry past a panel is not painted.
+     */
+    clip?: true;
 }
 /** The file `build` writes beside a deck with the bespoke pass's account of itself. */
 export declare const BESPOKE_FILE = "bespoke.json";
@@ -36,8 +48,12 @@ export declare const BESPOKE_FILE = "bespoke.json";
 export type BespokeMap = Readonly<Record<string, BespokeEntry>>;
 /** Space the body box leaves under the chrome — the same 34px `bodyBudget` charges by default. */
 export declare const BODY_TOP = 34;
-/** The box the generated drawing gets, in reference px. The prompt quotes it. */
-export declare function bespokeRegion(beat: Beat, ctx: Pick<EmitContext, "format" | "theme">): {
+/**
+ * The box the generated drawing gets, in reference px. The prompt quotes it.
+ * `eyebrow` is the scene's own section name when the archetype has none
+ * (`BespokeEntry.eyebrow`): it takes a line of the chrome too.
+ */
+export declare function bespokeRegion(beat: Beat, ctx: Pick<EmitContext, "format" | "theme">, eyebrow?: string): {
     width: number;
     height: number;
 };

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

@@ -10,3 +10,18 @@ export declare const emitters: {
  * every archetype has exactly one emitter of the right shape.
  */
 export declare function emitScene(beat: Beat, ctx: EmitContext): Scene;
+/**
+ * v2: every PART of a scene stands at `PREVIEW` from the open instead of
+ * arriving from nothing, and comes to full when its tween runs — so every hold
+ * shows the whole layout (the fill gate measures the content's box at each one,
+ * src/verify/fill.ts) and the reveal still says which part is being spoken to.
+ *
+ * A part is an element addressed by id alone whose FIRST tween fades it in
+ * from 0, and which no later tween fades out again: a transient (a packet, a
+ * morph's intermediate, a highlight that comes and goes) or a part shown in
+ * place of another would read as a ghost, so it keeps its own entrance. The
+ * chrome and class-addressed words are left alone. The entrance's offset and
+ * scale (`x`, `y`, `scale…`) are dropped: a previewed part stands where and as
+ * large as it lands, so its words are never drawn under their declared size.
+ */
+export declare function previewParts(scene: Scene, sid: string): Scene;

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

@@ -241,10 +241,25 @@ export declare function openSeconds(scene: Scene): number;
  * divergence between them is invisible. Sharing the code is the only thing that
  * makes them the same answer.
  */
-export declare function stageScene(scene: Scene, speed: number): {
+export declare function stageScene(scene: Scene, speed: number, 
+/** The beat's sentences, for an ARCHETYPE scene: see `onSentences`. */
+segments?: readonly Segment[]): {
     scene: Scene;
     open: number;
 };
+/**
+ * An archetype scene with a slow lean through each still stretch of its speech.
+ *
+ * `onSentences` lands each reveal on its sentence, but one sentence is often 7-9s
+ * and an archetype reveals once per sentence, so the rest of it stood still: r2 of
+ * the literal verbs run had ten `dead_stretch` failures, every one an archetype (a
+ * title held 8.9s, a callout panel 8.5s). Literal scenes already lean their camera
+ * over what is left of a sentence (`drift` in src/literal/kind.ts); this is the same
+ * move on the scene box: in and back out between a reveal's hold and the next
+ * reveal (or the scene's end), so every hold — where the layout gates photograph —
+ * sees the scene at rest, and the exit's own `scale: 1` from-state does not jump.
+ */
+export declare function leanThroughSentences(scene: Scene, sid: string, seconds: number): Scene;
 /**
  * When each sentence of a beat is spoken, on one continuous clock.
  *

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

@@ -195,6 +195,12 @@ export interface EmitContext {
     source: Source;
     format: Format;
     theme: Theme;
+    /**
+     * The deck's language (the storyboard's BCP-47 `lang`). A figure's own caption
+     * is printed only when it is written in it (`inLanguage`). Absent: printed as
+     * before.
+     */
+    lang?: string;
     /**
      * 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
@@ -503,6 +509,25 @@ export declare function js(s: string): string;
  * `-h` or `-e` to a spotlight.
  */
 export declare const DIM = 0.62;
+/**
+ * Where a v2 part not yet spoken stands, from the scene's open: the whole
+ * layout is on screen at every hold — the fill gate measures the content's box
+ * at each one (src/verify/fill.ts) — and a part comes to full when it is spoken.
+ * Below `DIM` on purpose: it reads as "coming", not as "said".
+ */
+export declare const PREVIEW = 0.32;
+/**
+ * When the preview fades up, scene seconds: after the seam into the scene (the
+ * outgoing slide is gone by then, so nothing previewed overlaps its words) and
+ * before the first hold.
+ */
+export declare const PREVIEW_AT = 0.5;
+/**
+ * A v2 part's two tweens: up to `PREVIEW` as the scene opens, then to `to` at
+ * `at`, from where the preview left it. A part revealed during the opening
+ * keeps its plain entrance, since its preview would not be seen.
+ */
+export declare function previewed(target: string, from: Vars, to: Vars, at: number): Tween[];
 /**
  * How much bigger the part under discussion stands than its neighbours.
  *
@@ -624,3 +649,11 @@ export declare function wordAtoms(text: string): {
     text: string;
     spaced: boolean;
 }[];
+/**
+ * Whether `text` is written in the script of `lang`: Hangul for Korean, kana or
+ * Han for Japanese, Han for Chinese, and no CJK at all for any other language.
+ * A heuristic on script, which is what an untranslated caption gets wrong.
+ */
+export declare function inLanguage(text: string, lang: string): boolean;
+/** The caption a figure prints: the plan's own, else the source's when it is in the deck's language, else none. */
+export declare function figureCaption(planned: string | undefined, source: string, lang: string | undefined): string;

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

@@ -189,6 +189,25 @@ export declare function textWidth(text: string, fontSize: number, weight?: numbe
  * one unbroken "word".
  */
 export declare function wrap(text: string, fontSize: number, maxWidth: number, weight?: number, tracking?: number, face?: Face): string[];
+/**
+ * A run with no spaces as the units a line may break between: a number or a
+ * Latin name whole ("88.84", "OneVL", "T5-XXL"), any other character alone, and
+ * closing punctuation kept on the unit before it so no line starts with "：".
+ */
+export declare function atomsOf(word: string): string[];
+/**
+ * A figure's caption as a slide sets it, in at most `lines` lines of `width`.
+ *
+ * Its first sentence — the "Figure 5: A simplified trace diagram…" title the
+ * authors wrote — and, where even that is too long, cut at a word (a character,
+ * in a script with no spaces) with the ellipsis typed into the text. A caption
+ * is provenance; a paper's own runs to 600 characters ("Figure 1: Our technique
+ * illustrated…" from arXiv), which beside a claim took the whole column and
+ * left the figure a 30px plate, and under an annotated figure was clamped by
+ * CSS, which the layout gate rightly calls clipped text. The full caption stays
+ * the image's alt.
+ */
+export declare function captionFit(caption: string, fontSize: number, width: number, lines: number, face?: Face, weight?: number): string;
 /**
  * Whether `wrap` would have to cut a word letter by letter to set `text` at
  * this size and width — "Rectified-flo" / "w". `wrap` does that as a last

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

@@ -6,6 +6,19 @@
 export declare const UNFIT_ATTR = "data-ds-unfit";
 /** KaTeX's message for `tex`, or null when it parses. Same options the deck uses. */
 export declare function texError(tex: string, display: boolean): string | null;
+/**
+ * A command whose backslash was doubled on the way in, or null.
+ *
+ * `\\frac{p}{q}` PARSES — KaTeX reads a line break, then the letters f r a c —
+ * so `texError` passes it and the slide says "fracpq". Doubling is what a
+ * markdown escape does to TeX (measured on arXiv 2211.17192, every inline
+ * equation of it). Outside an environment a line break directly before a
+ * letter is not something a formula is written with, so it is refused rather
+ * than guessed at: the fix belongs where the TeX was read, not here.
+ */
+export declare function escapedCommand(tex: string): string | null;
+/** The sentence a build fails with for `escapedCommand`'s finding. */
+export declare function escapedCommandError(where: string, id: string, tex: string): string | null;
 export interface Repaired {
     /** The TeX to render: the input when it parsed, otherwise the repaired form. */
     tex: string;

package/dist/types/literal/check.d.ts

@@ -0,0 +1,45 @@
+/**
+ * PLAN-TIME CHECKS: every literal scene drawn as the build draws it, at the
+ * region and in the face the build lays it out with, without its material — a
+ * verb on placeholder material (its own run), a word form or a cross-cutting
+ * kind by its fragment on placeholder layers and no cues. What it refuses (a
+ * step label with no room, a lane with nothing to show, rings that do not fit,
+ * a parameter an op does not take) is sent back to the planner for repair
+ * instead of failing `build --literal`.
+ */
+import type { Theme } from "../emit/kit.js";
+import type { Literal } from "../types.js";
+/** What stops a literal scene being drawn at `region`, or nothing. */
+export declare function drawProblems(lit: Literal, region_: {
+    width: number;
+    height: number;
+}, theme: Theme): string[];
+/**
+ * When each part of a literal scene's script is first SHOWN — a fade from 0 or a
+ * wipe from width 0 — and when that reveal ends, scene seconds, in order. Read
+ * off the emitted script (`Tl` writes JSON), so it judges what ships. A part
+ * hidden only by its parent is not seen here.
+ */
+export declare function firstShown(script: string): Array<{
+    id: string;
+    at: number;
+    end: number;
+}>;
+/** A part must stand whole on screen at least this long before its scene cuts away. */
+export declare const SEEN_WHOLE_S = 1;
+/**
+ * The parts of a literal scene that arrive too late to be seen: first shown
+ * less than `SEEN_WHOLE_S` before the scene ends (`duration`, scene seconds),
+ * or still arriving when it does. r2's scope lit its last item so late that
+ * the 2s frames never caught it before the cut.
+ *
+ * A step after the last hold is the stage's business, not this check's: the
+ * holds are the starts of the narration's STOPS, and the stage
+ * (src/literal/kinds/stage.ts) puts a scene's last step no later than the
+ * sentence that opens its last stop, then tours the finished picture.
+ */
+export declare function lateReveals(script: string, duration: number): Array<{
+    id: string;
+    at: number;
+    end: number;
+}>;

package/dist/types/literal/formula.d.ts

@@ -0,0 +1,78 @@
+/**
+ * A TINY FORMULA GRAMMAR for the expressions a source prints: numbers, names
+ * (Greek letters, subscripts: α, γ, x0, C_v), + − × ÷ ^, parentheses, and
+ * min max abs exp log sqrt clip. Parsed once, evaluated on numbers (the build)
+ * or on INTERVALS (the truth gate).
+ *
+ * Why intervals: a source prints rounded numbers. "α = 0.6, γ = 2 → 1.96X" is
+ * three rounded values, and a correct formula evaluated at the printed 0.6 can
+ * miss the printed 1.96 at the last digit. So a check is passed when the
+ * formula, over every input's printed-precision interval, reaches the output's
+ * own interval: a correct formula always passes, a wrong one almost never does
+ * across a table's rows. A decimal input carries half a unit of its last digit;
+ * an integer input is taken as exact (a count, not a measurement).
+ *
+ * No variable has a default and nothing is evaluated that the expression does
+ * not name. Pure.
+ */
+export type Ast = {
+    t: "num";
+    v: number;
+} | {
+    t: "var";
+    name: string;
+} | {
+    t: "neg";
+    a: Ast;
+} | {
+    t: "bin";
+    op: "+" | "-" | "*" | "/" | "^";
+    a: Ast;
+    b: Ast;
+} | {
+    t: "call";
+    fn: string;
+    args: Ast[];
+};
+/** Unicode operators and TeX spacing written as the plain grammar. */
+export declare function normalizeExpr(s: string): string;
+export declare const GREEK: Readonly<Record<string, string>>;
+/** Parse an expression; throws with the expression on anything it cannot read. */
+export declare function parseFormula(src: string): Ast;
+/** The variable names an expression reads. */
+export declare function variablesOf(ast: Ast): string[];
+/** Evaluate on numbers; a name with no value throws. */
+export declare function evaluate(ast: Ast, env: Readonly<Record<string, number>>): number;
+export type Iv = readonly [number, number];
+/** Evaluate on intervals: the result holds every value the expression takes over the inputs' boxes. */
+export declare function evaluateIv(ast: Ast, env: Readonly<Record<string, Iv>>): Iv;
+/**
+ * A printed number as the interval it stands for: "0.6" is [0.55, 0.65], "2"
+ * is exactly 2 for an input (`exact`), [1.5, 2.5] for an output. Undefined
+ * when the text is not one plain number.
+ */
+export declare function printed(value: string, exact?: boolean): Iv | undefined;
+export interface FormulaCheck {
+    inputs: ReadonlyArray<{
+        name: string;
+        value: string;
+    }>;
+    output: string;
+}
+/**
+ * Whether one check passes: the formula over its inputs' printed intervals
+ * (with `fixed` ones added) reaches the printed output's interval. Returns the
+ * reason when it does not.
+ */
+export declare function checkPasses(ast: Ast, check: FormulaCheck, fixed?: Readonly<Record<string, Iv>>): {
+    ok: true;
+} | {
+    ok: false;
+    why: string;
+};
+/**
+ * The expression over every piece of its inputs' boxes, each cut into `k`. Only the
+ * variables it reads are cut, and `k` shrinks so there are at most 4096 pieces (k^n
+ * grows fast; a coarser cut is still an enclosure, only a wider one).
+ */
+export declare function evaluateSplit(ast: Ast, env: Readonly<Record<string, Iv>>, k0: number): Iv[];

package/dist/types/literal/index.d.ts

@@ -0,0 +1,133 @@
+import { z } from "zod";
+import type { Fragment } from "../bespoke/contract.js";
+import { type BespokeMap } from "../bespoke/scene.js";
+import { type DeckNarration } from "../emit/composition.js";
+import type { Theme } from "../emit/kit.js";
+import { type Timing } from "../render/timing.js";
+import { type Beat, type Format, type LiteralKind, type Source, type Storyboard } from "../types.js";
+import { type Cue, type Layers } from "./kit.js";
+declare const specSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        table: "table";
+        "prior-work": "prior-work";
+        operate: "operate";
+        evolve: "evolve";
+        flow: "flow";
+        place: "place";
+        region: "region";
+        recap: "recap";
+    }>;
+    takeaway: z.ZodString;
+    labels: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    image: z.ZodOptional<z.ZodString>;
+    data: z.ZodOptional<z.ZodUnknown>;
+    assets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    headline: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type LiteralSpec = z.infer<typeof specSchema> & {
+    kind: LiteralKind;
+};
+/**
+ * What the pass draws, by beat. Built from the storyboard's own `literal` beats
+ * (`literalPlanOf`), or read from a prototype side file of this shape.
+ */
+export declare const literalPlanSchema: z.ZodObject<{
+    image: z.ZodOptional<z.ZodString>;
+    beats: z.ZodRecord<z.ZodString, z.ZodObject<{
+        kind: z.ZodEnum<{
+            table: "table";
+            "prior-work": "prior-work";
+            operate: "operate";
+            evolve: "evolve";
+            flow: "flow";
+            place: "place";
+            region: "region";
+            recap: "recap";
+        }>;
+        takeaway: z.ZodString;
+        labels: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        image: z.ZodOptional<z.ZodString>;
+        data: z.ZodOptional<z.ZodUnknown>;
+        assets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        headline: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type LiteralPlan = z.infer<typeof literalPlanSchema>;
+/** The figure a beat shows: its own, a split-compare side's, or its backdrop's. */
+export declare function figureOf(beat: Beat): string | undefined;
+/**
+ * The plan the storyboard carries: every beat with a `literal`, its takeaway,
+ * its labels, and the file its `picture` beat's figure lives in (under
+ * `assetsDir`, the source's `assets/`). Fails loudly on a picture that does
+ * not resolve: a scene computed from no picture is no scene.
+ */
+export declare function literalPlanOf(storyboard: Storyboard, source: Source, assetsDir: string): LiteralPlan;
+/**
+ * Each of the source's own figures, cut into panels as the build cuts it for a
+ * `region` or a figure trace (`panel`). A figure whose file
+ * is missing or unreadable is left out: the build names it.
+ */
+export declare function figurePanelCounts(source: Source, assetsDir: string): Promise<Record<string, number>>;
+/** Where the computed layers live in a deck. */
+export declare const LITERAL_DIR = "assets/literal";
+/** One literal scene's fragment, in token form, from its computed layers. */
+export declare function literalFragment(kind: LiteralKind, layers: Layers, region: {
+    width: number;
+    height: number;
+}, cues: readonly Cue[], spec: LiteralSpec, theme: Theme): Fragment;
+/**
+ * A scene's script with a slow lean of the whole scene through each still stretch
+ * of a sentence: back, and forward to rest before the next sentence starts or the
+ * next tween runs, so every hold (a sentence's start) sees the layout as drawn.
+ *
+ * A kind times its steps on the sentences, but a step is one reveal and a sentence
+ * runs 7-9s: r2's results table stood 6.4s after each row lit, and a lengths scene
+ * with two groups over four sentences stood 12s across its last two. The kinds
+ * that lean their own camera (`drift`) leave no stretch for this to find.
+ *
+ * Reads the script it is given — every line is `Tl`'s `tl.fromTo(..., {to}, at);`
+ * with a JSON `to` — and a line it cannot read counts as busy for 1s, so an
+ * unfamiliar line can only make the lean shorter, never overlap a tween.
+ */
+export declare function leanThroughStill(script: string, cues: readonly Cue[]): string;
+/**
+ * A scene's narration as its SENTENCES — one cue per sentence spoken, from its
+ * first subtitle line to its last — on the scene's clock. Not the subtitle
+ * lines: the voice splits a long sentence into two lines, and a scene timed on
+ * lines took one causal step per half-sentence (r1, b17: the second row lit in
+ * the middle of the first row's sentence). Not the stops either: a stage beat
+ * speaks several sentences in one stop, and each is still a step.
+ */
+export declare function sentenceCues(timing: Pick<Timing, "scenes" | "segments">, sid: string): Cue[];
+export interface LiteralInput {
+    storyboard: Storyboard;
+    source: Source;
+    format: Format;
+    narration: DeckNarration;
+    theme: string;
+    plan: LiteralPlan;
+    /** Directory the plan's `image` is relative to. */
+    planDir: string;
+    /** The deck directory: layers go under `<out>/assets/literal/`. */
+    out: string;
+    onStep?: (m: string) => void;
+}
+export interface LiteralReport {
+    version: 1;
+    scenes: Array<{
+        beat: string;
+        kind: LiteralKind;
+        takeaway: string;
+        layers: string[];
+        cues: Cue[];
+    }>;
+}
+/**
+ * Compute every literal beat's layers and fragment. A beat not in the plan, or
+ * one the cut dropped, keeps its archetype.
+ */
+export declare function literalPass(input: LiteralInput): Promise<{
+    map: BespokeMap;
+    report: LiteralReport;
+}>;
+export {};

package/dist/types/literal/kind.d.ts

@@ -0,0 +1,121 @@
+/**
+ * THE KIND CONTRACT: what a literal kind is given and what it returns, plus
+ * the drawing helpers every kind shares (slot text, step timing, panels, word
+ * wrap). A kind is one module in `src/literal/kinds/` exporting a `KindImpl`,
+ * listed once in `src/literal/registry.ts`.
+ *
+ * EVERY WORD ON SCREEN IS A SLOT (src/types.ts `LITERAL_KIND_DOCS`), with no
+ * default: a kind has no paper's facts and no language built in.
+ */
+import type { Fragment } from "../bespoke/contract.js";
+import type { Theme } from "../emit/kit.js";
+import type { LiteralKind } from "../types.js";
+import { type Cue, type Layers, type Tl } from "./kit.js";
+/** What a kind is given: its picture (picture kinds), its data (data kinds), the earlier scenes (recap). */
+export interface KindInput {
+    beatId: string;
+    /** Absolute path of the picture, for a picture kind. */
+    image?: string;
+    /** Where the layers are written. */
+    dir: string;
+    region: {
+        width: number;
+        height: number;
+    };
+    spec: KindSpec;
+    /**
+     * The deck's theme: a kind that lays out words at build time measures them in
+     * the deck's own face (`widthOf`). Required, so a caller cannot drop it silently.
+     */
+    theme: Theme;
+    /** Earlier literal scenes of this deck, by beat id, in deck order. */
+    earlier: ReadonlyMap<string, {
+        kind: string;
+        layers: Layers;
+        labels: Record<string, string>;
+    }>;
+}
+export interface KindSpec {
+    labels: Record<string, string>;
+    /** The storyboard's `literal` object. */
+    data?: unknown;
+    /**
+     * The beat's headline, the words on screen above the scene: an item or a row it
+     * NAMES is the scene's subject and is emphasised from the first frame (`namedIn`).
+     */
+    headline?: string;
+    /** The source's own figures a scene may show, by id → absolute file. */
+    assets?: Record<string, string>;
+}
+export interface KindImpl {
+    /** Whether the kind computes from the deck's picture. */
+    picture: boolean;
+    layers(input: KindInput): Promise<Layers>;
+    fragment(L: Layers, region: {
+        width: number;
+        height: number;
+    }, cues: readonly Cue[], spec: KindSpec, theme: Theme, href: (f: string) => string): Fragment;
+}
+/** A slot's text (src/types.ts `LITERAL_KIND_DOCS`): no defaults, so no paper's facts and no language are built in. */
+export declare const lab: (kind: LiteralKind, spec: KindSpec, slot: string, vars?: Readonly<Record<string, string | number>>) => string;
+export declare const LAB_H = 60;
+/**
+ * Whether `text` (a headline) names `name` (an item, a row, a group): the name,
+ * without a parenthetical ("Model (variant)" is named by "Model"),
+ * as a whole word — so "Net" does not name "Res Net+Head" and "Head" does not
+ * name "Res Head". Case and width folded (NFKC). A name of one character names
+ * nothing.
+ */
+export declare function namedIn(text: string | undefined, name: string): boolean;
+/**
+ * The indexes of `names` the headline names — the scene's subject. Empty when it
+ * names none, or every one (then nothing stands out from anything).
+ */
+export declare function subjectOf(text: string | undefined, names: readonly string[]): Set<number>;
+export declare const even: (n: number) => number;
+/**
+ * When `n` causal steps start: on the narration's cues when there are enough,
+ * else spread evenly over the narrated span (one step per cue is the rule;
+ * this is only for a beat narrated in fewer sentences than it has steps).
+ */
+export declare function stepStarts(cues: readonly Cue[], n: number): number[];
+/**
+ * A slow move across a real picture (or a computed layer) between two times:
+ * the picture's own motion — a push-in on a detail, a pan along it — so a long
+ * sentence does not play over a frozen frame. Never a decoration: the element
+ * moved is the material the scene computed. `from` is where the previous move
+ * of the same element left it.
+ */
+export interface Pose {
+    x: number;
+    y: number;
+    scale: number;
+}
+export declare const REST: Pose;
+export declare function drift(tl: Tl, id: string, t0: number, t1: number, to: Pose, from?: Pose, origin?: string): void;
+/**
+ * When `n` sub-steps of one step start, spread over the step's own sentence
+ * (from `t0` to `t1`, leaving `tail` seconds at the end), never closer than
+ * `min` nor further apart than `max`: a step's parts arrive while it is spoken,
+ * not in the first second and then nothing.
+ */
+export declare function spread(t0: number, t1: number, n: number, min?: number, max?: number, tail?: number): number[];
+export declare function img(id: string, src: string, x: number, y: number, w: number, h: number, extra?: string): string;
+export declare function panel(id: string, x: number, y: number, w: number, h: number, inner: string, cls?: string): string;
+/** Rendered width of a label, px, in the deck's face. */
+export declare function widthOf(text: string, size: number, theme: Theme, weight?: number): number;
+/** Greedy wrap to `maxW` px in the deck's face (`wrapBy`); a unit wider than the line keeps its own line. */
+export declare function wrap(text: string, size: number, maxW: number, theme: Theme, weight?: number): string[];
+/**
+ * A label on a picture that wraps to the picture's width instead of running past its
+ * edge (a panel clips it: "…적용한 장면 0" in r3 of the pure-planner deck). One element, so
+ * a tween of `id` still moves all of it; the browser wraps where `wrap` does — at spaces
+ * (keep-all keeps a Korean word whole), and between Han or kana characters, which
+ * keep-all would forbid — and `fromBottom` grows it upward from `y` by the lines `wrap`
+ * measures.
+ */
+export declare function tag(id: string, text: string, x: number, y: number, maxW: number, size: number, color: string, theme: Theme, extra?: string, fromBottom?: boolean): string;
+export declare function std(v: ArrayLike<number>): number;
+export declare function mean(v: ArrayLike<number>): number;
+/** A deterministic sequence in [0, 1): a 32-bit LCG, seeded. Build time only (invariant 4 is render time). */
+export declare function lcg(seed: number): () => number;