@jokerized/decksmith 0.1.0

package/dist/types/types.d.ts

@@ -0,0 +1,1992 @@
+/**
+ * The contract every layer builds against.
+ *
+ * Two objects matter. `Source` is what ingestion produces: the document's
+ * structure with every asset addressable by id. `Storyboard` is what planning
+ * produces: an ordered list of beats, each accountable to something in the
+ * Source. Everything downstream is a projection of the Storyboard.
+ *
+ * The Storyboard describes pedagogy, not geometry. It carries no canvas size,
+ * no colours, no coordinates — those are decisions `emit` makes per format, so
+ * one storyboard can render as a 16:9 deck and a 9:16 short without replanning.
+ */
+import { z } from "zod";
+/** A pointer back into the Source. Provenance is what makes a beat checkable. */
+export declare const refSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        figure: "figure";
+        equation: "equation";
+        table: "table";
+        section: "section";
+    }>;
+    id: z.ZodString;
+}, z.core.$strip>;
+export declare const figureSchema: z.ZodObject<{
+    id: z.ZodString;
+    src: z.ZodString;
+    caption: z.ZodString;
+    width: z.ZodInt;
+    height: z.ZodInt;
+}, z.core.$strip>;
+export declare const equationSchema: z.ZodObject<{
+    id: z.ZodString;
+    tex: z.ZodString;
+    display: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const tableSchema: z.ZodObject<{
+    id: z.ZodString;
+    caption: z.ZodOptional<z.ZodString>;
+    columns: z.ZodArray<z.ZodString>;
+    rows: z.ZodArray<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const sectionSchema: z.ZodObject<{
+    id: z.ZodString;
+    depth: z.ZodInt;
+    heading: z.ZodString;
+    text: z.ZodString;
+}, z.core.$strip>;
+export declare const sourceSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    lang: z.ZodDefault<z.ZodString>;
+    sections: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        depth: z.ZodInt;
+        heading: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strip>>;
+    figures: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        src: z.ZodString;
+        caption: z.ZodString;
+        width: z.ZodInt;
+        height: z.ZodInt;
+    }, z.core.$strip>>;
+    equations: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        tex: z.ZodString;
+        display: z.ZodBoolean;
+    }, z.core.$strip>>;
+    tables: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        caption: z.ZodOptional<z.ZodString>;
+        columns: z.ZodArray<z.ZodString>;
+        rows: z.ZodArray<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * The explanatory vocabulary. Each archetype is one way of making a point, and
+ * maps to exactly one emitter. Adding a domain means adding archetypes here and
+ * an emitter beside it — nothing else in the pipeline learns about the domain.
+ *
+ * These six came out of hand-building a real deck (EXPERIMENT-002), not from
+ * guessing at what might be useful.
+ */
+/** One symbol in an equation, highlighted while it is explained. */
+export declare const termSchema: z.ZodObject<{
+    tex: z.ZodString;
+    label: z.ZodString;
+    tone: z.ZodEnum<{
+        a: "a";
+        b: "b";
+        c: "c";
+        d: "d";
+    }>;
+}, z.core.$strip>;
+export declare const titleParamsSchema: z.ZodObject<{
+    eyebrow: z.ZodOptional<z.ZodString>;
+    headline: z.ZodString;
+    sub: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const claimFigureParamsSchema: z.ZodObject<{
+    eyebrow: z.ZodOptional<z.ZodString>;
+    headline: z.ZodString;
+    claim: z.ZodString;
+    figureId: z.ZodString;
+}, z.core.$strip>;
+export declare const equationWalkParamsSchema: z.ZodObject<{
+    eyebrow: z.ZodOptional<z.ZodString>;
+    headline: z.ZodString;
+    equationId: z.ZodString;
+    terms: z.ZodArray<z.ZodObject<{
+        tex: z.ZodString;
+        label: z.ZodString;
+        tone: z.ZodEnum<{
+            a: "a";
+            b: "b";
+            c: "c";
+            d: "d";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const dataTableParamsSchema: z.ZodObject<{
+    eyebrow: z.ZodOptional<z.ZodString>;
+    headline: z.ZodString;
+    tableId: z.ZodString;
+    highlight: z.ZodArray<z.ZodObject<{
+        row: z.ZodString;
+        tone: z.ZodEnum<{
+            a: "a";
+            b: "b";
+            c: "c";
+            d: "d";
+        }>;
+    }, z.core.$strip>>;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const lineChartParamsSchema: z.ZodObject<{
+    eyebrow: z.ZodOptional<z.ZodString>;
+    headline: z.ZodString;
+    xLabel: z.ZodString;
+    yLabel: z.ZodString;
+    points: z.ZodArray<z.ZodObject<{
+        x: z.ZodString;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+    deltas: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    readout: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const calloutParamsSchema: z.ZodObject<{
+    eyebrow: z.ZodOptional<z.ZodString>;
+    headline: z.ZodString;
+    panels: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        lines: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** A labelled stage in a flow. */
+export declare const stageSchema: z.ZodObject<{
+    label: z.ZodString;
+    note: z.ZodOptional<z.ZodString>;
+    tone: z.ZodOptional<z.ZodEnum<{
+        a: "a";
+        b: "b";
+        c: "c";
+        d: "d";
+    }>>;
+}, z.core.$strip>;
+export declare const pipelineParamsSchema: z.ZodObject<{
+    eyebrow: z.ZodOptional<z.ZodString>;
+    headline: z.ZodString;
+    stages: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        note: z.ZodOptional<z.ZodString>;
+        tone: z.ZodOptional<z.ZodEnum<{
+            a: "a";
+            b: "b";
+            c: "c";
+            d: "d";
+        }>>;
+    }, z.core.$strip>>;
+    loop: z.ZodOptional<z.ZodObject<{
+        from: z.ZodOptional<z.ZodInt>;
+        to: z.ZodInt;
+        label: z.ZodString;
+    }, z.core.$strip>>;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const annotatedFigureParamsSchema: z.ZodObject<{
+    eyebrow: z.ZodOptional<z.ZodString>;
+    headline: z.ZodString;
+    figureId: z.ZodString;
+    crop: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        w: z.ZodNumber;
+        h: z.ZodNumber;
+    }, z.core.$strip>>;
+    notes: z.ZodArray<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        text: z.ZodString;
+        tone: z.ZodOptional<z.ZodEnum<{
+            a: "a";
+            b: "b";
+            c: "c";
+            d: "d";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const gridParamsSchema: z.ZodObject<{
+    eyebrow: z.ZodOptional<z.ZodString>;
+    headline: z.ZodString;
+    cols: z.ZodInt;
+    rows: z.ZodInt;
+    regions: z.ZodArray<z.ZodObject<{
+        x: z.ZodInt;
+        y: z.ZodInt;
+        w: z.ZodInt;
+        h: z.ZodInt;
+        label: z.ZodString;
+        tone: z.ZodEnum<{
+            a: "a";
+            b: "b";
+            c: "c";
+            d: "d";
+        }>;
+    }, z.core.$strip>>;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const barCompareParamsSchema: z.ZodObject<{
+    eyebrow: z.ZodOptional<z.ZodString>;
+    headline: z.ZodString;
+    unit: z.ZodOptional<z.ZodString>;
+    bars: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodNumber;
+        tone: z.ZodOptional<z.ZodEnum<{
+            a: "a";
+            b: "b";
+            c: "c";
+            d: "d";
+        }>>;
+    }, z.core.$strip>>;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const stackParamsSchema: z.ZodObject<{
+    eyebrow: z.ZodOptional<z.ZodString>;
+    headline: z.ZodString;
+    layers: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        note: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const splitCompareParamsSchema: z.ZodObject<{
+    eyebrow: z.ZodOptional<z.ZodString>;
+    headline: z.ZodString;
+    left: z.ZodObject<{
+        label: z.ZodString;
+        figureId: z.ZodOptional<z.ZodString>;
+        lines: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    right: z.ZodObject<{
+        label: z.ZodString;
+        figureId: z.ZodOptional<z.ZodString>;
+        lines: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * "This beat happens inside that part of the beat before it."
+ *
+ * The one field the canvas investigation endorsed, and the only one. A camera
+ * move between two beats reads as continuity — rather than as a fancier cut —
+ * exactly when the source supplies a containment or adjacency relation between
+ * them; the camera renders a relation, it never creates one. Counted honestly
+ * over the twelve-beat demo, two or three of eleven transitions have one, which
+ * is why this is optional and off by default rather than an infinite canvas.
+ *
+ * `element` names a part of the containing beat's own drawing, by the suffix
+ * `src/emit/svg.ts`'s `id(sid, part, i)` gives it: a pipeline's third stage is
+ * `stage2`, a grid's first region is `rgn0`. The shell resolves it against the
+ * containing scene and refuses to emit a camera at a part that beat did not
+ * draw, so a wrong name is a build error rather than a camera that lands on
+ * nothing.
+ */
+export declare const insideSchema: z.ZodObject<{
+    beat: z.ZodString;
+    element: z.ZodString;
+}, z.core.$strip>;
+export declare const beatSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    narration: z.ZodOptional<z.ZodString>;
+    archetype: z.ZodLiteral<"title">;
+    params: z.ZodObject<{
+        eyebrow: z.ZodOptional<z.ZodString>;
+        headline: z.ZodString;
+        sub: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    intent: z.ZodString;
+    inside: z.ZodOptional<z.ZodObject<{
+        beat: z.ZodString;
+        element: z.ZodString;
+    }, z.core.$strip>>;
+    claim: z.ZodOptional<z.ZodString>;
+    evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            figure: "figure";
+            equation: "equation";
+            table: "table";
+            section: "section";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strip>>>;
+    weight: z.ZodDefault<z.ZodNumber>;
+    seconds: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    narration: z.ZodOptional<z.ZodString>;
+    archetype: z.ZodLiteral<"claim-figure">;
+    params: z.ZodObject<{
+        eyebrow: z.ZodOptional<z.ZodString>;
+        headline: z.ZodString;
+        claim: z.ZodString;
+        figureId: z.ZodString;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    intent: z.ZodString;
+    inside: z.ZodOptional<z.ZodObject<{
+        beat: z.ZodString;
+        element: z.ZodString;
+    }, z.core.$strip>>;
+    claim: z.ZodOptional<z.ZodString>;
+    evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            figure: "figure";
+            equation: "equation";
+            table: "table";
+            section: "section";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strip>>>;
+    weight: z.ZodDefault<z.ZodNumber>;
+    seconds: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    narration: z.ZodOptional<z.ZodString>;
+    archetype: z.ZodLiteral<"equation-walk">;
+    params: z.ZodObject<{
+        eyebrow: z.ZodOptional<z.ZodString>;
+        headline: z.ZodString;
+        equationId: z.ZodString;
+        terms: z.ZodArray<z.ZodObject<{
+            tex: z.ZodString;
+            label: z.ZodString;
+            tone: z.ZodEnum<{
+                a: "a";
+                b: "b";
+                c: "c";
+                d: "d";
+            }>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    intent: z.ZodString;
+    inside: z.ZodOptional<z.ZodObject<{
+        beat: z.ZodString;
+        element: z.ZodString;
+    }, z.core.$strip>>;
+    claim: z.ZodOptional<z.ZodString>;
+    evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            figure: "figure";
+            equation: "equation";
+            table: "table";
+            section: "section";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strip>>>;
+    weight: z.ZodDefault<z.ZodNumber>;
+    seconds: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    narration: z.ZodOptional<z.ZodString>;
+    archetype: z.ZodLiteral<"data-table">;
+    params: z.ZodObject<{
+        eyebrow: z.ZodOptional<z.ZodString>;
+        headline: z.ZodString;
+        tableId: z.ZodString;
+        highlight: z.ZodArray<z.ZodObject<{
+            row: z.ZodString;
+            tone: z.ZodEnum<{
+                a: "a";
+                b: "b";
+                c: "c";
+                d: "d";
+            }>;
+        }, z.core.$strip>>;
+        note: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    intent: z.ZodString;
+    inside: z.ZodOptional<z.ZodObject<{
+        beat: z.ZodString;
+        element: z.ZodString;
+    }, z.core.$strip>>;
+    claim: z.ZodOptional<z.ZodString>;
+    evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            figure: "figure";
+            equation: "equation";
+            table: "table";
+            section: "section";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strip>>>;
+    weight: z.ZodDefault<z.ZodNumber>;
+    seconds: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    narration: z.ZodOptional<z.ZodString>;
+    archetype: z.ZodLiteral<"line-chart">;
+    params: z.ZodObject<{
+        eyebrow: z.ZodOptional<z.ZodString>;
+        headline: z.ZodString;
+        xLabel: z.ZodString;
+        yLabel: z.ZodString;
+        points: z.ZodArray<z.ZodObject<{
+            x: z.ZodString;
+            y: z.ZodNumber;
+        }, z.core.$strip>>;
+        deltas: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        readout: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    intent: z.ZodString;
+    inside: z.ZodOptional<z.ZodObject<{
+        beat: z.ZodString;
+        element: z.ZodString;
+    }, z.core.$strip>>;
+    claim: z.ZodOptional<z.ZodString>;
+    evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            figure: "figure";
+            equation: "equation";
+            table: "table";
+            section: "section";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strip>>>;
+    weight: z.ZodDefault<z.ZodNumber>;
+    seconds: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    narration: z.ZodOptional<z.ZodString>;
+    archetype: z.ZodLiteral<"callout">;
+    params: z.ZodObject<{
+        eyebrow: z.ZodOptional<z.ZodString>;
+        headline: z.ZodString;
+        panels: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            lines: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        note: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    intent: z.ZodString;
+    inside: z.ZodOptional<z.ZodObject<{
+        beat: z.ZodString;
+        element: z.ZodString;
+    }, z.core.$strip>>;
+    claim: z.ZodOptional<z.ZodString>;
+    evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            figure: "figure";
+            equation: "equation";
+            table: "table";
+            section: "section";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strip>>>;
+    weight: z.ZodDefault<z.ZodNumber>;
+    seconds: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    narration: z.ZodOptional<z.ZodString>;
+    archetype: z.ZodLiteral<"pipeline">;
+    params: z.ZodObject<{
+        eyebrow: z.ZodOptional<z.ZodString>;
+        headline: z.ZodString;
+        stages: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            note: z.ZodOptional<z.ZodString>;
+            tone: z.ZodOptional<z.ZodEnum<{
+                a: "a";
+                b: "b";
+                c: "c";
+                d: "d";
+            }>>;
+        }, z.core.$strip>>;
+        loop: z.ZodOptional<z.ZodObject<{
+            from: z.ZodOptional<z.ZodInt>;
+            to: z.ZodInt;
+            label: z.ZodString;
+        }, z.core.$strip>>;
+        note: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    intent: z.ZodString;
+    inside: z.ZodOptional<z.ZodObject<{
+        beat: z.ZodString;
+        element: z.ZodString;
+    }, z.core.$strip>>;
+    claim: z.ZodOptional<z.ZodString>;
+    evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            figure: "figure";
+            equation: "equation";
+            table: "table";
+            section: "section";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strip>>>;
+    weight: z.ZodDefault<z.ZodNumber>;
+    seconds: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    narration: z.ZodOptional<z.ZodString>;
+    archetype: z.ZodLiteral<"annotated-figure">;
+    params: z.ZodObject<{
+        eyebrow: z.ZodOptional<z.ZodString>;
+        headline: z.ZodString;
+        figureId: z.ZodString;
+        crop: z.ZodOptional<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            w: z.ZodNumber;
+            h: z.ZodNumber;
+        }, z.core.$strip>>;
+        notes: z.ZodArray<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            text: z.ZodString;
+            tone: z.ZodOptional<z.ZodEnum<{
+                a: "a";
+                b: "b";
+                c: "c";
+                d: "d";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    intent: z.ZodString;
+    inside: z.ZodOptional<z.ZodObject<{
+        beat: z.ZodString;
+        element: z.ZodString;
+    }, z.core.$strip>>;
+    claim: z.ZodOptional<z.ZodString>;
+    evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            figure: "figure";
+            equation: "equation";
+            table: "table";
+            section: "section";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strip>>>;
+    weight: z.ZodDefault<z.ZodNumber>;
+    seconds: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    narration: z.ZodOptional<z.ZodString>;
+    archetype: z.ZodLiteral<"grid">;
+    params: z.ZodObject<{
+        eyebrow: z.ZodOptional<z.ZodString>;
+        headline: z.ZodString;
+        cols: z.ZodInt;
+        rows: z.ZodInt;
+        regions: z.ZodArray<z.ZodObject<{
+            x: z.ZodInt;
+            y: z.ZodInt;
+            w: z.ZodInt;
+            h: z.ZodInt;
+            label: z.ZodString;
+            tone: z.ZodEnum<{
+                a: "a";
+                b: "b";
+                c: "c";
+                d: "d";
+            }>;
+        }, z.core.$strip>>;
+        note: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    intent: z.ZodString;
+    inside: z.ZodOptional<z.ZodObject<{
+        beat: z.ZodString;
+        element: z.ZodString;
+    }, z.core.$strip>>;
+    claim: z.ZodOptional<z.ZodString>;
+    evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            figure: "figure";
+            equation: "equation";
+            table: "table";
+            section: "section";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strip>>>;
+    weight: z.ZodDefault<z.ZodNumber>;
+    seconds: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    narration: z.ZodOptional<z.ZodString>;
+    archetype: z.ZodLiteral<"bar-compare">;
+    params: z.ZodObject<{
+        eyebrow: z.ZodOptional<z.ZodString>;
+        headline: z.ZodString;
+        unit: z.ZodOptional<z.ZodString>;
+        bars: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodNumber;
+            tone: z.ZodOptional<z.ZodEnum<{
+                a: "a";
+                b: "b";
+                c: "c";
+                d: "d";
+            }>>;
+        }, z.core.$strip>>;
+        note: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    intent: z.ZodString;
+    inside: z.ZodOptional<z.ZodObject<{
+        beat: z.ZodString;
+        element: z.ZodString;
+    }, z.core.$strip>>;
+    claim: z.ZodOptional<z.ZodString>;
+    evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            figure: "figure";
+            equation: "equation";
+            table: "table";
+            section: "section";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strip>>>;
+    weight: z.ZodDefault<z.ZodNumber>;
+    seconds: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    narration: z.ZodOptional<z.ZodString>;
+    archetype: z.ZodLiteral<"stack">;
+    params: z.ZodObject<{
+        eyebrow: z.ZodOptional<z.ZodString>;
+        headline: z.ZodString;
+        layers: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        note: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    intent: z.ZodString;
+    inside: z.ZodOptional<z.ZodObject<{
+        beat: z.ZodString;
+        element: z.ZodString;
+    }, z.core.$strip>>;
+    claim: z.ZodOptional<z.ZodString>;
+    evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            figure: "figure";
+            equation: "equation";
+            table: "table";
+            section: "section";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strip>>>;
+    weight: z.ZodDefault<z.ZodNumber>;
+    seconds: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    narration: z.ZodOptional<z.ZodString>;
+    archetype: z.ZodLiteral<"split-compare">;
+    params: z.ZodObject<{
+        eyebrow: z.ZodOptional<z.ZodString>;
+        headline: z.ZodString;
+        left: z.ZodObject<{
+            label: z.ZodString;
+            figureId: z.ZodOptional<z.ZodString>;
+            lines: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+        right: z.ZodObject<{
+            label: z.ZodString;
+            figureId: z.ZodOptional<z.ZodString>;
+            lines: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+        note: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    intent: z.ZodString;
+    inside: z.ZodOptional<z.ZodObject<{
+        beat: z.ZodString;
+        element: z.ZodString;
+    }, z.core.$strip>>;
+    claim: z.ZodOptional<z.ZodString>;
+    evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            figure: "figure";
+            equation: "equation";
+            table: "table";
+            section: "section";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strip>>>;
+    weight: z.ZodDefault<z.ZodNumber>;
+    seconds: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>], "archetype">;
+/**
+ * Archetypes that draw rather than describe. `verify` warns when a deck leans on
+ * the others — a deck of headlines and bullet panels is the thing every slide
+ * generator already makes, and is not what this tool is for.
+ */
+export declare const DIAGRAMMATIC: ReadonlySet<string>;
+/**
+ * The four things a beat can BE, as opposed to the twelve ways it can be drawn.
+ *
+ * Used by src/plan/select.ts to keep a shortened cut recognisable as the same
+ * argument. Coverage has to be checked at this grain and not per-archetype: the
+ * demo's twelve beats have twelve distinct archetypes, so "keep one of each
+ * archetype" protects the entire deck and cuts nothing, while "keep one of each
+ * family" is a rule that can actually bind.
+ *
+ * - `frame` states or bounds a claim: the title, the assertion over a figure,
+ *   the caveat at the end. What the deck SAYS.
+ * - `structure` shows how something is put together or how two things differ.
+ * - `quantity` shows numbers: bars, a curve, a table. The EVIDENCE — and
+ *   `frame` outnumbers it in most decks, which is why a cut that optimises on
+ *   weight alone reliably ends up all claim and no proof.
+ * - `formal` walks an equation.
+ *
+ * `claim-figure` sits in `frame`, not `quantity`, even though a figure is on
+ * screen: the beat's work is the assertion, and the figure is its illustration.
+ */
+export type ArchetypeFamily = "frame" | "structure" | "quantity" | "formal";
+export declare const ARCHETYPE_FAMILY: Readonly<Record<Archetype, ArchetypeFamily>>;
+export declare const storyboardSchema: z.ZodObject<{
+    sourceId: z.ZodString;
+    title: z.ZodString;
+    lang: z.ZodDefault<z.ZodString>;
+    theme: z.ZodDefault<z.ZodString>;
+    beats: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        narration: z.ZodOptional<z.ZodString>;
+        archetype: z.ZodLiteral<"title">;
+        params: z.ZodObject<{
+            eyebrow: z.ZodOptional<z.ZodString>;
+            headline: z.ZodString;
+            sub: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        id: z.ZodString;
+        intent: z.ZodString;
+        inside: z.ZodOptional<z.ZodObject<{
+            beat: z.ZodString;
+            element: z.ZodString;
+        }, z.core.$strip>>;
+        claim: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                figure: "figure";
+                equation: "equation";
+                table: "table";
+                section: "section";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>>>;
+        weight: z.ZodDefault<z.ZodNumber>;
+        seconds: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        narration: z.ZodOptional<z.ZodString>;
+        archetype: z.ZodLiteral<"claim-figure">;
+        params: z.ZodObject<{
+            eyebrow: z.ZodOptional<z.ZodString>;
+            headline: z.ZodString;
+            claim: z.ZodString;
+            figureId: z.ZodString;
+        }, z.core.$strip>;
+        id: z.ZodString;
+        intent: z.ZodString;
+        inside: z.ZodOptional<z.ZodObject<{
+            beat: z.ZodString;
+            element: z.ZodString;
+        }, z.core.$strip>>;
+        claim: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                figure: "figure";
+                equation: "equation";
+                table: "table";
+                section: "section";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>>>;
+        weight: z.ZodDefault<z.ZodNumber>;
+        seconds: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        narration: z.ZodOptional<z.ZodString>;
+        archetype: z.ZodLiteral<"equation-walk">;
+        params: z.ZodObject<{
+            eyebrow: z.ZodOptional<z.ZodString>;
+            headline: z.ZodString;
+            equationId: z.ZodString;
+            terms: z.ZodArray<z.ZodObject<{
+                tex: z.ZodString;
+                label: z.ZodString;
+                tone: z.ZodEnum<{
+                    a: "a";
+                    b: "b";
+                    c: "c";
+                    d: "d";
+                }>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        id: z.ZodString;
+        intent: z.ZodString;
+        inside: z.ZodOptional<z.ZodObject<{
+            beat: z.ZodString;
+            element: z.ZodString;
+        }, z.core.$strip>>;
+        claim: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                figure: "figure";
+                equation: "equation";
+                table: "table";
+                section: "section";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>>>;
+        weight: z.ZodDefault<z.ZodNumber>;
+        seconds: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        narration: z.ZodOptional<z.ZodString>;
+        archetype: z.ZodLiteral<"data-table">;
+        params: z.ZodObject<{
+            eyebrow: z.ZodOptional<z.ZodString>;
+            headline: z.ZodString;
+            tableId: z.ZodString;
+            highlight: z.ZodArray<z.ZodObject<{
+                row: z.ZodString;
+                tone: z.ZodEnum<{
+                    a: "a";
+                    b: "b";
+                    c: "c";
+                    d: "d";
+                }>;
+            }, z.core.$strip>>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        id: z.ZodString;
+        intent: z.ZodString;
+        inside: z.ZodOptional<z.ZodObject<{
+            beat: z.ZodString;
+            element: z.ZodString;
+        }, z.core.$strip>>;
+        claim: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                figure: "figure";
+                equation: "equation";
+                table: "table";
+                section: "section";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>>>;
+        weight: z.ZodDefault<z.ZodNumber>;
+        seconds: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        narration: z.ZodOptional<z.ZodString>;
+        archetype: z.ZodLiteral<"line-chart">;
+        params: z.ZodObject<{
+            eyebrow: z.ZodOptional<z.ZodString>;
+            headline: z.ZodString;
+            xLabel: z.ZodString;
+            yLabel: z.ZodString;
+            points: z.ZodArray<z.ZodObject<{
+                x: z.ZodString;
+                y: z.ZodNumber;
+            }, z.core.$strip>>;
+            deltas: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            readout: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        id: z.ZodString;
+        intent: z.ZodString;
+        inside: z.ZodOptional<z.ZodObject<{
+            beat: z.ZodString;
+            element: z.ZodString;
+        }, z.core.$strip>>;
+        claim: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                figure: "figure";
+                equation: "equation";
+                table: "table";
+                section: "section";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>>>;
+        weight: z.ZodDefault<z.ZodNumber>;
+        seconds: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        narration: z.ZodOptional<z.ZodString>;
+        archetype: z.ZodLiteral<"callout">;
+        params: z.ZodObject<{
+            eyebrow: z.ZodOptional<z.ZodString>;
+            headline: z.ZodString;
+            panels: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                lines: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        id: z.ZodString;
+        intent: z.ZodString;
+        inside: z.ZodOptional<z.ZodObject<{
+            beat: z.ZodString;
+            element: z.ZodString;
+        }, z.core.$strip>>;
+        claim: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                figure: "figure";
+                equation: "equation";
+                table: "table";
+                section: "section";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>>>;
+        weight: z.ZodDefault<z.ZodNumber>;
+        seconds: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        narration: z.ZodOptional<z.ZodString>;
+        archetype: z.ZodLiteral<"pipeline">;
+        params: z.ZodObject<{
+            eyebrow: z.ZodOptional<z.ZodString>;
+            headline: z.ZodString;
+            stages: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                note: z.ZodOptional<z.ZodString>;
+                tone: z.ZodOptional<z.ZodEnum<{
+                    a: "a";
+                    b: "b";
+                    c: "c";
+                    d: "d";
+                }>>;
+            }, z.core.$strip>>;
+            loop: z.ZodOptional<z.ZodObject<{
+                from: z.ZodOptional<z.ZodInt>;
+                to: z.ZodInt;
+                label: z.ZodString;
+            }, z.core.$strip>>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        id: z.ZodString;
+        intent: z.ZodString;
+        inside: z.ZodOptional<z.ZodObject<{
+            beat: z.ZodString;
+            element: z.ZodString;
+        }, z.core.$strip>>;
+        claim: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                figure: "figure";
+                equation: "equation";
+                table: "table";
+                section: "section";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>>>;
+        weight: z.ZodDefault<z.ZodNumber>;
+        seconds: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        narration: z.ZodOptional<z.ZodString>;
+        archetype: z.ZodLiteral<"annotated-figure">;
+        params: z.ZodObject<{
+            eyebrow: z.ZodOptional<z.ZodString>;
+            headline: z.ZodString;
+            figureId: z.ZodString;
+            crop: z.ZodOptional<z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                w: z.ZodNumber;
+                h: z.ZodNumber;
+            }, z.core.$strip>>;
+            notes: z.ZodArray<z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                text: z.ZodString;
+                tone: z.ZodOptional<z.ZodEnum<{
+                    a: "a";
+                    b: "b";
+                    c: "c";
+                    d: "d";
+                }>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        id: z.ZodString;
+        intent: z.ZodString;
+        inside: z.ZodOptional<z.ZodObject<{
+            beat: z.ZodString;
+            element: z.ZodString;
+        }, z.core.$strip>>;
+        claim: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                figure: "figure";
+                equation: "equation";
+                table: "table";
+                section: "section";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>>>;
+        weight: z.ZodDefault<z.ZodNumber>;
+        seconds: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        narration: z.ZodOptional<z.ZodString>;
+        archetype: z.ZodLiteral<"grid">;
+        params: z.ZodObject<{
+            eyebrow: z.ZodOptional<z.ZodString>;
+            headline: z.ZodString;
+            cols: z.ZodInt;
+            rows: z.ZodInt;
+            regions: z.ZodArray<z.ZodObject<{
+                x: z.ZodInt;
+                y: z.ZodInt;
+                w: z.ZodInt;
+                h: z.ZodInt;
+                label: z.ZodString;
+                tone: z.ZodEnum<{
+                    a: "a";
+                    b: "b";
+                    c: "c";
+                    d: "d";
+                }>;
+            }, z.core.$strip>>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        id: z.ZodString;
+        intent: z.ZodString;
+        inside: z.ZodOptional<z.ZodObject<{
+            beat: z.ZodString;
+            element: z.ZodString;
+        }, z.core.$strip>>;
+        claim: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                figure: "figure";
+                equation: "equation";
+                table: "table";
+                section: "section";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>>>;
+        weight: z.ZodDefault<z.ZodNumber>;
+        seconds: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        narration: z.ZodOptional<z.ZodString>;
+        archetype: z.ZodLiteral<"bar-compare">;
+        params: z.ZodObject<{
+            eyebrow: z.ZodOptional<z.ZodString>;
+            headline: z.ZodString;
+            unit: z.ZodOptional<z.ZodString>;
+            bars: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                value: z.ZodNumber;
+                tone: z.ZodOptional<z.ZodEnum<{
+                    a: "a";
+                    b: "b";
+                    c: "c";
+                    d: "d";
+                }>>;
+            }, z.core.$strip>>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        id: z.ZodString;
+        intent: z.ZodString;
+        inside: z.ZodOptional<z.ZodObject<{
+            beat: z.ZodString;
+            element: z.ZodString;
+        }, z.core.$strip>>;
+        claim: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                figure: "figure";
+                equation: "equation";
+                table: "table";
+                section: "section";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>>>;
+        weight: z.ZodDefault<z.ZodNumber>;
+        seconds: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        narration: z.ZodOptional<z.ZodString>;
+        archetype: z.ZodLiteral<"stack">;
+        params: z.ZodObject<{
+            eyebrow: z.ZodOptional<z.ZodString>;
+            headline: z.ZodString;
+            layers: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                note: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        id: z.ZodString;
+        intent: z.ZodString;
+        inside: z.ZodOptional<z.ZodObject<{
+            beat: z.ZodString;
+            element: z.ZodString;
+        }, z.core.$strip>>;
+        claim: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                figure: "figure";
+                equation: "equation";
+                table: "table";
+                section: "section";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>>>;
+        weight: z.ZodDefault<z.ZodNumber>;
+        seconds: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        narration: z.ZodOptional<z.ZodString>;
+        archetype: z.ZodLiteral<"split-compare">;
+        params: z.ZodObject<{
+            eyebrow: z.ZodOptional<z.ZodString>;
+            headline: z.ZodString;
+            left: z.ZodObject<{
+                label: z.ZodString;
+                figureId: z.ZodOptional<z.ZodString>;
+                lines: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>;
+            right: z.ZodObject<{
+                label: z.ZodString;
+                figureId: z.ZodOptional<z.ZodString>;
+                lines: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        id: z.ZodString;
+        intent: z.ZodString;
+        inside: z.ZodOptional<z.ZodObject<{
+            beat: z.ZodString;
+            element: z.ZodString;
+        }, z.core.$strip>>;
+        claim: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                figure: "figure";
+                equation: "equation";
+                table: "table";
+                section: "section";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>>>;
+        weight: z.ZodDefault<z.ZodNumber>;
+        seconds: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>], "archetype">>;
+}, z.core.$strip>;
+/**
+ * What the person asking for the deck gets to decide.
+ *
+ * Split deliberately: `plan` reads the ones that change what is said, `emit`
+ * reads the ones that change how it looks. Neither reaches for a field it does
+ * not own, which is why a preferences change never invalidates a storyboard.
+ */
+export declare const prefsSchema: z.ZodObject<{
+    slides: z.ZodDefault<z.ZodInt>;
+    lang: z.ZodDefault<z.ZodString>;
+    tone: z.ZodDefault<z.ZodEnum<{
+        plain: "plain";
+        academic: "academic";
+        conversational: "conversational";
+        punchy: "punchy";
+    }>>;
+    density: z.ZodDefault<z.ZodEnum<{
+        sparse: "sparse";
+        normal: "normal";
+        dense: "dense";
+    }>>;
+    duration: z.ZodOptional<z.ZodNumber>;
+    theme: z.ZodDefault<z.ZodString>;
+    animationSpeed: z.ZodDefault<z.ZodNumber>;
+    narration: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        voice: z.ZodOptional<z.ZodString>;
+        rate: z.ZodDefault<z.ZodString>;
+        pitch: z.ZodDefault<z.ZodString>;
+        subtitles: z.ZodDefault<z.ZodBoolean>;
+        density: z.ZodDefault<z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** One subtitle line with the timing edge-tts measured for it. */
+export declare const cueSchema: z.ZodObject<{
+    start: z.ZodNumber;
+    end: z.ZodNumber;
+    text: z.ZodString;
+}, z.core.$strip>;
+/**
+ * What is spoken at one stop.
+ *
+ * One segment per stop, so the audio and the reveal advance together: the
+ * presenter says the sentence that belongs to the thing that just appeared.
+ * `seconds` is measured from the rendered audio, never estimated — it is what
+ * lets a beat's length follow its narration instead of a number someone guessed.
+ */
+export declare const segmentSchema: z.ZodObject<{
+    stop: z.ZodInt;
+    text: z.ZodString;
+    audio: z.ZodString;
+    seconds: z.ZodNumber;
+    cues: z.ZodArray<z.ZodObject<{
+        start: z.ZodNumber;
+        end: z.ZodNumber;
+        text: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const narrationSchema: z.ZodObject<{
+    voice: z.ZodString;
+    beats: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+        stop: z.ZodInt;
+        text: z.ZodString;
+        audio: z.ZodString;
+        seconds: z.ZodNumber;
+        cues: z.ZodArray<z.ZodObject<{
+            start: z.ZodNumber;
+            end: z.ZodNumber;
+            text: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/**
+ * How one external asset travels with the deck.
+ *
+ * `bake` copies the bytes in, so the pack works offline and forever. `link`
+ * keeps the URL, so the pack stays small and the asset stays current. `embed` is
+ * for things that are not files at all — a YouTube or Vimeo URL is a player, and
+ * downloading it would be both wrong and, usually, against its terms.
+ */
+export declare const mediaSchema: z.ZodObject<{
+    id: z.ZodString;
+    policy: z.ZodEnum<{
+        bake: "bake";
+        link: "link";
+        embed: "embed";
+    }>;
+    path: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    mime: z.ZodOptional<z.ZodString>;
+    bytes: z.ZodOptional<z.ZodInt>;
+}, z.core.$strip>;
+/** Bumped only when an older reader could misread a newer pack. */
+export declare const PACK_VERSION = 1;
+/**
+ * `deck.json` inside a `.deck` archive: everything needed to rebuild the deck,
+ * and nothing that can be derived from it.
+ *
+ * A pack is the unit a user keeps, sends, and re-opens. It carries the source
+ * and the storyboard rather than the built HTML, because the built HTML is a
+ * projection of those two and every format profile makes a different one.
+ */
+export declare const packSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    createdAt: z.ZodString;
+    title: z.ZodString;
+    prefs: z.ZodObject<{
+        slides: z.ZodDefault<z.ZodInt>;
+        lang: z.ZodDefault<z.ZodString>;
+        tone: z.ZodDefault<z.ZodEnum<{
+            plain: "plain";
+            academic: "academic";
+            conversational: "conversational";
+            punchy: "punchy";
+        }>>;
+        density: z.ZodDefault<z.ZodEnum<{
+            sparse: "sparse";
+            normal: "normal";
+            dense: "dense";
+        }>>;
+        duration: z.ZodOptional<z.ZodNumber>;
+        theme: z.ZodDefault<z.ZodString>;
+        animationSpeed: z.ZodDefault<z.ZodNumber>;
+        narration: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            voice: z.ZodOptional<z.ZodString>;
+            rate: z.ZodDefault<z.ZodString>;
+            pitch: z.ZodDefault<z.ZodString>;
+            subtitles: z.ZodDefault<z.ZodBoolean>;
+            density: z.ZodDefault<z.ZodEnum<{
+                high: "high";
+                medium: "medium";
+                low: "low";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    source: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        lang: z.ZodDefault<z.ZodString>;
+        sections: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            depth: z.ZodInt;
+            heading: z.ZodString;
+            text: z.ZodString;
+        }, z.core.$strip>>;
+        figures: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            src: z.ZodString;
+            caption: z.ZodString;
+            width: z.ZodInt;
+            height: z.ZodInt;
+        }, z.core.$strip>>;
+        equations: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            tex: z.ZodString;
+            display: z.ZodBoolean;
+        }, z.core.$strip>>;
+        tables: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            caption: z.ZodOptional<z.ZodString>;
+            columns: z.ZodArray<z.ZodString>;
+            rows: z.ZodArray<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    storyboard: z.ZodObject<{
+        sourceId: z.ZodString;
+        title: z.ZodString;
+        lang: z.ZodDefault<z.ZodString>;
+        theme: z.ZodDefault<z.ZodString>;
+        beats: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            narration: z.ZodOptional<z.ZodString>;
+            archetype: z.ZodLiteral<"title">;
+            params: z.ZodObject<{
+                eyebrow: z.ZodOptional<z.ZodString>;
+                headline: z.ZodString;
+                sub: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            id: z.ZodString;
+            intent: z.ZodString;
+            inside: z.ZodOptional<z.ZodObject<{
+                beat: z.ZodString;
+                element: z.ZodString;
+            }, z.core.$strip>>;
+            claim: z.ZodOptional<z.ZodString>;
+            evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    figure: "figure";
+                    equation: "equation";
+                    table: "table";
+                    section: "section";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strip>>>;
+            weight: z.ZodDefault<z.ZodNumber>;
+            seconds: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            narration: z.ZodOptional<z.ZodString>;
+            archetype: z.ZodLiteral<"claim-figure">;
+            params: z.ZodObject<{
+                eyebrow: z.ZodOptional<z.ZodString>;
+                headline: z.ZodString;
+                claim: z.ZodString;
+                figureId: z.ZodString;
+            }, z.core.$strip>;
+            id: z.ZodString;
+            intent: z.ZodString;
+            inside: z.ZodOptional<z.ZodObject<{
+                beat: z.ZodString;
+                element: z.ZodString;
+            }, z.core.$strip>>;
+            claim: z.ZodOptional<z.ZodString>;
+            evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    figure: "figure";
+                    equation: "equation";
+                    table: "table";
+                    section: "section";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strip>>>;
+            weight: z.ZodDefault<z.ZodNumber>;
+            seconds: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            narration: z.ZodOptional<z.ZodString>;
+            archetype: z.ZodLiteral<"equation-walk">;
+            params: z.ZodObject<{
+                eyebrow: z.ZodOptional<z.ZodString>;
+                headline: z.ZodString;
+                equationId: z.ZodString;
+                terms: z.ZodArray<z.ZodObject<{
+                    tex: z.ZodString;
+                    label: z.ZodString;
+                    tone: z.ZodEnum<{
+                        a: "a";
+                        b: "b";
+                        c: "c";
+                        d: "d";
+                    }>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            id: z.ZodString;
+            intent: z.ZodString;
+            inside: z.ZodOptional<z.ZodObject<{
+                beat: z.ZodString;
+                element: z.ZodString;
+            }, z.core.$strip>>;
+            claim: z.ZodOptional<z.ZodString>;
+            evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    figure: "figure";
+                    equation: "equation";
+                    table: "table";
+                    section: "section";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strip>>>;
+            weight: z.ZodDefault<z.ZodNumber>;
+            seconds: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            narration: z.ZodOptional<z.ZodString>;
+            archetype: z.ZodLiteral<"data-table">;
+            params: z.ZodObject<{
+                eyebrow: z.ZodOptional<z.ZodString>;
+                headline: z.ZodString;
+                tableId: z.ZodString;
+                highlight: z.ZodArray<z.ZodObject<{
+                    row: z.ZodString;
+                    tone: z.ZodEnum<{
+                        a: "a";
+                        b: "b";
+                        c: "c";
+                        d: "d";
+                    }>;
+                }, z.core.$strip>>;
+                note: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            id: z.ZodString;
+            intent: z.ZodString;
+            inside: z.ZodOptional<z.ZodObject<{
+                beat: z.ZodString;
+                element: z.ZodString;
+            }, z.core.$strip>>;
+            claim: z.ZodOptional<z.ZodString>;
+            evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    figure: "figure";
+                    equation: "equation";
+                    table: "table";
+                    section: "section";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strip>>>;
+            weight: z.ZodDefault<z.ZodNumber>;
+            seconds: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            narration: z.ZodOptional<z.ZodString>;
+            archetype: z.ZodLiteral<"line-chart">;
+            params: z.ZodObject<{
+                eyebrow: z.ZodOptional<z.ZodString>;
+                headline: z.ZodString;
+                xLabel: z.ZodString;
+                yLabel: z.ZodString;
+                points: z.ZodArray<z.ZodObject<{
+                    x: z.ZodString;
+                    y: z.ZodNumber;
+                }, z.core.$strip>>;
+                deltas: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                readout: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            id: z.ZodString;
+            intent: z.ZodString;
+            inside: z.ZodOptional<z.ZodObject<{
+                beat: z.ZodString;
+                element: z.ZodString;
+            }, z.core.$strip>>;
+            claim: z.ZodOptional<z.ZodString>;
+            evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    figure: "figure";
+                    equation: "equation";
+                    table: "table";
+                    section: "section";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strip>>>;
+            weight: z.ZodDefault<z.ZodNumber>;
+            seconds: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            narration: z.ZodOptional<z.ZodString>;
+            archetype: z.ZodLiteral<"callout">;
+            params: z.ZodObject<{
+                eyebrow: z.ZodOptional<z.ZodString>;
+                headline: z.ZodString;
+                panels: z.ZodArray<z.ZodObject<{
+                    label: z.ZodString;
+                    lines: z.ZodArray<z.ZodString>;
+                }, z.core.$strip>>;
+                note: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            id: z.ZodString;
+            intent: z.ZodString;
+            inside: z.ZodOptional<z.ZodObject<{
+                beat: z.ZodString;
+                element: z.ZodString;
+            }, z.core.$strip>>;
+            claim: z.ZodOptional<z.ZodString>;
+            evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    figure: "figure";
+                    equation: "equation";
+                    table: "table";
+                    section: "section";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strip>>>;
+            weight: z.ZodDefault<z.ZodNumber>;
+            seconds: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            narration: z.ZodOptional<z.ZodString>;
+            archetype: z.ZodLiteral<"pipeline">;
+            params: z.ZodObject<{
+                eyebrow: z.ZodOptional<z.ZodString>;
+                headline: z.ZodString;
+                stages: z.ZodArray<z.ZodObject<{
+                    label: z.ZodString;
+                    note: z.ZodOptional<z.ZodString>;
+                    tone: z.ZodOptional<z.ZodEnum<{
+                        a: "a";
+                        b: "b";
+                        c: "c";
+                        d: "d";
+                    }>>;
+                }, z.core.$strip>>;
+                loop: z.ZodOptional<z.ZodObject<{
+                    from: z.ZodOptional<z.ZodInt>;
+                    to: z.ZodInt;
+                    label: z.ZodString;
+                }, z.core.$strip>>;
+                note: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            id: z.ZodString;
+            intent: z.ZodString;
+            inside: z.ZodOptional<z.ZodObject<{
+                beat: z.ZodString;
+                element: z.ZodString;
+            }, z.core.$strip>>;
+            claim: z.ZodOptional<z.ZodString>;
+            evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    figure: "figure";
+                    equation: "equation";
+                    table: "table";
+                    section: "section";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strip>>>;
+            weight: z.ZodDefault<z.ZodNumber>;
+            seconds: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            narration: z.ZodOptional<z.ZodString>;
+            archetype: z.ZodLiteral<"annotated-figure">;
+            params: z.ZodObject<{
+                eyebrow: z.ZodOptional<z.ZodString>;
+                headline: z.ZodString;
+                figureId: z.ZodString;
+                crop: z.ZodOptional<z.ZodObject<{
+                    x: z.ZodNumber;
+                    y: z.ZodNumber;
+                    w: z.ZodNumber;
+                    h: z.ZodNumber;
+                }, z.core.$strip>>;
+                notes: z.ZodArray<z.ZodObject<{
+                    x: z.ZodNumber;
+                    y: z.ZodNumber;
+                    text: z.ZodString;
+                    tone: z.ZodOptional<z.ZodEnum<{
+                        a: "a";
+                        b: "b";
+                        c: "c";
+                        d: "d";
+                    }>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            id: z.ZodString;
+            intent: z.ZodString;
+            inside: z.ZodOptional<z.ZodObject<{
+                beat: z.ZodString;
+                element: z.ZodString;
+            }, z.core.$strip>>;
+            claim: z.ZodOptional<z.ZodString>;
+            evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    figure: "figure";
+                    equation: "equation";
+                    table: "table";
+                    section: "section";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strip>>>;
+            weight: z.ZodDefault<z.ZodNumber>;
+            seconds: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            narration: z.ZodOptional<z.ZodString>;
+            archetype: z.ZodLiteral<"grid">;
+            params: z.ZodObject<{
+                eyebrow: z.ZodOptional<z.ZodString>;
+                headline: z.ZodString;
+                cols: z.ZodInt;
+                rows: z.ZodInt;
+                regions: z.ZodArray<z.ZodObject<{
+                    x: z.ZodInt;
+                    y: z.ZodInt;
+                    w: z.ZodInt;
+                    h: z.ZodInt;
+                    label: z.ZodString;
+                    tone: z.ZodEnum<{
+                        a: "a";
+                        b: "b";
+                        c: "c";
+                        d: "d";
+                    }>;
+                }, z.core.$strip>>;
+                note: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            id: z.ZodString;
+            intent: z.ZodString;
+            inside: z.ZodOptional<z.ZodObject<{
+                beat: z.ZodString;
+                element: z.ZodString;
+            }, z.core.$strip>>;
+            claim: z.ZodOptional<z.ZodString>;
+            evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    figure: "figure";
+                    equation: "equation";
+                    table: "table";
+                    section: "section";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strip>>>;
+            weight: z.ZodDefault<z.ZodNumber>;
+            seconds: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            narration: z.ZodOptional<z.ZodString>;
+            archetype: z.ZodLiteral<"bar-compare">;
+            params: z.ZodObject<{
+                eyebrow: z.ZodOptional<z.ZodString>;
+                headline: z.ZodString;
+                unit: z.ZodOptional<z.ZodString>;
+                bars: z.ZodArray<z.ZodObject<{
+                    label: z.ZodString;
+                    value: z.ZodNumber;
+                    tone: z.ZodOptional<z.ZodEnum<{
+                        a: "a";
+                        b: "b";
+                        c: "c";
+                        d: "d";
+                    }>>;
+                }, z.core.$strip>>;
+                note: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            id: z.ZodString;
+            intent: z.ZodString;
+            inside: z.ZodOptional<z.ZodObject<{
+                beat: z.ZodString;
+                element: z.ZodString;
+            }, z.core.$strip>>;
+            claim: z.ZodOptional<z.ZodString>;
+            evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    figure: "figure";
+                    equation: "equation";
+                    table: "table";
+                    section: "section";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strip>>>;
+            weight: z.ZodDefault<z.ZodNumber>;
+            seconds: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            narration: z.ZodOptional<z.ZodString>;
+            archetype: z.ZodLiteral<"stack">;
+            params: z.ZodObject<{
+                eyebrow: z.ZodOptional<z.ZodString>;
+                headline: z.ZodString;
+                layers: z.ZodArray<z.ZodObject<{
+                    label: z.ZodString;
+                    note: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                note: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            id: z.ZodString;
+            intent: z.ZodString;
+            inside: z.ZodOptional<z.ZodObject<{
+                beat: z.ZodString;
+                element: z.ZodString;
+            }, z.core.$strip>>;
+            claim: z.ZodOptional<z.ZodString>;
+            evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    figure: "figure";
+                    equation: "equation";
+                    table: "table";
+                    section: "section";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strip>>>;
+            weight: z.ZodDefault<z.ZodNumber>;
+            seconds: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            narration: z.ZodOptional<z.ZodString>;
+            archetype: z.ZodLiteral<"split-compare">;
+            params: z.ZodObject<{
+                eyebrow: z.ZodOptional<z.ZodString>;
+                headline: z.ZodString;
+                left: z.ZodObject<{
+                    label: z.ZodString;
+                    figureId: z.ZodOptional<z.ZodString>;
+                    lines: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>;
+                right: z.ZodObject<{
+                    label: z.ZodString;
+                    figureId: z.ZodOptional<z.ZodString>;
+                    lines: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>;
+                note: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            id: z.ZodString;
+            intent: z.ZodString;
+            inside: z.ZodOptional<z.ZodObject<{
+                beat: z.ZodString;
+                element: z.ZodString;
+            }, z.core.$strip>>;
+            claim: z.ZodOptional<z.ZodString>;
+            evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    figure: "figure";
+                    equation: "equation";
+                    table: "table";
+                    section: "section";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strip>>>;
+            weight: z.ZodDefault<z.ZodNumber>;
+            seconds: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>], "archetype">>;
+    }, z.core.$strip>;
+    narration: z.ZodOptional<z.ZodObject<{
+        voice: z.ZodString;
+        beats: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+            stop: z.ZodInt;
+            text: z.ZodString;
+            audio: z.ZodString;
+            seconds: z.ZodNumber;
+            cues: z.ZodArray<z.ZodObject<{
+                start: z.ZodNumber;
+                end: z.ZodNumber;
+                text: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    media: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        policy: z.ZodEnum<{
+            bake: "bake";
+            link: "link";
+            embed: "embed";
+        }>;
+        path: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        mime: z.ZodOptional<z.ZodString>;
+        bytes: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/**
+ * The profiles that ship with a name. `FORMATS` is keyed by these and nothing
+ * else; `DESTINATIONS` and the budget helpers are indexed by them.
+ *
+ * `Format["id"]` is deliberately WIDER than this — a canvas the caller sized
+ * itself is a real format with a real id, and it is not in this union. See
+ * `resizeFormat`.
+ */
+export type PresetId = "deck-16x9" | "video-16x9" | "short-9x16" | "post-1x1";
+/**
+ * Output profiles. A profile decides canvas, pacing, and how many beats
+ * survive — never what the beats mean.
+ *
+ * A plain type, not a schema: the preset table below is the only source of NAMED
+ * formats there is, and the one other constructor (`resizeFormat`) validates its
+ * own arguments, so there is no boundary at which one could arrive unvalidated.
+ */
+export interface Format {
+    /**
+     * A `PresetId` for the four named profiles, `custom-<w>x<h>` for a canvas the
+     * caller sized. Printed in build lines and in cut explanations, so it has to
+     * describe the thing that was actually built: a resized profile keeps its
+     * base's pacing but NOT its name, because "short-9x16" over a 1080x1350 canvas
+     * would be a lie in every message that quotes it.
+     */
+    id: string;
+    width: number;
+    height: number;
+    /** Keep only beats at or above this weight. */
+    minWeight: number;
+    /** Deck mode emits a slideshow island; video mode does not. */
+    navigable: boolean;
+    /**
+     * The longest NARRATED cut this format may produce, in seconds.
+     *
+     * A length, like a canvas, is part of what a format is: a 9x16 file that runs
+     * four minutes is not a short, it is a tall video nobody can post. So the
+     * number is a hard ceiling and `verify`'s budget gate reads it — see
+     * src/verify/budget.ts for why exceeding it fails the build rather than
+     * silently trimming beats.
+     *
+     * `Infinity` where no platform imposes one. That is not "unchecked": a
+     * presented deck is paced by the person clicking through it, and long-form
+     * video has no ceiling worth encoding, so any finite number here would be a
+     * house rule dressed up as a constraint.
+     *
+     * Optional in the TYPE, mandatory in the TABLE — `test/types.test.ts` asserts
+     * every entry in `FORMATS` states one. A required field cannot tell "chose
+     * Infinity" apart from "forgot the field", and it would force every test
+     * fixture that needs a canvas to invent a length it does not care about.
+     * Absent reads as unbudgeted, which is the safe direction for a fixture and
+     * the one the coherence test refuses for a shipped profile.
+     */
+    maxSeconds?: number;
+    /**
+     * A tighter ceiling that only some destinations impose — a warning, not a
+     * failure. Omitted when every destination for the format agrees on `maxSeconds`.
+     */
+    warnSeconds?: number;
+}
+/** A real place a built file gets uploaded, and the length it stops accepting at. */
+export interface Destination {
+    /** What a person would call it. Printed in budget findings. */
+    name: string;
+    /** Longest video this destination takes, in seconds. */
+    maxSeconds: number;
+}
+/**
+ * Where each format's file is actually going.
+ *
+ * The budget numbers used to be two literals with a comment, and a comment is
+ * not a check: Instagram raised Reels from 90 seconds to three minutes in early
+ * 2025, and the table went on quoting 90 as an Instagram limit long after that
+ * stopped being true. A number in a table nobody can trace is a trap, so
+ * `maxSeconds` and `warnSeconds` are DERIVED from this list — you cannot state a
+ * budget here without naming the destination it came from.
+ *
+ * WHAT IS DELIBERATELY ABSENT. TikTok takes ten minutes and LinkedIn takes
+ * fifteen, and neither is listed, because the cap is the LOOSEST limit among a
+ * format's destinations: adding one permissive platform would raise `short-9x16`
+ * to 600s and the gate would stop failing the four-minute short it exists to
+ * catch. So a destination belongs here only if it CONSTRAINS the deliverable —
+ * a platform that accepts anything the others accept adds nothing but slack.
+ *
+ * Verified by hand, not by network (nothing here may reach one). These move;
+ * when one does, the finding it produces names it, so the stale number is
+ * findable from the message rather than only from this file.
+ */
+export declare const DESTINATIONS: Readonly<Record<PresetId, readonly Destination[]>>;
+/** The loosest destination: what the format may produce at all. */
+export declare function maxSecondsFor(id: string): number;
+/** The tightest destination, when it is tighter — a warning, never a failure. */
+export declare function warnSecondsFor(id: string): number | undefined;
+/** The destination a given ceiling came from, for a message that can name it. */
+export declare function destinationAt(id: string, seconds: number): Destination | undefined;
+export declare const FORMATS: Record<string, Format>;
+/**
+ * The smallest edge a canvas may have.
+ *
+ * Not a taste call. Every absolute measurement in `src/emit/kit.ts` is scaled by
+ * `width / 1920`; at 64px wide that factor is 0.033, which rounds the scene
+ * padding to 4px and puts every emitted type size under 3px. The composition is
+ * still valid HTML — it is just an image of grey smears, and no gate can tell
+ * that from a deck. Below this there is nothing left to be wrong about.
+ */
+export declare const MIN_EDGE = 64;
+/**
+ * The largest edge a canvas may have.
+ *
+ * Chrome's `Page.captureScreenshot` — which is how `render` gets every frame —
+ * is bounded by the maximum texture size, 16384px on the desktop builds
+ * hyperframes drives. Past it capture fails partway through a job that has
+ * already burned an hour, which is the worst possible place to learn a number.
+ */
+export declare const MAX_EDGE = 16384;
+/**
+ * The most lopsided canvas the layout survives, long edge over short.
+ *
+ * DERIVED, not chosen for looks. `padY` in src/emit/kit.ts is `84 × width/1920`
+ * — the vertical padding scales with WIDTH, because the type it clears scales
+ * with width — so on a canvas `k` times wider than tall the two paddings take
+ * `0.0875 × k` of the height. At k = 8 that is 70% of the frame gone to margin
+ * and 30% left to draw in; at k = 11.4 the content box is exactly zero and every
+ * archetype lays out into negative space without a single gate firing. 8 is the
+ * last ratio at which "the slide is mostly margin" is still a slide.
+ *
+ * Applied in both directions. The tall side has no such collapse — it fails
+ * through the type scale instead, which `canvasWarnings` reports below.
+ */
+export declare const MAX_ASPECT = 8;
+/**
+ * Below this width the deck is legible only to a machine.
+ *
+ * Half of the 1920 canvas every measurement in `src/emit` was chosen against.
+ *
+ * MEASURED, on the demo storyboard, by emitting at each canvas and bisecting
+ * (experiments/011-sizing/sweep.mjs). Two things came out of it, and they are
+ * why this is a WARNING and only a warning:
+ *
+ *   - The archetypes already refuse rather than shrink. The smallest 16:9 canvas
+ *     the demo lays out on is about 1325x745; below it `split-compare` throws
+ *     `the panels do not fit beside each other at the 40px floor`, by name, with
+ *     the beat id. Square gives up around 740x740 and 9:16 around 429x763 — the
+ *     narrow shapes get further because they stack instead of sitting side by
+ *     side. So the range between here and there produces a clear build error, not
+ *     a bad deck, and does not need a warning on top of it.
+ *   - Under that boundary the sizes that DO emit put the 40px type floor between
+ *     20 and 28 real canvas pixels depending on `REF_PULL` in src/emit/kit.ts,
+ *     and text that small does not survive H.264 chroma subsampling at any
+ *     bitrate. Nothing in the gate stack measures rendered glyph size, so this
+ *     line is the only warning that will ever be given.
+ *
+ * Not an error, because a 100x100 deck is a legal thing to ask for — a thumbnail
+ * strip, a favicon-scale loop — and this is not the place to argue about it.
+ */
+export declare const LEGIBLE_W = 960;
+/**
+ * Why this canvas cannot be built, in one sentence, or nothing.
+ *
+ * Separate from `canvasWarnings` because the two have different consequences and
+ * the caller must not have to tell them apart by reading the prose.
+ */
+export declare function canvasProblem(width: number, height: number): string | undefined;
+/**
+ * What is legal but probably not what the caller meant. Printed, never fatal.
+ */
+export declare function canvasWarnings(width: number, height: number): string[];
+/**
+ * The same profile on a different canvas.
+ *
+ * WHAT IS AND IS NOT DERIVED. `minWeight`, the duration budget and `navigable`
+ * come from `base` untouched, because there is nothing about a pixel count that
+ * implies any of them: `short-9x16`'s 0.6 floor and 180-second ceiling are facts
+ * about YouTube Shorts, not about being 1080 wide, and inventing an equivalent
+ * for 1080x1350 would be exactly the house-rule-dressed-as-a-constraint that the
+ * note on `DESTINATIONS` exists to forbid. So a resized format inherits from a
+ * profile the caller NAMED — `--width 1080 --height 1350` alone means
+ * "deck-16x9 at another size": unbudgeted, no floor, navigable — and
+ * `--format short-9x16 --width 1080 --height 1350` means "a Reel, but 4:5".
+ *
+ * A canvas identical to the base's returns the base itself, so that stating the
+ * size you were going to get anyway cannot rename your format or cost you the
+ * budget attached to its name.
+ */
+export declare function resizeFormat(base: Format, width: number, height: number): Format;
+/** Whether this format's canvas was given rather than named. */
+export declare function isCustom(format: Format): boolean;
+/** Verdicts are produced and printed in one process; nothing parses them back. */
+export interface Finding {
+    severity: "error" | "warning" | "info";
+    /** Which gate produced it: lint | runtime | layout | motion | contrast. */
+    gate: string;
+    rule: string;
+    message: string;
+    beatId?: string;
+}
+export interface Verdict {
+    passed: boolean;
+    findings: Finding[];
+}
+export type Ref = z.infer<typeof refSchema>;
+export type Figure = z.infer<typeof figureSchema>;
+export type Equation = z.infer<typeof equationSchema>;
+export type Table = z.infer<typeof tableSchema>;
+export type Section = z.infer<typeof sectionSchema>;
+export type Source = z.infer<typeof sourceSchema>;
+export type Term = z.infer<typeof termSchema>;
+export type Beat = z.infer<typeof beatSchema>;
+export type Archetype = Beat["archetype"];
+export type Storyboard = z.infer<typeof storyboardSchema>;
+/** Narrow a beat to one archetype — the emitters' entry point. */
+export type BeatOf<A extends Archetype> = Extract<Beat, {
+    archetype: A;
+}>;