@jokerized/decksmith 0.2.0 → 0.3.1

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

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

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

@@ -1,2 +1,64 @@
-import type { Emitter } from "../kit.js";
+/**
+ * An equation, walked one symbol at a time.
+ *
+ * This is the most valuable thing the vocabulary does: the reader is never shown
+ * a wall of TeX and left to find the symbol being discussed. Each term is wrapped
+ * in `\htmlClass{term t-<tone>}{...}` so KaTeX emits a real element for it, which
+ * GSAP then tints and swells in step with its legend row.
+ */
+import type { Term } from "../../types.js";
+import type { Emitter, Theme } from "../kit.js";
+export declare const OPTS = "{ displayMode: true, trust: function (c) { return c.command === \"\\\\htmlClass\"; }, strict: false, output: \"html\" }";
+export declare const INLINE_OPTS = "{ displayMode: false, trust: function (c) { return c.command === \"\\\\htmlClass\"; }, strict: false, output: \"html\" }";
+/** Where `term` sits in `tex`, comparing normal forms. Null when it is absent. */
+export declare function locate(tex: string, term: string): {
+    start: number;
+    end: number;
+} | null;
+/**
+ * Wrap each term where it first occurs, and report which ones were wrapped.
+ *
+ * Segments are tracked as raw/wrapped so a later term cannot match inside an
+ * earlier term's `\htmlClass{...}` and produce nested markup that highlights the
+ * wrong span.
+ *
+ * A term that cannot be found is DROPPED rather than thrown on, and the caller
+ * drops its legend row with it — the two go together, which is what keeps this
+ * honest. Silently highlighting nothing is the failure this archetype exists to
+ * avoid, and a legend line pointing at an unhighlighted symbol is that failure;
+ * a shorter legend is not. Losing an entire deck to one mis-spelled term is a
+ * worse answer than either. If NOTHING matches, the beat has no work to do and
+ * that is still an error.
+ */
+export declare function wrapTerms(tex: string, terms: Term[], beatId: string, 
+/** The class the wrapper carries; the morph adds its key to the walk's tint. */
+cls?: (t: Term) => string): {
+    tex: string;
+    used: Term[];
+    missing: Term[];
+};
+/**
+ * Display equations want to live between 68px and 108px.
+ *
+ * The equation is the whole argument of this archetype and it was the smallest
+ * thing on the slide — 72px of TeX centred in a 1700px box, measured at 46% fill
+ * with a 1920x316 band under it. It is sized off the source length rather than
+ * off `textWidth` because TeX is not the string that gets set: `\mathcal{W}(F)`
+ * is fourteen characters and three glyphs.
+ *
+ * This is the *wanted* size, not the final one. The old comment here claimed
+ * "KaTeX's own `\displaystyle` box will shrink to the container if the estimate
+ * runs wide". It does not — it overflows, silently, because the composition is
+ * the size it says it is and no gate reads past the canvas edge. At 9:16 that
+ * truncated `X = \mathcal{W}(F)` to "X =" and then left the legend explaining a
+ * symbol the viewer could not see, which is worse than a clip: the slide
+ * asserted something false. `statements` and the `size` cap below are what make
+ * the claim true.
+ */
+export declare function equationSize(tex: string): number;
+/** Estimated rendered width of a display, in ems. */
+export declare function texUnits(tex: string): number;
+/** One row per term: a chip KaTeX fills in `setup`, and the label. Shared with the morph. */
+export declare function legendRows(sid: string, terms: Term[], theme: Theme): string;
+export declare function legendCss(theme: Theme): string;
 export declare const equationWalk: Emitter<"equation-walk">;

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

@@ -12,7 +12,7 @@ export declare const emitters: {
 };
 /**
  * Dispatch a beat to its emitter. The cast is the one place the pairing is taken
- * on trust: `emitters[beat.archetype]` is a union of twelve emitters and TypeScript
+ * on trust: `emitters[beat.archetype]` is a union of thirteen emitters and TypeScript
  * will not narrow the key and the beat together. The table above already proves
  * every archetype has exactly one emitter of the right shape.
  */

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

@@ -25,7 +25,16 @@ import type { BeatOf, Format } from "../../types.js";
 import type { Emitter } from "../kit.js";
 import { type Face } from "../svg.js";
 type Params = BeatOf<"stack">["params"];
