@jokerized/decksmith 0.5.2 → 0.6.0

package/dist/types/deck/runtime.d.ts

@@ -105,6 +105,46 @@ interface Frame {
  * cannot drive it. `present()` says so out loud rather than rendering blank.
  */
 export declare function frameOf(player: Player): Frame | null;
+/**
+ * Whether a scene is on screen at composition time `t`: from its slide's start
+ * until its CLIP ends, which is the engine's own rule — hyperframes shows a clip
+ * while `start <= t < start + data-duration`, and nothing else.
+ *
+ * THE CLIP, NOT THE SLIDE, and the slide was a live blink. `composition.ts`
+ * lets every scene but the last outlast its slide by one handoff, so the
+ * outgoing scene dissolves over the incoming one's empty opening — `chromeIn`
+ * puts first ink at 0.15s. The render honoured that; this function used the
+ * island's `endTime`, hid the outgoing scene on the seam's instant, and a glide
+ * across a seam cut a lit slide to flat background. Measured 2026-09-18 on
+ * deck.html at hyperframes 0.8.43 with a hand-stepped 60Hz clock, gliding
+ * 6.2s -> 8.55s over a `stack` -> `pipeline` seam at 7.0s: ELEVEN ticks,
+ * 7.000s through 7.167s, of background and presenter chrome alone, while the
+ * mp4 of the same deck had no background-only frame at any seam. See
+ * `.planning/2026-09-18-scene-boundary-blink.md`.
+ *
+ * `clip` is the scene div's `data-duration`. Anything unusable falls back to the
+ * island's window, which is what every deck did before the handoff existed.
+ */
+export declare function showingAt(slide: SlideSpec, clip: number, t: number): boolean;
+/**
+ * Put the composition on the frame at time `t`.
+ *
+ * `player.seek()` moves the player's own clock; under the render engine that is
+ * enough, because the engine drives each scene's timeline and clip visibility
+ * itself. The standalone player bundle does neither — so a seeked deck shows
+ * every scene stacked with all its entrance tweens still at their `from` state,
+ * i.e. blank. Scenes are addressed by the ids the island already carries; the
+ * one thing read off the scene itself is how long its clip runs, because the
+ * island only knows the slide (see `showingAt`).
+ *
+ * Exported so test/deck.test.ts can drive it through a fake frame. Testing
+ * `showingAt` alone left this function free to stop calling it: put main's
+ * slide-window rule back here and every deck test passed, the Chrome suite
+ * included, because test/deck-page.test.ts only checks resting stops and no
+ * stop falls inside a handoff. The deck-runtime bundle is an IIFE, so the
+ * export does not reach deck.html.
+ */
+export declare function paint(frame: Frame, slides: readonly SlideSpec[], t: number): void;
 export interface Voice {
     /**
      * Arrive at a stop: cut whatever was speaking, start this stop from zero.

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

@@ -70,6 +70,14 @@
  *    lives on the clip and nowhere else. The 150ms proposed here turned out to
  *    be short by half; `HANDOFF_SECONDS` carries the luma trace that fixes it.
  *
+ *    IT CLOSED IN THE RENDER AND NOT IN deck.html, until 2026-09-18. The engine
+ *    reads the clip; `paint()` in `src/deck/runtime.ts` read the island's slide
+ *    window, so a presented deck gliding across a seam still hid the outgoing
+ *    scene on the seam's instant — eleven 60Hz ticks of flat background on a
+ *    `stack`→`pipeline` seam at hyperframes 0.8.43, while the mp4 of the same
+ *    deck had none at any of its three seams. `showingAt` now gives `paint()`
+ *    the engine's rule. `.planning/2026-09-18-scene-boundary-blink.md`.
+ *
  *    That dip is a compromise and it is worth naming. The spike's version keeps
  *    the container lit while the contained scene arrives inside it, which needs
  *    both scenes on screen at once — and `hyperframes lint` rejects that

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

@@ -12,7 +12,7 @@
  */
 import type { z } from "zod";
 import { type Cut } from "../plan/select.js";
-import type { Format, Source, Storyboard, segmentSchema } from "../types.js";
+import type { Format, NarrationCanvas, Source, Storyboard, segmentSchema } from "../types.js";
 import { type Scene } from "./kit.js";
 /** A built deck. `page` is present only for navigable formats. */
 export interface Deck {
@@ -39,6 +39,14 @@ export interface DeckNarration {
     voice: string;
     /** Directory holding the mp3s, relative to `deck.html`. */
     dir: string;
+    /**
+     * What `narrate` split the sentences over: the canvas, each narrated beat's
+     * stop count, and the density cap. Absent on narration written before they
+     * were recorded, which builds unchecked. See `assertNarrationStaging`.
+     */
+    canvas?: NarrationCanvas | undefined;
+    stops?: Record<string, number> | undefined;
+    speakingStops?: number | undefined;
     beats: Record<string, Segment[]>;
 }
 /**

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

@@ -1,20 +1,24 @@
+import type { Format, Storyboard } from "../types.js";
+import { type Scene } from "./kit.js";
+import { type DeckTheme } from "./themes/index.js";
+export { type DeckTheme, ink, mono, paper, resolveTheme, THEME_NAMES, THEMES, } from "./themes/index.js";
 /**
- * The shared stylesheet, the ambient gate, and the deck's pacing.
+ * The theme a storyboard's scenes are staged with, and the font family it ships.
  *
- * The palettes themselves moved to `./themes/` once there was more than one;
- * this file stays the door to them, so nothing that imports `ambient` or `ink`
- * had to be touched to gain a registry.
+ * ONE RESOLUTION for every place that emits a beat to learn how it stages:
+ * `planCut` and `layout`, `planTiming`, and `narrate`. It is not only colour.
+ * The family goes first in `fontStack`, `faceOf` reads it, and a Hangul or CJK
+ * face measures Latin runs wider, so a beat can fit in one theme and be refused
+ * in the other. MEASURED 2026-09-18: `narrate` staged with the bare `ink` theme,
+ * and a `lang: "ko"` callout at 1380×776 was one stop there and four in the
+ * build, so its three sentences played as one segment over the first card.
  *
- * What is left here is everything a theme does NOT decide per-theme: the reset,
- * the scene box, the two ambient keyframes, and `pace`. Typography belongs to
- * the archetype that draws it, not to this file. Two stylesheets describing one
- * `.figwrap` is how a rule ends up being decided by emission order, so nothing
- * an emitter styles is styled here as well.
+ * `name` overrides `storyboard.theme`, as `--theme` does at build.
  */
-import type { Format } from "../types.js";
-import { type Scene } from "./kit.js";
-import type { DeckTheme } from "./themes/index.js";
-export { type DeckTheme, ink, mono, paper, resolveTheme, THEME_NAMES, THEMES, } from "./themes/index.js";
+export declare function deckLook(storyboard: Pick<Storyboard, "theme" | "lang">, name?: string): {
+    family: string | null;
+    theme: DeckTheme;
+};
 /** Where `ingest` writes the subsetted font bundle, relative to the deck. */
 export declare const FONT_BUNDLE_DIR = "assets/fonts";
 export declare const FONT_BUNDLE_HREF = "assets/fonts/fonts.css";

package/dist/types/narrate/narrate.d.ts

@@ -14,13 +14,17 @@
  * archetype whose reveal count depends on its params.
  */
 import type { z } from "zod";
+import type { Theme } from "../emit/kit.js";
 import type { Source, Storyboard } from "../types.js";
-import { type Beat, type Format, type prefsSchema, type segmentSchema } from "../types.js";
+import { type Beat, type Format, type NarrationCanvas, type prefsSchema, type segmentSchema } from "../types.js";
 import { type Runner } from "./tts.js";
 type Prefs = z.infer<typeof prefsSchema>;
 type Segment = z.infer<typeof segmentSchema>;
 type Narration = {
     voice: string;
+    canvas: NarrationCanvas;
+    stops: Record<string, number>;
+    speakingStops?: number;
     beats: Record<string, Segment[]>;
 };
 /**
@@ -41,8 +45,13 @@ export declare function stopCount(holds: readonly number[]): number;
  * `onBeatError`, which is where a missing slide is reported and where a caller
  * without that hook still gets the error. Throwing here instead killed the whole
  * job one stage early, with the hook the caller had passed never reached.
+ *
+ * `theme` must be the one the build stages with, `deckLook(storyboard).theme`,
+ * which is what `narrate` passes: the font face it names decides whether a beat
+ * fits. The `ink` default is for a caller that has no storyboard and no
+ * CJK-language beat.
  */
-export declare function stopsFor(beat: Beat, source: Source, format: Format, sid?: string): number;
+export declare function stopsFor(beat: Beat, source: Source, format: Format, sid?: string, theme?: Theme): number;
 /**
  * Split narration into sentences.
  *
@@ -65,12 +74,26 @@ export declare function splitSentences(text: string): string[];
  * Returns one entry per stop; `""` means nothing is said there.
  */
 export declare function planSegments(text: string, stops: number): string[];
+/**
+ * How many stops `planSegments` gives words to, for a beat staged with `stops`
+ * stops under a density cap of `cap`.
+ *
+ * Two stagings that answer the same number split `text` identically, sentence
+ * for sentence and stop for stop: the first n-1 speaking stops get one sentence
+ * each and the last gets the rest. So this, not the raw stop count, is what has
+ * to agree between `narrate` and a build. A beat with three sentences reads the
+ * same over four stops as over five; the extra stop is silent either way.
+ */
+export declare function speakingStopCount(text: string, stops: number, cap?: number): number;
 export interface NarrateOpts {
     /** Directory the audio is written into. Returned paths are relative to it. */
     dir: string;
     /** Injected in tests so no test reaches the network. */
     runner?: Runner;
-    /** Staging differs by canvas, so the stop count does too. */
+    /**
+     * Staging differs by canvas, so the stop count does too. Recorded in the
+     * result as `canvas`, which is what lets `build` refuse another one.
+     */
     format?: Format;
 }
 /**
@@ -84,4 +107,51 @@ export interface NarrateOpts {
  * actually speak.
  */
 export declare function narrate(storyboard: Storyboard, source: Source, prefs: Prefs, opts: NarrateOpts): Promise<Narration>;
+/** The part of a narration a build checks, as `narrate` wrote it. */
+export interface NarrationStaging {
+    canvas?: NarrationCanvas | undefined;
+    stops?: Readonly<Record<string, number>> | undefined;
+    speakingStops?: number | undefined;
+    beats: Readonly<Record<string, readonly {
+        text: string;
+    }[]>>;
+}
+/** What `narrate` records about the format it staged against. */
+export declare function narrationCanvas(format: Format): NarrationCanvas;
+/**
+ * The warning for narration that records no stop counts, or undefined.
+ *
+ * ACCEPTED, NOT REFUSED. That is every `narration.json` and every pack written
+ * before `narrate` recorded them. Refusing would make each of those decks
+ * unbuildable until re-narrated, and a pack carries the mp3s but not the TTS
+ * cache sidecars, so for an unpacked deck that is every sentence synthesised
+ * again. The cost is that an old file staged differently still builds wrong,
+ * and this sentence is the only thing that says it was not checked. The library
+ * has no channel for it; the CLI prints it.
+ */
+export declare function uncheckedNarration(narration: NarrationStaging, format: Format): string | undefined;
+/**
+ * Refuse narration whose sentences were split over stops this build does not
+ * stage.
+ *
+ * `staged` is each beat THIS DECK DRAWS mapped to its stop count here: a beat
+ * the build leaves out, by refusal or by budget, speaks nowhere and cannot be
+ * wrong. For each one that has segments, the speaking-stop count `narrate` split
+ * against is compared with the one this staging gives (`speakingStopCount`).
+ *
+ * COMPARED PER BEAT, NOT BY CANVAS. The canvas was the first version of this
+ * check and it was wrong both ways: it refused `deck-16x9` narration built at
+ * `short-9x16`, which stages every drawn demo beat identically, and it passed a
+ * Korean deck whose font face made `narrate` and `build` stage one beat
+ * differently at the same size. A beat's own stop count is the fact both sides
+ * record, so it also catches a params edit that moves the count without
+ * changing a word, which `scanNarrationDrift` cannot see.
+ *
+ * THROWN, NOT REPORTED, for the reason `scanNarrationDrift` is an error: the
+ * two sides are recorded facts that must agree, and what gets through is a deck
+ * whose voice describes reveals that are not on screen. `place` clamps a stop
+ * past the end, `assertFits` skips a clamped one, and `build` printed PASS on
+ * the measured case.
+ */
+export declare function assertNarrationStaging(narration: NarrationStaging, staged: ReadonlyMap<string, number>, format: Format): void;
 export {};

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

@@ -163,9 +163,11 @@ export declare function assertHoldsAgree(scenes: TimedScene[], fragments: Record
  * timelines and why the video keeps its length.
  *
  * A segment whose `stop` is past the end of the stop list is clamped onto the
- * last one. That only happens when a deck is narrated for one format and built
- * for another whose staging differs; speaking it late over the final state
- * beats dropping the sentence on the floor.
+ * last one. That happens only when the staging moved after `narrate` ran and
+ * the narration records no stop counts to say so: a file written before they
+ * were recorded. One that records them never gets here with a moved beat;
+ * `assertNarrationStaging` refuses it first. Speaking it late over the final
+ * state beats dropping the sentence on the floor.
  */
 export declare function place(scenes: TimedScene[], spoken: Record<string, Segment[]>): TimedSegment[];
 /**

package/dist/types/server/auth.d.ts

@@ -0,0 +1,160 @@
+/**
+ * Who may use the server, and over what: the startup policy, the token, and the
+ * browser session cookie.
+ *
+ * NODE BUILTINS ONLY. `build:server` transpiles this directory file by file
+ * without bundling, so an import of anything else would survive into
+ * dist/server/ and resolve to nothing — the failure "the server's imports
+ * survive the build" in test/server.test.ts exists to catch.
+ *
+ * THE POLICY IS REFUSE, NEVER WARN. A server that starts with a warning about
+ * being open is a server that is open: nobody reads a banner. So every
+ * configuration that would put the Codex spend endpoint on a network without a
+ * token and a certificate, or would quietly ignore a credential someone set, is
+ * a refusal at startup that names each problem and what fixes it. There is no
+ * override flag, and `createDeckServer` repeats the one check that matters most
+ * so no future caller can skip this file.
+ *
+ * WHAT IS KEPT IN MEMORY is `sha256(token)` to compare against and an HKDF of
+ * the token to sign sessions with. The token itself, a cookie value and an
+ * `Authorization` header are never logged, and no message here prints a file's
+ * contents or a fingerprint of the token: an unsalted hash prefix in a log is an
+ * offline oracle for a weak one.
+ *
+ * A SESSION BELONGS TO ONE LISTENER, not to the host. The port is in the cookie's
+ * name and `host:port` is inside the MAC, because cookies have no port and two
+ * DeckSmiths reading one token file would otherwise be interchangeable to a
+ * browser. That is a collision fix, NOT confidentiality: the browser still hands
+ * this cookie to every listener on the host, and the README says what that lets a
+ * local account do.
+ */
+import { X509Certificate } from "node:crypto";
+/**
+ * A loopback bind, spelled exactly as `DECKSMITH_HOST` must spell it. Anything
+ * else — `127.0.0.2`, `::ffff:127.0.0.1`, `0.0.0.0`, an empty string — is
+ * treated as exposed. A list that fails closed on a spelling it does not know is
+ * the point; resolving names here would make the answer depend on DNS.
+ */
+export declare const LOOPBACK_BINDS: string[];
+/** How long a browser session lasts. A constant, not a setting. */
+export declare const SESSION_SECONDS: number;
+/**
+ * The floor `createDeckServer` gives OpenSSL, and the floor `readTls` validates
+ * against. ONE CONSTANT because the two must not drift: validating a pair under
+ * a laxer policy than the server will use is a refusal that never fires and a
+ * stack trace at listen instead.
+ */
+export declare const TLS_MIN_VERSION: "TLSv1.2";
+/** What a request is compared against. Derived from the token, never the token. */
+export interface AuthKeys {
+    tokenHash: Buffer;
+    sessionKey: Buffer;
+}
+export interface TlsMaterial {
+    /** The PEM chain, leaf first, exactly as read. */
+    cert: Buffer;
+    key: Buffer;
+    /** The leaf. Its SANs are the Host allowlist on an exposed bind. */
+    x509: X509Certificate;
+}
+export interface Security {
+    host: string;
+    loopback: boolean;
+    sandboxDecks: boolean;
+    auth?: AuthKeys & {
+        file: string;
+    };
+    tls?: TlsMaterial & {
+        certPath: string;
+        keyPath: string;
+    };
+    /** Said once at startup; never a reason to refuse. */
+    warnings: string[];
+}
+export interface SecurityDeps {
+    readFile: (path: string) => Buffer;
+    stat: (path: string) => {
+        mode: number;
+        isFile(): boolean;
+    };
+    now: () => number;
+    platform: NodeJS.Platform;
+}
+/** Every problem at once, so fixing a configuration is one restart and not five. */
+export declare class SecurityRefusal extends Error {
+    readonly problems: string[];
+    constructor(problems: string[]);
+}
+/**
+ * Read the environment into a server configuration, or refuse.
+ *
+ * Pure apart from `deps`, which tests replace. `main.ts` calls it before it
+ * creates the work directory or sweeps it, so a refused start leaves nothing on
+ * disk.
+ */
+export declare function resolveSecurity(env: NodeJS.ProcessEnv, deps?: SecurityDeps): Security;
+/**
+ * The lines `main.ts` prints about how the server is reached. Never the token.
+ *
+ * THE URL MUST BE ONE THIS SERVER ANSWERS TO. On an exposed bind the `Host`
+ * allowlist is the certificate's SANs and nothing else, and the bind address is
+ * almost never one of them — `https://0.0.0.0:8475`, which this banner used to
+ * print, is a URL the server refuses with 403. So the exposed banner prints a
+ * name from the certificate and says separately what it is bound to.
+ */
+export declare function securityBanner(security: Security, port: number): string[];
+/** An environment switch. Shared with main.ts so the two cannot parse one variable two ways. */
+export declare function flag(raw: string | undefined, fallback: boolean): boolean;
+export declare function authKeys(token: string): AuthKeys;
+/**
+ * Compare a presented token. Hashed first so both sides are 32 bytes: a length
+ * mismatch is a plain `false`, never the RangeError `timingSafeEqual` throws.
+ */
+export declare function tokenMatches(keys: AuthKeys, presented: string): boolean;
+/**
+ * The token in an `Authorization` header, or null when the header is anything
+ * but `Bearer <token>` — Basic, an empty Bearer, a second parameter. The scheme
+ * is case-insensitive (RFC 9110 §11.1).
+ */
+export declare function bearerOf(header: string): string | null;
+/**
+ * The cookie's name, WITH THE PORT IN IT.
+ *
+ * `__Host-` over TLS: the browser then refuses the cookie unless it is `Secure`,
+ * `Path=/` and has no `Domain`, so nothing on a sibling host can plant or read
+ * it. Plain loopback cannot use the prefix, which requires `Secure`.
+ *
+ * THE PORT IS IN THE NAME BECAUSE COOKIES HAVE NO PORT. RFC 6265 §1 says so
+ * outright: `127.0.0.1:8475` and `127.0.0.1:9000` share one jar. Without the
+ * suffix a second DeckSmith on this host overwrites the first one's cookie and
+ * the viewer is silently logged out of it — and, since both derive the same key
+ * from the same token file, each would have accepted the other's session as its
+ * own. Neither happens now.
+ *
+ * IT IS NOT CONFIDENTIALITY. The browser still SENDS this cookie to every
+ * listener on the host, whatever the name; scoping only stops them colliding and
+ * stops one server honouring another's session. See `sessionBinding`.
+ */
+export declare function cookieName(tls: boolean, port: number): string;
+/**
+ * What a session is valid FOR: this bind and this port, inside the MAC.
+ *
+ * The cookie name keeps two instances' cookies apart in the browser. This keeps
+ * them apart in the server: a session minted by the instance on :8475 fails the
+ * MAC on :9000 even though both derived `sessionKey` from the same token file,
+ * so a second instance cannot be logged into with the first one's cookie.
+ */
+export declare function sessionBinding(host: string, port: number): string;
+/**
+ * A session is `<exp>.<mac>`, stateless: a restart keeps every browser logged
+ * in, which is what "Run it again" after a restart needs. Revocation is
+ * rotating the token file, because the key is derived from it — POST /logout
+ * clears the browser's copy and nothing else, so a value captured before it
+ * stays good until `exp`.
+ */
+export declare function mintSession(keys: AuthKeys, nowMs: number, bind: string): string;
+export declare function sessionValid(keys: AuthKeys, value: string, nowMs: number, bind: string): boolean;
+/** Every value of cookie `name`. Several may arrive; the caller accepts any valid one. */
+export declare function cookieValues(header: string | undefined, name: string): string[];
+export declare function sessionCookie(name: string, value: string, tls: boolean): string;
+export declare function clearedCookie(name: string, tls: boolean): string;

package/dist/types/server/http.d.ts

@@ -1,4 +1,6 @@
 import { type Server } from "node:http";
+import { type Server as TlsServer } from "node:https";
+import { type AuthKeys, type TlsMaterial } from "./auth.js";
 import { type PipelineInput } from "./pipeline.js";
 import { type JobHandle, type JobResult, Queue } from "./queue.js";
 export interface ServeOptions {
@@ -24,9 +26,27 @@ export interface ServeOptions {
      * Same seam, and the same reason, as `Runner` in src/plan/codex.ts.
      */
     run?: (job: JobHandle, input: PipelineInput) => Promise<JobResult>;
+    /**
+     * Require the token. Built from DECKSMITH_TOKEN_FILE by `resolveSecurity` in
+     * ./auth.ts; absent, the server behaves as it did before tokens existed.
+     */
+    auth?: AuthKeys;
+    /**
+     * Serve https. On a bind that is not loopback the certificate's SANs are the
+     * names the server answers to.
+     */
+    tls?: TlsMaterial;
+    /** The clock sessions and the failed-token limiter read. Injected by tests. */
+    now?: () => number;
+    /**
+     * TEST SEAM ONLY. `false` drops the anti-framing headers every non-deck
+     * response carries, so the browser test can show what they stop. Nothing in
+     * src/ passes it.
+     */
+    frameHeaders?: boolean;
 }
 export declare function createDeckServer(opts: ServeOptions): {
-    server: Server;
+    server: Server | TlsServer;
     queue: Queue;
 };
 /**
@@ -54,4 +74,11 @@ export declare class RateLimiter {
     private readonly now;
     constructor(limit: number, windowMs: number, now?: () => number);
     take(key: string): boolean;
+    /**
+     * Whether `take` would refuse, without spending anything. The failed-token
+     * limiter asks this BEFORE comparing, so an exhausted budget refuses a correct
+     * token too and the comparison stops being an oracle; it `take`s only after a
+     * comparison fails.
+     */
+    blocked(key: string): boolean;
 }

package/dist/types/server/ui.d.ts

@@ -5,5 +5,11 @@
  * once per call and a server that hot-reloads a theme picks the change up
  * without a module cache dance. It is a few hundred microseconds of string
  * concatenation against a request that will take two minutes to satisfy.
+ *
+ * `auth` puts a logout form in the header. It is a plain form so it works
+ * without script, and it is only there when the server has a token to log out
+ * of — http.ts caches one page per mode.
  */
-export declare function uiPage(): string;
+export declare function uiPage(opts?: {
+    auth?: boolean;
+}): string;

package/dist/types/types.d.ts

@@ -1650,8 +1650,29 @@ export declare const segmentSchema: z.ZodObject<{
         text: z.ZodString;
     }, z.core.$strip>>;
 }, z.core.$strip>;
+/**
+ * The canvas a narration's sentences were split against. Recorded so a refusal
+ * can say where the narration was staged and which `narrate` flags stage it
+ * where the build is; it is NOT what is compared. See `assertNarrationStaging`
+ * in src/narrate/narrate.ts.
+ */
+export declare const narrationCanvasSchema: z.ZodObject<{
+    format: z.ZodString;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    captionReserve: z.ZodNumber;
+}, z.core.$strip>;
+export type NarrationCanvas = z.infer<typeof narrationCanvasSchema>;
 export declare const narrationSchema: z.ZodObject<{
     voice: z.ZodString;
+    canvas: z.ZodOptional<z.ZodObject<{
+        format: z.ZodString;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        captionReserve: z.ZodNumber;
+    }, z.core.$strip>>;
+    stops: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    speakingStops: z.ZodOptional<z.ZodNumber>;
     beats: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
         stop: z.ZodInt;
         text: z.ZodString;
@@ -2355,6 +2376,14 @@ export declare const packSchema: z.ZodObject<{
     }, z.core.$strip>;
     narration: z.ZodOptional<z.ZodObject<{
         voice: z.ZodString;
+        canvas: z.ZodOptional<z.ZodObject<{
+            format: z.ZodString;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            captionReserve: z.ZodNumber;
+        }, z.core.$strip>>;
+        stops: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        speakingStops: z.ZodOptional<z.ZodNumber>;
         beats: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
             stop: z.ZodInt;
             text: z.ZodString;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jokerized/decksmith",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "Turn a source document into an animated explanation deck.",
   "type": "module",
   "license": "MIT",