@plaintake/scenario 1.2.1

package/dist/schema/errors.d.ts

@@ -0,0 +1,20 @@
+export declare const EXIT_CODES: {
+    readonly ok: 0;
+    readonly assertion: 1;
+    readonly usage: 2;
+    readonly toolchain: 3;
+    readonly capture: 4;
+    readonly render: 5;
+    readonly verification: 6;
+};
+export type FailureKind = Exclude<keyof typeof EXIT_CODES, 'ok'>;
+/**
+ * Satisfies the structural exit-code contract: any thrown error carrying a numeric
+ * `exitCode` maps to that process exit code.
+ */
+export declare class DemoError extends Error {
+    readonly kind: FailureKind;
+    readonly exitCode: number;
+    readonly details: Record<string, unknown>;
+    constructor(kind: FailureKind, message: string, details?: Record<string, unknown>);
+}

package/dist/schema/event.d.ts

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+export declare const DemoEventTypeSchema: z.ZodEnum<{
+    "session.start": "session.start";
+    "session.finish": "session.finish";
+    chapter: "chapter";
+    "step.start": "step.start";
+    "step.finish": "step.finish";
+    "assertion.pass": "assertion.pass";
+    "assertion.fail": "assertion.fail";
+    "privacy.mask": "privacy.mask";
+    "human.wait": "human.wait";
+}>;
+export declare const TargetSchema: z.ZodObject<{
+    role: z.ZodOptional<z.ZodString>;
+    accessibleName: z.ZodOptional<z.ZodString>;
+    selector: z.ZodOptional<z.ZodString>;
+    rect: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const DemoEventSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"agent-demo.event/v1">;
+    seq: z.ZodNumber;
+    tStartNs: z.ZodString;
+    tEndNs: z.ZodOptional<z.ZodString>;
+    type: z.ZodEnum<{
+        "session.start": "session.start";
+        "session.finish": "session.finish";
+        chapter: "chapter";
+        "step.start": "step.start";
+        "step.finish": "step.finish";
+        "assertion.pass": "assertion.pass";
+        "assertion.fail": "assertion.fail";
+        "privacy.mask": "privacy.mask";
+        "human.wait": "human.wait";
+    }>;
+    stableId: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    subtitle: z.ZodOptional<z.ZodString>;
+    target: z.ZodOptional<z.ZodObject<{
+        role: z.ZodOptional<z.ZodString>;
+        accessibleName: z.ZodOptional<z.ZodString>;
+        selector: z.ZodOptional<z.ZodString>;
+        rect: z.ZodOptional<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type DemoEvent = z.infer<typeof DemoEventSchema>;
+export type DemoEventType = z.infer<typeof DemoEventTypeSchema>;
+export type Target = z.infer<typeof TargetSchema>;

package/dist/schema/index.d.ts

@@ -0,0 +1,9 @@
+export * from './errors.js';
+export * from './event.js';
+export * from './json-schema.js';
+export * from './manifest.js';
+export * from './render-plan.js';
+export * from './results.js';
+export * from './scenario.js';
+export * from './stable-json.js';
+export * from './zod-format.js';

package/dist/schema/json-schema.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The published counterpart to `ScenarioMetaSchema`, for an agent or IDE that wants to
+ * validate scenario metadata without this package's source or a running `demo_validate`.
+ *
+ * `io: 'input'` on purpose: a scenario author never supplies `handoff`, `handoffTimeoutMs` or
+ * `allowedConsoleErrors`, so the schema a caller validates *against* must mark them optional,
+ * even though `ScenarioMeta` (the parsed *output* type) always carries them.
+ */
+export declare function scenarioJsonSchema(): Record<string, unknown>;

package/dist/schema/manifest.d.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+export declare const BundleManifestSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"agent-demo.bundle/v1">;
+    status: z.ZodEnum<{
+        passed: "passed";
+        failed: "failed";
+    }>;
+    scenario: z.ZodObject<{
+        id: z.ZodString;
+        sourceSha256: z.ZodString;
+    }, z.core.$strip>;
+    toolchain: z.ZodObject<{
+        node: z.ZodString;
+        playwright: z.ZodString;
+        chromiumRevision: z.ZodString;
+        ffmpeg: z.ZodString;
+        libass: z.ZodString;
+        fontSha256: z.ZodString;
+        containerImage: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    environment: z.ZodObject<{
+        os: z.ZodString;
+        architecture: z.ZodString;
+        locale: z.ZodLiteral<"en-US">;
+        timezone: z.ZodLiteral<"UTC">;
+        viewport: z.ZodTuple<[z.ZodLiteral<1920>, z.ZodLiteral<1080>], null>;
+        deviceScaleFactor: z.ZodLiteral<1>;
+    }, z.core.$strip>;
+    assertions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+        }>;
+    }, z.core.$strip>>;
+    artifacts: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        sha256: z.ZodString;
+        bytes: z.ZodNumber;
+        role: z.ZodEnum<{
+            source: "source";
+            derived: "derived";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type BundleManifest = z.infer<typeof BundleManifestSchema>;

package/dist/schema/render-plan.d.ts

@@ -0,0 +1,454 @@
+import { z } from 'zod';
+export declare const CueSchema: z.ZodObject<{
+    id: z.ZodString;
+    startMs: z.ZodNumber;
+    endMs: z.ZodNumber;
+    lines: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * The closing credit card. Absent means no card, which is a Pro-Tier-only outcome.
+ *
+ * This lives in the **plan**, not in a licence check inside the renderer, and that is the
+ * single most important thing about it. The plan is built once, when the bundle is
+ * created, from the licence state at that moment; rendering then executes it verbatim. So
+ * a bundle produces the same bytes on a licensed and an unlicensed machine, and
+ * `compareRenders`, `refreshManifestArtifacts` and every reproducibility claim keep
+ * holding. Reading licence state at render time would have voided all of them.
+ *
+ * The colour regexes are also the injection guard: these values reach an FFmpeg
+ * filtergraph, and on the Pro Tier they come from user configuration. `#RRGGBB` admits no
+ * filtergraph metacharacter. The *text* never reaches the filtergraph at all — it goes
+ * into `captions/outro.ass`.
+ */
+export declare const OutroSchema: z.ZodObject<{
+    durationMs: z.ZodNumber;
+    lines: z.ZodArray<z.ZodString>;
+    backgroundColor: z.ZodString;
+    textColor: z.ZodString;
+    assPath: z.ZodLiteral<"captions/outro.ass">;
+}, z.core.$strip>;
+export type Outro = z.infer<typeof OutroSchema>;
+/**
+ * The opening card. Absent means the video starts on the recording, which is what every
+ * plan before this did and what any scenario declaring no `intro` still does.
+ *
+ * Structurally the outro's twin, and frozen for the same reason: the plan is built once,
+ * when the bundle is created, and rendering executes it verbatim. The colour regexes carry
+ * the same duty here — these values reach an FFmpeg filtergraph and `#RRGGBB` admits no
+ * metacharacter, while the *text* never goes near it and lands in `captions/intro.ass`.
+ *
+ * What differs is upstream, not here: the outro's content is decided by the licence, the
+ * intro's by the scenario. By the time either reaches the plan that distinction is spent —
+ * both are just a card to draw.
+ *
+ * The spoken hook is **not** in this schema. It is synthesised at record time into
+ * `speech/clips/intro.wav` like any step's narration, and reaches the render through
+ * `speech` with every other clip. A plan that carried the text would be a plan whose
+ * rendering depended on a voice model being installed.
+ */
+export declare const IntroSchema: z.ZodObject<{
+    durationMs: z.ZodNumber;
+    lines: z.ZodArray<z.ZodString>;
+    backgroundColor: z.ZodString;
+    textColor: z.ZodString;
+    assPath: z.ZodLiteral<"captions/intro.ass">;
+}, z.core.$strip>;
+export type Intro = z.infer<typeof IntroSchema>;
+/**
+ * One MP4 chapter marker. `endMs` is stored rather than derived from the next mark, so
+ * `render/chapters.ffmetadata` is a pure function of the plan and nothing is recomputed at
+ * render time — the same reason `ffmpeg` holds literal argument arrays.
+ */
+export declare const ChapterMarkSchema: z.ZodObject<{
+    startMs: z.ZodNumber;
+    endMs: z.ZodNumber;
+    title: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Chapter markers. Only ever produced on the Pro Tier — but nothing here knows that,
+ * and that is the point: the tier decision is taken once when the bundle is created, and the
+ * renderer executes what it finds.
+ *
+ * Unlike the outro's colours, chapter titles are arbitrary scenario text and cannot be
+ * restricted to a safe character set. They never reach a filtergraph — they go into
+ * `render/chapters.ffmetadata`, which is passed as an `-i` input and where `=`, `;`, `#`,
+ * `\` and newline are backslash-escaped.
+ */
+export declare const ChaptersSchema: z.ZodObject<{
+    metadataPath: z.ZodLiteral<"render/chapters.ffmetadata">;
+    marks: z.ZodArray<z.ZodObject<{
+        startMs: z.ZodNumber;
+        endMs: z.ZodNumber;
+        title: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Chapters = z.infer<typeof ChaptersSchema>;
+export type ChapterMark = z.infer<typeof ChapterMarkSchema>;
+/**
+ * One point on the cursor track. `x`/`y` are the centre of the step's `target`
+ * rect, in PlayRes (= viewport) pixels, so the same coordinates libass will draw at.
+ * `arriveMs` is when the cursor reaches the point — no later than the step's start, and
+ * pulled earlier for clicks so the arrow is parked and visible before it ripples — and
+ * `departMs` is when it may leave for the next point, pulled back from the step's finish
+ * to leave the glide room. `rippleMs` is when a click's ripple *starts*: the step's own
+ * start minus a measured 200ms lead, so the ripple is visibly under way before the
+ * screen the click changes — the step start rather than the action end because whatever
+ * `run()` awaits after the click is the change itself. Present only on `action: 'click'`
+ * points.
+ *
+ * Like chapter marks, these are stored rather than re-derived from `events/events.ndjson`
+ * at render time, so `captions/cursor.ass` is a pure function of the plan — which is also
+ * why retiming the derivation was not a compatibility event at all: an older reader
+ * executes the same frozen numbers over the same frozen ASS.
+ */
+export declare const CursorPointSchema: z.ZodObject<{
+    id: z.ZodString;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    arriveMs: z.ZodNumber;
+    departMs: z.ZodNumber;
+    action: z.ZodEnum<{
+        type: "type";
+        click: "click";
+        point: "point";
+    }>;
+    rippleMs: z.ZodOptional<z.ZodNumber>;
+    scale: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const CursorSchema: z.ZodObject<{
+    assPath: z.ZodLiteral<"captions/cursor.ass">;
+    points: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        arriveMs: z.ZodNumber;
+        departMs: z.ZodNumber;
+        action: z.ZodEnum<{
+            type: "type";
+            click: "click";
+            point: "point";
+        }>;
+        rippleMs: z.ZodOptional<z.ZodNumber>;
+        scale: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Cursor = z.infer<typeof CursorSchema>;
+export type CursorPoint = z.infer<typeof CursorPointSchema>;
+/**
+ * One camera window over the source frame. `enterMs` is when the ease INTO this
+ * shot starts; `holdFromMs` is when that ease ends and the shot is held. The window is
+ * then constant until the next shot's `enterMs`, which is why the list must *tile* the
+ * timeline rather than merely sort.
+ */
+export declare const CameraShotSchema: z.ZodObject<{
+    id: z.ZodString;
+    enterMs: z.ZodNumber;
+    holdFromMs: z.ZodNumber;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    w: z.ZodNumber;
+    h: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * The camera. A shot **list**, not frame-sampled
+ * keyframes: keyframing the window at 30 fps would add ~190 KB to a plan that is
+ * currently ~3 KB, for windows that hold constant for whole seconds. `render/camera.cmd`
+ * is generated from these shots at plan-freeze time and then frozen like every other
+ * command array, so the renderer stays a pure executor of arguments it does not
+ * recompute.
+ *
+ * The geometry rules below are measured, not stylistic (M10): on `yuv420p`, FFmpeg
+ * silently masks odd crop geometry down by a pixel, so a plan freezing an odd `x`/`y`/
+ * `w`/`h` would render a window different from the one it froze — the schema rejects
+ * loudly instead. `w % 32` is not a separate alignment rule: with `h` pinned to `9w/16`
+ * and 9 odd, `h` is even exactly when `w` is a multiple of 32, so it *is* the even-height
+ * rule, expressed on `w`. The ladder it implies — windows step down 1920, 1888, 1856, …,
+ * one rung ≈ 1.7% of zoom — is the measured granularity of the feature, not an accident
+ * to be trimmed.
+ */
+export declare const CameraSchema: z.ZodObject<{
+    commandPath: z.ZodLiteral<"render/camera.cmd">;
+    shots: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        enterMs: z.ZodNumber;
+        holdFromMs: z.ZodNumber;
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        w: z.ZodNumber;
+        h: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Camera = z.infer<typeof CameraSchema>;
+export type CameraShot = z.infer<typeof CameraShotSchema>;
+/**
+ * One frozen narration clip and where it lands on the timeline.
+ *
+ * `durationMs` is stored rather than measured from the file, for the reason chapter marks
+ * store their own `endMs`: it makes `speech/narration.wav` a pure function of the plan, so
+ * nothing is re-derived at render time. It is also the number the *timeline* was built from
+ * — the recorder held the step open for it — so a file whose length disagrees means the
+ * bundle was edited after it was frozen, which is worth failing on rather than papering over.
+ *
+ * `source` distinguishes a synthesised clip from an author-supplied WAV, because they are the
+ * same bytes by the time they reach here and the distinction is not otherwise recoverable.
+ */
+export declare const SpeechClipSchema: z.ZodObject<{
+    id: z.ZodString;
+    path: z.ZodString;
+    atMs: z.ZodNumber;
+    durationMs: z.ZodNumber;
+    source: z.ZodEnum<{
+        file: "file";
+        synth: "synth";
+    }>;
+}, z.core.$strip>;
+/**
+ * What produced the synthesised clips. Evidence only — nothing reads it to make a decision,
+ * exactly as `source.durationMs` is evidence only.
+ *
+ * It earns its place because it is the answer to the one question a frozen audio track cannot
+ * otherwise answer: *this bundle sounds different from that one, why?* The voice, the model
+ * bytes and the engine version are the three things that can change it, and none of them is
+ * recoverable from the WAV.
+ *
+ * Absent when every clip came from a file, which is why it is optional rather than filled
+ * with placeholders — an author-supplied voiceover has no model hash, and inventing one
+ * ("unknown", `0`.repeat(64)) would make the field lie in the one case it exists to explain.
+ */
+export declare const SpeechEngineSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    modelSha256: z.ZodString;
+    voice: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Spoken narration. Absent means a silent video, which is every plan before this and
+ * the default after it.
+ *
+ * The clips are frozen *and* the mixed track is frozen. That is one more file than strictly
+ * needed, and it is deliberate: the clips are what the timeline was derived from — each one's
+ * length set its step's hold — so keeping them makes the bundle self-explanatory and lets
+ * `verify` hash them, while the mixed track is what FFmpeg muxes. Regenerating the mix from
+ * the clips is pure integer arithmetic (`narration.ts`), so the two can never disagree, and
+ * `renderBundle` reads the mix without regenerating anything.
+ */
+export declare const SpeechSchema: z.ZodObject<{
+    trackPath: z.ZodLiteral<"speech/narration.wav">;
+    sampleRate: z.ZodLiteral<24000>;
+    channels: z.ZodLiteral<1>;
+    clips: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        path: z.ZodString;
+        atMs: z.ZodNumber;
+        durationMs: z.ZodNumber;
+        source: z.ZodEnum<{
+            file: "file";
+            synth: "synth";
+        }>;
+    }, z.core.$strip>>;
+    engine: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+        modelSha256: z.ZodString;
+        voice: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Speech = z.infer<typeof SpeechSchema>;
+export type SpeechClip = z.infer<typeof SpeechClipSchema>;
+/**
+ * The speech decision as the application layer supplies it; `trackPath`, `sampleRate` and
+ * `channels` are filled in by `buildRenderPlan`, exactly as `OutroInput` works.
+ */
+export type SpeechInput = Omit<Speech, 'trackPath' | 'sampleRate' | 'channels'>;
+/** The cursor decision as the application layer supplies it; `assPath` is filled in by
+ * `buildRenderPlan`, exactly as `OutroInput` and `ChaptersInput` work. */
+export type CursorInput = Omit<Cursor, 'assPath'>;
+/** The chapter decision as the application layer supplies it; `metadataPath` is filled in
+ * by `buildRenderPlan`, exactly as `OutroInput` works. */
+export type ChaptersInput = {
+    marks: ChapterMark[];
+};
+/** The camera decision as the application layer supplies it; `commandPath` is filled in
+ * by `buildRenderPlan`, exactly as `CursorInput` and `ChaptersInput` work. */
+export type CameraInput = Omit<Camera, 'commandPath'>;
+/**
+ * The branding decision as the application layer supplies it: everything about the card
+ * except where its ASS file lives, which `buildRenderPlan` fills in. Declared here rather
+ * than in the renderer so that `@plaintake/license` can produce one without depending
+ * on the render path — the direction `renderer-no-license` forbids.
+ */
+export type OutroInput = Omit<Outro, 'assPath'>;
+/** The opening card as the application layer supplies it, exactly as `OutroInput` works. */
+export type IntroInput = Omit<Intro, 'assPath'>;
+/**
+ * The one value a plan's `schema` field ever holds.
+ *
+ * The field names the *document kind* — it is what makes a manifest or a result envelope
+ * handed to the renderer fail at the parse instead of three frames into an encode. The
+ * `/v1` suffix is frozen, not incremented: capabilities are stated by the plan's own
+ * optional fields, which is where they always were.
+ */
+export declare const RENDER_PLAN_SCHEMA = "agent-demo.render/v1";
+/**
+ * The frozen render contract. `ffmpeg` holds the exact argument arrays, which is what
+ * makes re-rendering a bundle bit-for-bit repeatable without re-deriving anything.
+ *
+ * **The version ladder this schema once carried has been retired.** It ran `/v1` (nothing) → `/v2`
+ * (outro) → `/v3` (chapters) → `/v4` (cursor) → `/v5` (camera), each rung the highest
+ * capability a plan used, stamped by `declaredVersion` and cross-checked by a refinement.
+ * Three things were wrong with it, and the third is why it went:
+ *
+ * 1. **It carried no information.** `declaredVersion` was a pure function of `outro`,
+ *    `chapters`, `cursor` and `camera` — fields sitting in the same object — and the
+ *    refinement asserted the stamp equalled that function. So the field was a cache of a
+ *    derivation over its own neighbours, and the refinement was the cache-coherence check.
+ *    `plan.camera !== undefined` is the capability test; `/v5` was a restatement of it.
+ * 2. **It encoded build order, not capability structure.** The four capabilities are
+ *    independent booleans. A single integer cannot describe sixteen combinations, so `/v5`
+ *    meant "a camera, and who knows what else" and every new feature had to become the new
+ *    top rung by definition of having been built last.
+ * 3. **It cost forward compatibility rather than buying backward compatibility.** The
+ *    backward direction — an old plan read by a new build — is carried by the fields being
+ *    `.optional()`, and always was; the version string did nothing there. The forward
+ *    direction is where the enum bit: `renderBundle` executes `plan.ffmpeg[variant]`
+ *    verbatim and never regenerates the derived files, so a bundle from a newer build
+ *    would have rendered *correctly* on an older one — the frozen arguments already name
+ *    every input, and the files they name are already in the bundle. The enum refused it
+ *    first. A marker justified as compatibility was the only thing preventing it.
+ *
+ * So a plan states its capabilities by carrying them. An unknown *field* is ignored, which
+ * is Zod's default and the right one — an older build ignoring `speech` still
+ * executes the frozen arguments that mux the frozen WAV. An unknown *document kind* is
+ * still rejected, because that is what the field is for.
+ *
+ * **`/v2`–`/v5` are not accepted.** They are gone rather than tolerated: this is pre-1.0
+ * software, a bundle is cheap to re-record, and a list of five strings where four exist only
+ * to be inert is the kind of thing that outlives the reason for it. A plan carrying one now
+ * fails at the parse, naming the value it should have — which is a better outcome than the
+ * ladder's, where the same bundle failed while carrying arguments that would have rendered.
+ *
+ * A plan using no optional capability remains byte-identical to what every earlier version
+ * produced, so `scripts/make-golden-bundle.sh` regenerates the committed golden bundle
+ * exactly — the version string was already `/v1` there.
+ */
+export declare const RenderPlanSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"agent-demo.render/v1">;
+    source: z.ZodObject<{
+        path: z.ZodLiteral<"raw/session.webm">;
+        sha256: z.ZodString;
+        durationMs: z.ZodNumber;
+    }, z.core.$strip>;
+    video: z.ZodObject<{
+        width: z.ZodLiteral<1920>;
+        height: z.ZodLiteral<1080>;
+        fps: z.ZodLiteral<30>;
+        pixelFormat: z.ZodLiteral<"yuv420p">;
+        durationMs: z.ZodNumber;
+        tailPadMs: z.ZodNumber;
+    }, z.core.$strip>;
+    captions: z.ZodObject<{
+        language: z.ZodString;
+        srtPath: z.ZodLiteral<"captions/captions.srt">;
+        vttPath: z.ZodLiteral<"captions/captions.vtt">;
+        assPath: z.ZodLiteral<"captions/captions.ass">;
+        cues: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            startMs: z.ZodNumber;
+            endMs: z.ZodNumber;
+            lines: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    style: z.ZodObject<{
+        fontFile: z.ZodLiteral<"assets/fonts/NotoSans-Regular.ttf">;
+        fontName: z.ZodLiteral<"Noto Sans">;
+        fontSize: z.ZodNumber;
+        textColor: z.ZodString;
+        outlineColor: z.ZodString;
+        outlineWidth: z.ZodNumber;
+        marginBottom: z.ZodNumber;
+        marginSide: z.ZodDefault<z.ZodNumber>;
+        borderStyle: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<4>]>>;
+        outlineOpacity: z.ZodDefault<z.ZodNumber>;
+        boxColor: z.ZodDefault<z.ZodString>;
+        boxOpacity: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    ffmpeg: z.ZodObject<{
+        base: z.ZodArray<z.ZodString>;
+        soft: z.ZodArray<z.ZodString>;
+        hard: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    intro: z.ZodOptional<z.ZodObject<{
+        durationMs: z.ZodNumber;
+        lines: z.ZodArray<z.ZodString>;
+        backgroundColor: z.ZodString;
+        textColor: z.ZodString;
+        assPath: z.ZodLiteral<"captions/intro.ass">;
+    }, z.core.$strip>>;
+    outro: z.ZodOptional<z.ZodObject<{
+        durationMs: z.ZodNumber;
+        lines: z.ZodArray<z.ZodString>;
+        backgroundColor: z.ZodString;
+        textColor: z.ZodString;
+        assPath: z.ZodLiteral<"captions/outro.ass">;
+    }, z.core.$strip>>;
+    chapters: z.ZodOptional<z.ZodObject<{
+        metadataPath: z.ZodLiteral<"render/chapters.ffmetadata">;
+        marks: z.ZodArray<z.ZodObject<{
+            startMs: z.ZodNumber;
+            endMs: z.ZodNumber;
+            title: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    cursor: z.ZodOptional<z.ZodObject<{
+        assPath: z.ZodLiteral<"captions/cursor.ass">;
+        points: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            arriveMs: z.ZodNumber;
+            departMs: z.ZodNumber;
+            action: z.ZodEnum<{
+                type: "type";
+                click: "click";
+                point: "point";
+            }>;
+            rippleMs: z.ZodOptional<z.ZodNumber>;
+            scale: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    camera: z.ZodOptional<z.ZodObject<{
+        commandPath: z.ZodLiteral<"render/camera.cmd">;
+        shots: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            enterMs: z.ZodNumber;
+            holdFromMs: z.ZodNumber;
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            w: z.ZodNumber;
+            h: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    speech: z.ZodOptional<z.ZodObject<{
+        trackPath: z.ZodLiteral<"speech/narration.wav">;
+        sampleRate: z.ZodLiteral<24000>;
+        channels: z.ZodLiteral<1>;
+        clips: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            atMs: z.ZodNumber;
+            durationMs: z.ZodNumber;
+            source: z.ZodEnum<{
+                file: "file";
+                synth: "synth";
+            }>;
+        }, z.core.$strip>>;
+        engine: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodString;
+            modelSha256: z.ZodString;
+            voice: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RenderPlan = z.infer<typeof RenderPlanSchema>;
+export type Cue = z.infer<typeof CueSchema>;