+/** Where the numerals' right edge lands once the type floor has moved. */
+export declare function numSpine(floor: number): number;
 export interface StackLayout {
+    /**
+     * The type floor this layout solved against, which is `MIN_FONT` for a flat
+     * beat and larger for a tilted one. The emitter reads it back so the notes it
+     * draws are set at the same floor the solver reserved room for — they were
+     * pinned to `MIN_FONT` directly, which under a tilt drew them below it.
+     */
+    floor: number;
     /**
      * False when the rise the canvas allows is shorter than the tallest label
      * block — i.e. adjacent labels would overlap. `stackLayout` re-composes rather

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

@@ -0,0 +1,95 @@
+/**
+ * Tilting a plane, and paying for it in type size.
+ *
+ * Gap 2 wants depth as exposition — a diagram tilting to reveal a layer. The
+ * expensive half is not the transform. It is that perspective shrinks the type on
+ * the far half of the plane, and invariant 5 is about what the AUDIENCE sees, so
+ * a tilt that leaves a 40px label drawing 31px has broken the floor whatever the
+ * source says. `src/verify/apparent.ts` is the gate that catches it; this module
+ * is how an archetype avoids tripping it, by declaring bigger type up front.
+ *
+ * WHAT IS AND IS NOT SUPPORTED HERE. One transform on one plane — the whole
+ * scene's content tilts as a unit. NOT per-element depth: measured in Chrome,
+ * `translateZ` on an SVG `<g>` under a `preserve-3d` ancestor is ignored
+ * completely (z=0, z=+200 and z=-200 paint the identical rect, while an HTML
+ * sibling in the same test moves and scales correctly). An exploding stack needs
+ * sibling HTML planes and is a later slice; a tilting plate is this one.
+ *
+ * THE MODEL. For a plane rotated by `t` about its horizontal centre line under
+ * CSS `perspective: d`, a point `dy` below the plane's centre is drawn at
+ *
+ *     scale(dy) = cos(t) * (d / (d - dy * sin(t)))^2
+ *
+ * — `cos(t)` for the foreshortening and the square for the perspective divide
+ * applying to both the glyph's height and its distance from the eye. Fitted
+ * against Chrome at `rotateX(30deg)`, `perspective: 1400px`:
+ *
+ *     dy = -340 (near the top)     model 0.6886   Chrome 0.6820   +0.97%
+ *     dy = +360 (near the bottom)  model 1.1404   Chrome 1.1260   +1.28%
+ *
+ * The model runs about 1% OPTIMISTIC, so `worstScale` rounds its answer down by
+ * 2% before anyone divides by it. Erring large costs a couple of type px; erring
+ * small ships a slide under the floor, which is the whole failure this exists to
+ * prevent.
+ */
+/** How a scene's plane is tilted. Degrees, and CSS `perspective` in px. */
+export interface Pose {
+    /** Rotation about the horizontal centre line. Positive tips the top away. */
+    rotateX: number;
+    /** CSS `perspective`, in reference px. Smaller is a stronger effect. */
+    perspective: number;
+}
+/**
+ * The default a depth archetype gets when it asks for one.
+ *
+ * 12 degrees, not the 30 the spike reached for. The table in `worstScale`'s note
+ * is why: at 30 degrees a 40px audience floor needs 67px declared, which is more
+ * than a headline can spend and still fit its own line. At 12 it needs 48.7px,
+ * which archetypes can and do pay. Depth here is a lean, not a dive.
+ */
+export declare const DEFAULT_POSE: Pose;
+/** Apparent scale at `dy` reference px below the plane's centre. */
+export declare function scaleAt(pose: Pose, dy: number): number;
+/**
+ * The smallest scale anywhere on a `height`-tall plane, already discounted.
+ *
+ * The smallest scale is at the TOP edge, furthest from the eye. The BOTTOM edge
+ * is the one that can swing through the eye entirely, and when it does the plane
+ * is not being tilted any more — it is being turned inside out — so the pose is
+ * refused rather than priced. Checking only the top would have returned a
+ * perfectly reasonable-looking floor for a pose that cannot be drawn.
+ *
+ * What it buys, at `perspective: 1400` on a 1080 canvas, AFTER the 2% discount:
+ *
+ *   rotateX(6)   0.901  ->  a 40px floor needs 44.4px declared
+ *   rotateX(12)  0.821  ->  48.7px
+ *   rotateX(18)  0.744  ->  53.8px
+ *   rotateX(24)  0.669  ->  59.8px
+ *   rotateX(30)  0.597  ->  67.0px
+ *
+ * That table is the tilt budget. Depth in this project is bounded by the type
+ * floor rather than by taste, and the bound is tighter than it looks.
+ */
+export declare function worstScale(pose: Pose, height: number): number;
+/**
+ * The type floor an archetype must solve against to LAND on `floor` once tilted.
+ *
+ * Archetypes already solve against a floor — `stack` passes `MIN_FONT` into its
+ * own fit — so depth costs them one substitution rather than a second solver.
+ */
+export declare function tiltedFloor(pose: Pose, height: number, floor: number): number;
+/**
+ * The CSS a tilted scene needs, scoped to its own id (invariant 3).
+ *
+ * `perspective` sits on the scene and the rotation on ONE part of it, named by
+ * `part`, because tilting a whole scene tilts its chrome too. Built that way
+ * first and it was obviously wrong the moment a frame was opened: the headline
+ * came out sheared, leaning like a mistake rather than a design, and the stack's
+ * probe marker — a straight rule with a dot under it — bent into a hook. The
+ * diagram is what gains by leaning; the words are what the audience reads.
+ *
+ * Nothing here animates: a pose is a static property of the beat, and a tilt that
+ * moved would put every label at a different apparent size on every frame while
+ * `apparent` only measures at the declared stops.
+ */
+export declare function depthCss(sid: string, pose: Pose, part: string): string;

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

@@ -285,6 +285,13 @@ export interface Scene {
      * values.
      */
     measure?: string[];
+    /**
+     * Vendored runtimes this scene's tweens need registered before its script
+     * runs — `"dsMorph"` for the equation morph. The shell loads a runtime only
+     * when some scene names it, so a deck that names none is byte-for-byte what
+     * it was.
+     */
+    plugins?: readonly string[];
     /**
      * Hold points in seconds from the scene's start — where a presenter should
      * pause. The shell converts these to absolute island fragment times.

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

@@ -0,0 +1,178 @@
+/**
+ * The keyed equation morph — TransformMatchingTex, for the DOM.
+ *
+ * Two KaTeX renderings in, one seek-evaluable plan out. `build()` runs once in
+ * the browser, inside the ready gate (Seam B), and bakes every number; the
+ * plan is then driven by a GSAP PLUGIN — `render(ratio)` is part of being
+ * seeked, so it fires under `suppressEvents` where an `onUpdate` would not
+ * (invariant 11). Nothing here runs on a callback.
+ *
+ * Four phases, kept separate on purpose:
+ *   1. LIFT   — pull every ink-bearing leaf out of KaTeX's nested boxes into a
+ *               flat absolutely-positioned overlay. Removes clipping, vlist
+ *               stacking and transform-on-inline entirely.
+ *   2. GROUP  — collect leaves into the units that move as one body. An author
+ *               key makes a group; an unkeyed leaf is its own group.
+ *   3. MATCH  — decide which group of A becomes which group of B.
+ *   4. PLAN   — a similarity transform per group, as per-leaf segments.
+ *
+ * `evaluate()` turns a plan and a progress into styles. It is a pure function
+ * of its arguments — two seeks to one time write the same strings — which is
+ * what makes the render byte-identical across browser processes, measured on
+ * the spike this is ported from (`experiments/013-vocabulary/morph/`).
+ *
+ * Bundled to an IIFE by `scripts/build.mjs`, vendored beside GSAP by the CLI,
+ * and loaded only by a deck that has a morph in it. The pure halves — `group`,
+ * `match`, `plan`, `evaluate` — are exported for the tests, which is why the
+ * window registration at the bottom is guarded.
+ */
+/** The class prefix an author key is carried on: `\htmlClass{ds-k-<key>}{...}`. */
+export declare const KEY_PREFIX = "ds-k-";
+export interface Leaf {
+    el: HTMLElement;
+    key: string;
+    sig: string;
+    text: string;
+    /** Font size in layout px. */
+    fs: number;
+    /** Centre and box, in the host's own layout px. */
+    cx: number;
+    cy: number;
+    w: number;
+    h: number;
+}
+export interface Group {
+    ident: string;
+    key: string;
+    leaves: Leaf[];
+    cx: number;
+    cy: number;
+    w: number;
+    h: number;
+    fs: number;
+    text: string;
+}
+/**
+ * The unit that moves as one body.
+ *
+ * This is the whole quality argument of the file. Matching GLYPH BY GLYPH is
+ * what a naive reading of TransformMatchingTex suggests and it is visibly
+ * wrong: in `a^2+b^2=c^2 -> c^2-b^2=a^2` the three `2`s are interchangeable
+ * under any text-plus-class identity, so they pair left-to-right and stay put
+ * while their bases cross over. The audience sees the letters swap and the
+ * exponents refuse to follow, which asserts something false about the algebra.
+ *
+ * Manim does not avoid this by being cleverer — `MathTex("a^2", "+", "b^2",
+ * ...)` is the AUTHOR splitting the expression into the parts meant to
+ * survive. `\htmlClass{ds-k-<key>}{...}` is the same act, and it is the only
+ * mechanism here that produces a correct morph on an ambiguous pair.
+ *
+ * A group's identity is its key alone, not its contents, so `ds-k-exp` can
+ * carry `x^2` onto `x^3`: the body moves and its contents dissolve.
+ */
+export declare function group(items: Leaf[]): Group[];
+export interface Match {
+    pairs: [number, number][];
+    dropA: number[];
+    addB: number[];
+}
+/**
+ * Bucket by identity, then pair NEAREST FIRST within a bucket.
+ *
+ * Document order — the spike's rule — sends the wrong twin across the slide:
+ * `F = E(I), X = W(F)` has two `=` and its successor one, and pairing the
+ * first `=` with it flew a glyph 800px over the equation while the `=` sitting
+ * 40px from its destination faded out. Nearest-first is what a viewer expects
+ * of a symbol that did not move. Ties fall to document order, so it is still a
+ * pure function of the two layouts.
+ */
+export declare function match(A: Group[], B: Group[]): Match;
+export type Prop = "x" | "y" | "s" | "o";
+export type Ease = "none" | "power1.in" | "power1.out" | "power2.in" | "power2.out" | "power2.inOut";
+/**
+ * One property of one leaf, over one slice of the morph.
+ *
+ * Times are FRACTIONS of the morph, not seconds: the plan is evaluated against
+ * the plugin tween's ratio, so `pace()` scaling the tween's `duration` scales
+ * all of this with it, and the plan never has to know how long it takes.
+ */
+export interface Step {
+    el: HTMLElement;
+    prop: Prop;
+    from: number;
+    to: number;
+    at: number;
+    dur: number;
+    ease: Ease;
+}
+/**
+ * One similarity transform per matched group, expressed per leaf.
+ *
+ * A group's leaves move RIGIDLY: every leaf gets the same scale and the
+ * translation that the group's own centre-to-centre move implies for its
+ * position within the body. `a^2` therefore arrives with its exponent still
+ * attached, which is the whole reason groups exist.
+ *
+ * The B side is placed by the INVERSE transform — B's leaves start where they
+ * would sit inside A's box — so when the contents differ the two renderings
+ * dissolve into each other while sharing one trajectory.
+ *
+ * `arc` bows the path. Two glyphs swapping ends of an equation travel the same
+ * straight line in opposite directions and pile up in the middle, which reads
+ * as a collision rather than an exchange. The bow is two segments on `y` — out
+ * over the first half, back over the second — against one on `x` that runs
+ * the whole way.
+ */
+export declare function plan(A: Group[], B: Group[], m: Match, opt: {
+    arc?: boolean;
+}): Step[];
+export interface MorphPlan {
+    leaves: {
+        el: HTMLElement;
+        side: "a" | "b";
+    }[];
+    steps: Step[];
+}
+/**
+ * Write the morph at progress `v` in [0, 1] into every leaf's style.
+ *
+ * Every leaf is written every time, from its resting state forward — A drawn,
+ * B hidden, nothing moved — so a cold seek to any progress produces the same
+ * strings as a walk to it. That is the property the capture depends on.
+ */
+export declare function evaluate(p: MorphPlan, v: number): void;
+export interface Stats {
+    groupsA: number;
+    groupsB: number;
+    leavesA: number;
+    leavesB: number;
+    matched: number;
+    dropped: number;
+    added: number;
+}
+/**
+ * Build the morph inside `host`, which must already contain two rendered KaTeX
+ * roots marked `data-morph="a"` and `data-morph="b"`. Runs in `measure`, after
+ * fonts; the plan is kept for the plugin tween on the same host to find.
+ */
+export declare function build(host: HTMLElement, opt?: {
+    arc?: boolean;
+}): Stats;
+interface PluginState {
+    plan: MorphPlan;
+    end: number;
+}
+/**
+ * `dsMorph` as a GSAP property: `tl.fromTo(host, { dsMorph: 0 }, { dsMorph: 1 })`.
+ *
+ * A plugin's `render` is called by the timeline as part of being seeked, so
+ * this runs under `suppressEvents` — the capture path — where an `onUpdate`
+ * does not. The tween's own ease must be "none": the plan carries its eases
+ * per segment, and a second ease on top would warp every one of them.
+ */
+export declare const DSMorphPlugin: {
+    name: string;
+    init(this: PluginState, target: Element, value: unknown): void;
+    render(ratio: number, d: PluginState): void;
+};
+export {};

package/dist/types/index.d.ts

@@ -111,7 +111,7 @@ export { verify } from "./verify/index.js";
  * deck was asked for, which a built directory does not carry — and
  * `scanUnusedFigures` folds in only where the source was passed alongside.
  */
-export { scanBeatCount, scanHeadlines, scanNarrationLead, scanRepeatedObject, scanUnusedFigures, } from "./verify/index.js";
+export { scanBeatCount, scanNarrationDrift, scanPaperArc, scanHeadlines, scanNarrationLead, scanRepeatedObject, scanUnusedFigures, } from "./verify/index.js";
 export { check, parseCheckReport, sampleTimes } from "./verify/check.js";
 export type { CheckOptions } from "./verify/check.js";
 /**

package/dist/types/mcp/tools.d.ts

@@ -26,6 +26,10 @@ export declare const settingsSchema: z.ZodObject<{
         normal: "normal";
         dense: "dense";
     }>>;
+    genre: z.ZodOptional<z.ZodEnum<{
+        general: "general";
+        paper: "paper";
+    }>>;
     duration: z.ZodOptional<z.ZodNumber>;
     slides: z.ZodOptional<z.ZodInt>;
     animation_speed: z.ZodOptional<z.ZodNumber>;
@@ -63,6 +67,10 @@ export declare const estimateSchema: z.ZodObject<{
             normal: "normal";
             dense: "dense";
         }>>;
+        genre: z.ZodOptional<z.ZodEnum<{
+            general: "general";
+            paper: "paper";
+        }>>;
         duration: z.ZodOptional<z.ZodNumber>;
         slides: z.ZodOptional<z.ZodInt>;
         animation_speed: z.ZodOptional<z.ZodNumber>;
@@ -101,6 +109,10 @@ export declare const createSchema: z.ZodObject<{
             normal: "normal";
             dense: "dense";
         }>>;
+        genre: z.ZodOptional<z.ZodEnum<{
+            general: "general";
+            paper: "paper";
+        }>>;
         duration: z.ZodOptional<z.ZodNumber>;
         slides: z.ZodOptional<z.ZodInt>;
         animation_speed: z.ZodOptional<z.ZodNumber>;

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

@@ -0,0 +1,82 @@
+/**
+ * The paper arc: what a research-talk deck must open and close with.
+ *
+ * A research talk has a shape a general explainer does not. It opens on the
+ * problem and on the ground the work stands on, and it closes on what the work
+ * does NOT do and then on what to take away. DeckSmith's planner writes the
+ * opening well already — 13 of 15 committed full-deck runs open with a `title` —
+ * and the ending badly: 10 of 15 close with a `callout`, but ZERO of 15 carry
+ * two, because the limitation arrives as a subordinate clause inside the
+ * conclusion ("The idea works, but the strongest lightweight models remain
+ * ahead") rather than as its own slide. Splitting that clause into a slide is
+ * the actual behaviour change this module asks for.
+ *
+ * WHY THIS FILE EXISTS AT ALL, rather than the rule living where it is enforced:
+ * three directories read this definition and none of them can own it — the
+ * prompt (src/plan/prompt.ts) asks the model for the arc, the scan
+ * (src/verify/index.ts) reports where a plan missed it, and the cut
+ * (src/plan/select.ts) refuses to delete a beat that carries a role. Restating
+ * the rule three times is how the three fall out of step; deriving it from one
+ * table is how they cannot.
+ *
+ * WHAT THIS MODULE DELIBERATELY DOES NOT DO. It never decides that a document is
+ * a research paper. `prefs.genre` is declared by the author and nothing here
+ * sniffs it — see the field's own note in src/types.ts for the measurement that
+ * settled that. And it never requires a beat the source cannot support: RULE 3
+ * forbids inventing a baseline or a result, so a source that says nothing about
+ * prior work honestly yields no `background` beat, and this file's job is then
+ * to report the gap rather than to have manufactured one.
+ */
+import type { Prefs } from "../prefs.js";
+import type { Beat, BeatRole, Storyboard } from "../types.js";
+/** Every structural job, in the order a deck performs them. */
+export declare const ARC_ROLES: readonly BeatRole[];
+/**
+ * Roles required at a given deck length, and why the list shortens.
+ *
+ * Four reserved slides out of five is not a deck, it is a table of contents. At
+ * `--duration 60` a deck is about five beats, so asking for the full arc there
+ * is asking for something nobody could deliver, and a gate that fires on the
+ * impossible is one people learn to ignore. The thresholds:
+ *
+ *   n >= 8   the full arc. 8 is this project's own definition of a full-deck
+ *            run — the corpus count of "15 committed full-deck plans" is beats
+ *            >= 8 — not a number chosen here.
+ *   5..7     the ending only. An `intro` is what the planner already writes
+ *            unprompted 13 times in 15, and `background` is the beat most likely
+ *            to have no source material behind it, so those two are the ones to
+ *            give up first when the budget is short.
+ *   n < 5    nothing. There is no room for a shape.
+ *
+ * Read off the beat count the plan actually came back with, not off
+ * `prefs.slides`: the floor the author asked for and the deck the planner
+ * returned are different numbers, and `scanBeatCount` already owns the gap
+ * between them.
+ */
+export declare function requiredRoles(beatCount: number): readonly BeatRole[];
+/** Whether the paper arc was asked for at all. Declared, never sniffed. */
+export declare function paperArcRequested(prefs: Pick<Prefs, "genre">): boolean;
+/** The beats carrying a structural role, by role. Later duplicates are reported, not kept. */
+export declare function arcBeats(storyboard: Storyboard): Map<BeatRole, Beat[]>;
+/**
+ * Ids of every beat carrying a role — what the cut refuses to release.
+ *
+ * Takes a beat list rather than a Storyboard because the cut works over the
+ * surviving beats, not over the plan.
+ */
+export declare function arcIds(beats: readonly Beat[]): Set<string>;
+/**
+ * Where a plan departs from the arc it was asked for, as sentences.
+ *
+ * ORDER IS CHECKED, NOT JUST PRESENCE, and only where order is the point. The
+ * user's requirement is specifically that the deck END on the conclusion with
+ * limitations immediately before it — an ending is a position, not a topic — so
+ * those two are checked against the last two slots. The opening pair is checked
+ * for presence and for being early, because "the first couple of slides" is a
+ * region rather than an index, and a deck that opens title, problem, background
+ * is not wrong.
+ *
+ * Returns an empty array when the arc was not requested, when the deck is too
+ * short to carry it, or when the plan satisfied it.
+ */
+export declare function arcProblems(storyboard: Storyboard, prefs: Pick<Prefs, "genre" | "slides">): string[];

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

@@ -1,5 +1,11 @@
 import type { Prefs } from "../prefs.js";
 import { type Source, type Storyboard } from "../types.js";
+/** The schema for one run. `role` is present only when the paper arc was asked for. */
+export declare function schemaFor(prefs: Pick<Prefs, "genre">): unknown;
+/**
+ * The default-preferences schema, unchanged and still exported: `general` hides
+ * `role`, so these bytes are what they have always been.
+ */
 export declare const SCHEMA: unknown;
 export interface CodexOptions {
     /** Left unset by default: use whatever model the user's Codex is configured for. */

package/dist/types/prefs.d.ts

@@ -39,6 +39,7 @@ export interface PrefFlags {
     lang?: string;
     tone?: string;
     density?: string;
+    genre?: string;
     duration?: string | number;
     theme?: string;
     speed?: string | number;

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

@@ -60,20 +60,6 @@ export interface AudioInput {
     file: string;
     delayMs: number;
 }
-/**
- * Delay every segment onto one track and sum them.
- *
- * `amix` with `normalize=0` sums rather than averaging: the default divides by
- * the input count, which on a 37-segment deck would render the narration 31 dB
- * down and sound exactly like a bug in the TTS. The segments never overlap — the
- * timing model gives each one the video's undivided attention — so summing is
- * safe. `dropout_transition=0` stops amix ramping the gain as inputs end.
- *
- * Every input is resampled and laid out identically first, because amix refuses
- * a mismatch and edge-tts emits 24 kHz mono while the video wants 48 kHz.
- * `apad` runs the track out to the video's length so the mux does not have to
- * choose between a short audio stream and `-shortest` truncating the picture.
- */
 export declare function audioGraph(inputs: readonly AudioInput[], seconds: number, 
 /**
  * ffmpeg input index of the first mp3. 1 when the video is the only other