@skyphusion-labs/vivijure-core 0.9.0

package/dist/storyboard-validate.d.ts

@@ -0,0 +1,72 @@
+export { coerceShotId } from "./storyboard-ids.js";
+export type SlotId = "A" | "B" | "C" | "D";
+export declare const SLOT_IDS: readonly SlotId[];
+export declare const SCENE_PROMPT_MAX_WORDS = 50;
+export declare const STORYBOARD_MAX_SCENES = 50;
+export declare const FULL_PROMPT_MAX_CHARS = 1024;
+export declare const STYLE_PREFIX_MAX_CHARS = 256;
+export declare const SCENE_MAX_SECONDS = 60;
+export declare const STORYBOARD_MAX_SECONDS: number;
+export declare const DIALOGUE_MAX_CHARS = 300;
+export interface StoryboardScene {
+    id?: string;
+    prompt: string;
+    character_slots?: SlotId[];
+    start?: number;
+    end?: number;
+    target_seconds?: number;
+    act?: string;
+    start_image?: string;
+    dialogue?: {
+        slot: SlotId;
+        text: string;
+    };
+}
+export interface StoryboardInput {
+    title: string;
+    full_prompt?: string;
+    duration_seconds?: number;
+    clip_seconds?: number;
+    style_prefix?: string;
+    style_category?: string | null;
+    style_preset?: string | null;
+    use_characters?: SlotId[];
+    cast_rules?: string;
+    refs_dir?: string;
+    scenes: StoryboardScene[];
+}
+export interface StoryboardValidated {
+    title: string;
+    projectName: string;
+    full_prompt: string;
+    duration_seconds: number | undefined;
+    clip_seconds: number | undefined;
+    style_prefix: string;
+    style_category: string;
+    style_preset: string;
+    use_characters: SlotId[];
+    cast_rules: string;
+    refs_dir?: string;
+    scenes: StoryboardScene[];
+}
+export type ValidationResult = {
+    ok: true;
+    value: StoryboardValidated;
+} | {
+    ok: false;
+    errors: string[];
+};
+export declare function normalizeProjectName(title: string | undefined | null): string;
+export declare function validateStoryboard(input: unknown): ValidationResult;
+export declare function normalizePerShotModels(raw: unknown, allowedModelIds: ReadonlySet<string>): {
+    perShot: Record<string, string>;
+    errors: string[];
+};
+export declare function normalizeHybridBackends(raw: unknown, allowedModelIds: ReadonlySet<string>): {
+    backends: Record<string, {
+        backend: "gpu" | "cloud";
+        model?: string;
+    }>;
+    errors: string[];
+};
+//# sourceMappingURL=storyboard-validate.d.ts.map

package/dist/storyboard-validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storyboard-validate.d.ts","sourceRoot":"","sources":["../src/storyboard-validate.ts"],"names":[],"mappings":"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"}

package/dist/storyboard-validate.js

@@ -0,0 +1,595 @@
+// Storyboard input validator for the planning Worker (v0.27.0).
+//
+// Pure, synchronous, no I/O. Validates the structural shape of a planner
+// output before it is serialized to storyboard.yaml and bundled for the
+// vivijure-serverless GPU worker. Slot readiness (registry prompt plus
+// >=8 reference images on disk) is checked separately as a pre-flight
+// against R2; this validator does not touch the filesystem or network.
+//
+// Schema source of truth: vivijure-serverless/build/vivijure-src/
+// storyboard.example.yaml, plus what orchestrator.build_render_payload
+// and core.build_manifest in that repo actually consume. Slot IDs
+// ("A", "B", "C", "D") mirror characters.SLOTS in the same repo.
+// normalizeProjectName mirrors studio_service.norm_project.
+//
+// Minimal-dep convention (matches src/env.ts, src/longrun-params.ts):
+// hand-authored interfaces, no zod / ajv at runtime, no codegen.
+import { isSafeRelKey, sanitizeKeySegment } from "./key-safety.js";
+export { coerceShotId } from "./storyboard-ids.js";
+import { coerceShotId } from "./storyboard-ids.js";
+export const SLOT_IDS = ["A", "B", "C", "D"];
+const SLOT_SET = new Set(SLOT_IDS);
+// v0.80.0: content-shape guards that the GPU renderer relies on but the
+// structural validator (lines below) historically did not enforce.
+// These caps protect downstream paths from LLM Assist outputs that pass
+// the structural schema but break renderer constraints. See the audit
+// memo for the four gaps these close.
+//
+// SCENE_PROMPT_MAX_TOKENS: SDXL's CLIP-L and OpenCLIP-G text encoders
+// each cap at 77 tokens. Diffusers silently truncates above that. The
+// pod's regional path prepends 2-4 trigger tokens + ~10 style_prefix
+// tokens, leaving ~60 tokens of scene-prompt budget before truncation
+// starts dropping setting clauses. Word-to-token ratio for English in
+// the BPE tokenizers SDXL uses is ~1.3 tokens per word, so the word
+// count check uses 60 / 1.3 = ~46 words. We round to 50 with a small
+// margin and surface the offending scene + word count in the error.
+export const SCENE_PROMPT_MAX_WORDS = 50;
+// Hard cap on scenes per storyboard. The pod's max_scenes default is
+// 100; below 50 is the preflight comfort zone. A 50-scene render with
+// Wan I2V at ~30s per shot is already ~25 minutes of GPU time, beyond
+// which RunPod's per-job timeout starts mattering more than schema.
+export const STORYBOARD_MAX_SCENES = 50;
+// Length caps on the two top-level free-text strings the renderer
+// reads at manifest-build time. style_prefix is what the pod's 0.4.38
+// background_prompt() now leans on - an LLM Assist style_prefix > 256
+// chars would itself overflow CLIP 77 even before any scene-prompt
+// tokens are added.
+export const FULL_PROMPT_MAX_CHARS = 1024;
+export const STYLE_PREFIX_MAX_CHARS = 256;
+// Per-shot and total duration caps. A shot's render cost is ~linear in its seconds
+// (Wan I2V), so an LLM Assist storyboard with a 600s shot, or a huge duration_seconds,
+// becomes real GPU minutes that pass the structural schema. Cap a single shot at 60s
+// (well past any one i2v clip the model makes) and the whole film at scenes x per-shot.
+export const SCENE_MAX_SECONDS = 60;
+export const STORYBOARD_MAX_SECONDS = STORYBOARD_MAX_SCENES * SCENE_MAX_SECONDS;
+// Per-shot dialogue line cap. The line is voiced by Deepgram Aura-1 (billed per 1k chars) and a
+// shot lip-syncs one spoken line, so this bounds both TTS cost and how much speech must fit a clip.
+// 300 chars is ~20s of speech, well past any single-shot line, while staying firmly bounded.
+export const DIALOGUE_MAX_CHARS = 300;
+// Scene-id format the renderer expects (core.py shot manifest looks up
+// scenes by this id). LLM Assist outputs like "scene_dramatic_sunset"
+// silently break downstream tools that expect the shot_NN pattern.
+// Coerce rather than reject so the LLM doesn't have to know the format;
+// the validator renumbers in declaration order.
+function countWords(prompt) {
+    return prompt.trim().split(/\s+/).filter((w) => w.length > 0).length;
+}
+// studio_service.norm_project (vivijure-serverless studio_service.py):
+//   return (name or "project").strip().replace(" ", "_") or "project"
+// Collapses internal whitespace runs (\s+) rather than only literal
+// spaces, since YAML parsers can hand us tabs or other whitespace too.
+export function normalizeProjectName(title) {
+    const raw = typeof title === "string" ? title : "";
+    const slug = raw.trim().replace(/\s+/g, "_");
+    // Guarantee a path-safe single segment: a hostile title (".." , "a/b", "x://y") otherwise reaches
+    // bundles/<projectName>.tar.gz and could steer the key off-bucket. Normal titles (letters, digits,
+    // _ . -) are unchanged, so the value stays in sync with the backend `project` field. (security #6)
+    return sanitizeKeySegment(slug, "project");
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPositiveFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function isNonNegativeFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function describeType(value) {
+    if (value === null)
+        return "null";
+    if (Array.isArray(value))
+        return "array";
+    return typeof value;
+}
+function sceneLabel(scene, index) {
+    const id = typeof scene.id === "string" && scene.id.trim().length > 0
+        ? scene.id.trim()
+        : null;
+    return id ? `scenes[${index}] (id="${id}")` : `scenes[${index}]`;
+}
+// missing / null / empty / whitespace-only collapse to "None" (the literal
+// string the renderer treats as "no style lookup"). Non-string types
+// silently collapse too; the planner's TypeScript types disallow them at
+// authoring time, so reaching this branch at runtime is a programmer
+// error worth defending against rather than rejecting.
+function normalizeStyleNone(value) {
+    if (typeof value !== "string")
+        return "None";
+    const trimmed = value.trim();
+    return trimmed.length === 0 ? "None" : trimmed; // return the trimmed value, not the raw (issue #17)
+}
+// ---- validateStoryboard, decomposed (S6 split) -----------------------------------------------
+// One section, one function; every error message and check moved VERBATIM from the former
+// 455-line body, so behavior (and the tests pinning these strings) is unchanged. Each helper
+// pushes into the shared `errors` and returns its validated slice.
+function validateTitleSection(input, errors) {
+    let title = "";
+    let projectName = "project";
+    const rawTitle = input.title;
+    if (typeof rawTitle !== "string" || rawTitle.trim().length === 0) {
+        errors.push("title is required and must be a non-empty string");
+    }
+    else {
+        title = rawTitle;
+        projectName = normalizeProjectName(rawTitle);
+    }
+    return { title, projectName };
+}
+function validateUseCharactersSection(input, errors) {
+    const useCharacters = [];
+    if (input.use_characters !== undefined) {
+        if (!Array.isArray(input.use_characters)) {
+            errors.push(`use_characters must be an array of slot ids if provided (got ${describeType(input.use_characters)})`);
+        }
+        else {
+            const seen = new Set();
+            input.use_characters.forEach((slot, i) => {
+                if (typeof slot !== "string") {
+                    errors.push(`use_characters[${i}] must be a string (got ${describeType(slot)})`);
+                    return;
+                }
+                if (!SLOT_SET.has(slot)) {
+                    errors.push(`use_characters[${i}] = "${slot}" is not a valid slot id (allowed: ${SLOT_IDS.join(", ")})`);
+                    return;
+                }
+                if (seen.has(slot)) {
+                    errors.push(`use_characters[${i}] = "${slot}" is duplicated`);
+                    return;
+                }
+                seen.add(slot);
+                useCharacters.push(slot);
+            });
+        }
+    }
+    return useCharacters;
+}
+// scenes[i].character_slots: optional array of SlotId, must be a subset of use_characters.
+function validateSceneSlots(scene, label, useCharacters, out, errors) {
+    if (scene.character_slots !== undefined) {
+        if (!Array.isArray(scene.character_slots)) {
+            errors.push(`${label} character_slots must be an array if provided (got ${describeType(scene.character_slots)})`);
+        }
+        else {
+            const slotsOut = [];
+            const seenLocal = new Set();
+            scene.character_slots.forEach((slot, j) => {
+                if (typeof slot !== "string") {
+                    errors.push(`${label} character_slots[${j}] must be a string (got ${describeType(slot)})`);
+                    return;
+                }
+                if (!SLOT_SET.has(slot)) {
+                    errors.push(`${label} character_slots[${j}] = "${slot}" is not a valid slot id (allowed: ${SLOT_IDS.join(", ")})`);
+                    return;
+                }
+                if (seenLocal.has(slot)) {
+                    errors.push(`${label} character_slots[${j}] = "${slot}" is duplicated within the scene`);
+                    return;
+                }
+                // Subset rule: every per-scene slot must be loaded for the render.
+                if (!useCharacters.includes(slot)) {
+                    const loaded = useCharacters.length > 0 ? useCharacters.join(", ") : "(none)";
+                    errors.push(`${label} character_slots references slot "${slot}" which is not in use_characters (loaded: ${loaded})`);
+                    return;
+                }
+                seenLocal.add(slot);
+                slotsOut.push(slot);
+            });
+            out.character_slots = slotsOut;
+        }
+    }
+}
+// dialogue: optional { slot, text }. The speaker must be in this shot (one of its validated
+// character_slots, which already enforces the use_characters subset rule), and the line is a
+// non-empty string capped to bound TTS cost + how much speech must fit the clip.
+function validateSceneDialogue(scene, label, out, errors) {
+    if (scene.dialogue !== undefined) {
+        if (!isPlainObject(scene.dialogue)) {
+            errors.push(`${label} dialogue must be an object { slot, text } if provided (got ${describeType(scene.dialogue)})`);
+        }
+        else {
+            const dlgSlot = scene.dialogue.slot;
+            const dlgText = scene.dialogue.text;
+            let slotOk = false;
+            if (typeof dlgSlot !== "string" || !SLOT_SET.has(dlgSlot)) {
+                errors.push(`${label} dialogue.slot must be a valid slot id (allowed: ${SLOT_IDS.join(", ")})`);
+            }
+            else if (!(out.character_slots ?? []).includes(dlgSlot)) {
+                errors.push(`${label} dialogue.slot "${dlgSlot}" must be one of this shot's character_slots (the speaker has to be in the shot)`);
+            }
+            else {
+                slotOk = true;
+            }
+            let textOk = false;
+            if (typeof dlgText !== "string" || dlgText.trim().length === 0) {
+                errors.push(`${label} dialogue.text must be a non-empty string`);
+            }
+            else if (dlgText.length > DIALOGUE_MAX_CHARS) {
+                errors.push(`${label} dialogue.text is ${dlgText.length} chars; cap is ${DIALOGUE_MAX_CHARS} (one spoken line per shot)`);
+            }
+            else {
+                textOk = true;
+            }
+            if (slotOk && textOk) {
+                out.dialogue = { slot: dlgSlot, text: dlgText.trim() };
+            }
+        }
+    }
+}
+// start / end / target_seconds + the cross-field span rule (per-shot GPU-billing caps).
+function validateSceneTiming(scene, label, out, errors) {
+    // start: optional non-negative number (0.0 is a legal film-time origin)
+    if (scene.start !== undefined) {
+        if (!isNonNegativeFiniteNumber(scene.start)) {
+            errors.push(`${label} start must be a non-negative finite number if provided`);
+        }
+        else {
+            out.start = scene.start;
+        }
+    }
+    // end: optional positive film-time position (absolute, not a duration, so no cap)
+    if (scene.end !== undefined) {
+        if (!isPositiveFiniteNumber(scene.end)) {
+            errors.push(`${label} end must be a positive finite number if provided`);
+        }
+        else {
+            out.end = scene.end;
+        }
+    }
+    // target_seconds: optional positive per-shot DURATION, capped so one shot cannot
+    // bill an unbounded GPU render.
+    if (scene.target_seconds !== undefined) {
+        if (!isPositiveFiniteNumber(scene.target_seconds)) {
+            errors.push(`${label} target_seconds must be a positive finite number if provided`);
+        }
+        else if (scene.target_seconds > SCENE_MAX_SECONDS) {
+            errors.push(`${label} target_seconds is ${scene.target_seconds}s; cap is ${SCENE_MAX_SECONDS}s per shot`);
+        }
+        else {
+            out.target_seconds = scene.target_seconds;
+        }
+    }
+    // Cross-field: if both start and end are valid, end must be > start, and the
+    // span (a per-shot duration) is capped like target_seconds.
+    if (typeof out.start === "number" &&
+        typeof out.end === "number" &&
+        out.end <= out.start) {
+        errors.push(`${label} end (${out.end}) must be greater than start (${out.start})`);
+    }
+    else if (typeof out.start === "number" &&
+        typeof out.end === "number" &&
+        out.end - out.start > SCENE_MAX_SECONDS) {
+        errors.push(`${label} span (end - start = ${Math.round((out.end - out.start) * 100) / 100}s) exceeds the per-shot cap of ${SCENE_MAX_SECONDS}s`);
+    }
+}
+// One scene: prompt (CLIP token guard), id coercion, slots, dialogue, timing, act/start_image.
+function validateScene(scene, i, useCharacters, errors) {
+    if (!isPlainObject(scene)) {
+        errors.push(`scenes[${i}] must be an object (got ${describeType(scene)})`);
+        return null;
+    }
+    const label = sceneLabel(scene, i);
+    const out = { prompt: "" };
+    // prompt: required, non-empty after trim
+    if (typeof scene.prompt !== "string" ||
+        scene.prompt.trim().length === 0) {
+        errors.push(`${label} is missing prompt (must be a non-empty string)`);
+    }
+    else {
+        out.prompt = scene.prompt;
+        // v0.80.0: token-count guard so LLM Assist outputs that
+        // overflow SDXL's CLIP 77-token limit get caught here
+        // rather than silently truncating at render time. The pod's
+        // regional path prepends triggers + style_prefix, leaving
+        // ~60 tokens of headroom, ~46 words at 1.3 tokens/word; we
+        // cap at 50 with a small margin.
+        const wc = countWords(scene.prompt);
+        if (wc > SCENE_PROMPT_MAX_WORDS) {
+            errors.push(`${label} prompt is ${wc} words; cap is ${SCENE_PROMPT_MAX_WORDS} to fit within SDXL CLIP 77 tokens after triggers + style_prefix. Tighten the prompt or move appearance details to the cast bible.`);
+        }
+    }
+    // id: optional; v0.80.0 always coerces to the shot_NN pattern
+    // the renderer expects. LLM Assist outputs like
+    // "scene_dramatic_sunset" become "shot_NN" in declaration
+    // order. A valid scene.id like "shot_07" survives intact.
+    // Non-string ids are tolerated (coerced to the default).
+    if (scene.id !== undefined && typeof scene.id !== "string") {
+        errors.push(`${label} id must be a string if provided (got ${describeType(scene.id)})`);
+    }
+    out.id = coerceShotId(typeof scene.id === "string" ? scene.id : undefined, i);
+    validateSceneSlots(scene, label, useCharacters, out, errors);
+    validateSceneDialogue(scene, label, out, errors);
+    validateSceneTiming(scene, label, out, errors);
+    // act / start_image: optional strings. start_image is a path/key consumed downstream as an R2
+    // object, so it must be a safe relative key (no traversal / absolute / scheme). (security #6)
+    for (const key of ["act", "start_image"]) {
+        const v = scene[key];
+        if (v !== undefined) {
+            if (typeof v !== "string") {
+                errors.push(`${label} ${key} must be a string if provided (got ${describeType(v)})`);
+            }
+            else if (key === "start_image" && !isSafeRelKey(v)) {
+                errors.push(`${label} start_image must be a safe relative path (letters, digits, . _ - /, no "..", no leading "/")`);
+            }
+            else {
+                out[key] = v;
+            }
+        }
+    }
+    return out;
+}
+function validateScenesSection(input, useCharacters, errors) {
+    const validatedScenes = [];
+    if (!Array.isArray(input.scenes)) {
+        errors.push(`scenes is required and must be a non-empty array (got ${describeType(input.scenes)})`);
+    }
+    else if (input.scenes.length === 0) {
+        errors.push("scenes is required and must be a non-empty array (got empty array)");
+    }
+    else if (input.scenes.length > STORYBOARD_MAX_SCENES) {
+        // v0.80.0: hard cap on scene count. Preflight warns at 24; this
+        // is the firm ceiling. Catches LLM Assist outputs that try to
+        // produce a 100-shot epic on a draft pass.
+        errors.push(`scenes count ${input.scenes.length} exceeds the hard cap of ${STORYBOARD_MAX_SCENES} (preflight warns at 24; consider splitting the storyboard or shortening the duration)`);
+    }
+    else {
+        input.scenes.forEach((scene, i) => {
+            const out = validateScene(scene, i, useCharacters, errors);
+            if (out)
+                validatedScenes.push(out);
+        });
+    }
+    // Duplicate shot ids: coerceShotId renumbers unlabeled scenes by index, which can
+    // collide with an authored id (an explicit "shot_05" plus the 5th unlabeled scene ->
+    // two "shot_05"). core.py looks scenes up by id, so a dup silently drops a shot from
+    // the render. Reject so the collision is visible.
+    {
+        const seenIds = new Set();
+        for (const s of validatedScenes) {
+            const id = s.id;
+            if (!id)
+                continue;
+            if (seenIds.has(id)) {
+                errors.push(`duplicate shot id "${id}" (an authored id collided with an auto-numbered one; rename or renumber the scene)`);
+            }
+            else {
+                seenIds.add(id);
+            }
+        }
+    }
+    return validatedScenes;
+}
+function validateTopLevelFields(input, errors) {
+    let fullPrompt = "";
+    if (input.full_prompt !== undefined) {
+        if (typeof input.full_prompt !== "string") {
+            errors.push(`full_prompt must be a string if provided (got ${describeType(input.full_prompt)})`);
+        }
+        else if (input.full_prompt.length > FULL_PROMPT_MAX_CHARS) {
+            // v0.80.0: cap free-text length so a runaway LLM Assist
+            // synopsis can't bloat the manifest. full_prompt is read at
+            // manifest-build time on the pod.
+            errors.push(`full_prompt is ${input.full_prompt.length} chars; cap is ${FULL_PROMPT_MAX_CHARS}`);
+        }
+        else {
+            fullPrompt = input.full_prompt;
+        }
+    }
+    let stylePrefix = "";
+    if (input.style_prefix !== undefined) {
+        if (typeof input.style_prefix !== "string") {
+            errors.push(`style_prefix must be a string if provided (got ${describeType(input.style_prefix)})`);
+        }
+        else if (input.style_prefix.length > STYLE_PREFIX_MAX_CHARS) {
+            // v0.80.0: style_prefix is what the pod's 0.4.38 background_
+            // prompt() builds the bg backplate from; an LLM Assist output
+            // over 256 chars would itself overflow CLIP 77 before any
+            // scene-prompt tokens are added.
+            errors.push(`style_prefix is ${input.style_prefix.length} chars; cap is ${STYLE_PREFIX_MAX_CHARS} (the pod's bg-pass uses style_prefix verbatim and SDXL CLIP truncates at 77 tokens)`);
+        }
+        else {
+            stylePrefix = input.style_prefix;
+        }
+    }
+    let castRules = "";
+    if (input.cast_rules !== undefined) {
+        if (typeof input.cast_rules !== "string") {
+            errors.push(`cast_rules must be a string if provided (got ${describeType(input.cast_rules)})`);
+        }
+        else {
+            castRules = input.cast_rules;
+        }
+    }
+    let durationSeconds;
+    if (input.duration_seconds !== undefined) {
+        if (!isPositiveFiniteNumber(input.duration_seconds)) {
+            errors.push("duration_seconds must be a positive finite number if provided");
+        }
+        else if (input.duration_seconds > STORYBOARD_MAX_SECONDS) {
+            errors.push(`duration_seconds is ${input.duration_seconds}s; cap is ${STORYBOARD_MAX_SECONDS}s (${STORYBOARD_MAX_SCENES} shots x ${SCENE_MAX_SECONDS}s)`);
+        }
+        else {
+            durationSeconds = input.duration_seconds;
+        }
+    }
+    let clipSeconds;
+    if (input.clip_seconds !== undefined) {
+        if (!isPositiveFiniteNumber(input.clip_seconds)) {
+            errors.push("clip_seconds must be a positive finite number if provided");
+        }
+        else if (input.clip_seconds > SCENE_MAX_SECONDS) {
+            errors.push(`clip_seconds is ${input.clip_seconds}s; cap is ${SCENE_MAX_SECONDS}s per shot`);
+        }
+        else {
+            clipSeconds = input.clip_seconds;
+        }
+    }
+    let refsDir;
+    if (input.refs_dir !== undefined) {
+        if (typeof input.refs_dir !== "string" ||
+            input.refs_dir.trim().length === 0) {
+            errors.push("refs_dir must be a non-empty string if provided");
+        }
+        else if (!isSafeRelKey(input.refs_dir)) {
+            // refs_dir is used downstream as an R2 key prefix; reject traversal / absolute / scheme. (security #6)
+            errors.push('refs_dir must be a safe relative path (letters, digits, . _ - /, no "..", no leading "/")');
+        }
+        else {
+            refsDir = input.refs_dir;
+        }
+    }
+    return { fullPrompt, stylePrefix, castRules, durationSeconds, clipSeconds, refsDir };
+}
+// v0.134.3: backfill each scene's target_seconds when the model omitted the
+// (optional) field, so the planner's scene editor shows an explicit per-shot
+// duration instead of a blank box and the value is explicit downstream (beat
+// snap, YAML, render) rather than relying on a silent fallback. Priority: an
+// explicit start/end span, else the storyboard's clip_seconds (the per-shot
+// default), else an even split of duration_seconds across the scenes. This is
+// the same clip_seconds fallback markers.ts / preflight apply at render time,
+// just materialized into the data. No-op when there's nothing to derive from.
+function backfillTargetSeconds(validatedScenes, clipSeconds, durationSeconds) {
+    const perShotFallback = typeof clipSeconds === "number" && clipSeconds > 0
+        ? clipSeconds
+        : typeof durationSeconds === "number" &&
+            durationSeconds > 0 &&
+            validatedScenes.length > 0
+            ? Math.round((durationSeconds / validatedScenes.length) * 100) / 100
+            : undefined;
+    for (const s of validatedScenes) {
+        if (typeof s.target_seconds === "number")
+            continue;
+        if (typeof s.start === "number" && typeof s.end === "number" && s.end > s.start) {
+            s.target_seconds = Math.round((s.end - s.start) * 100) / 100;
+        }
+        else if (perShotFallback !== undefined) {
+            s.target_seconds = perShotFallback;
+        }
+    }
+}
+export function validateStoryboard(input) {
+    const errors = [];
+    if (!isPlainObject(input)) {
+        return {
+            ok: false,
+            errors: [
+                `storyboard must be an object (got ${describeType(input)})`,
+            ],
+        };
+    }
+    const { title, projectName } = validateTitleSection(input, errors);
+    const useCharacters = validateUseCharactersSection(input, errors);
+    const validatedScenes = validateScenesSection(input, useCharacters, errors);
+    const { fullPrompt, stylePrefix, castRules, durationSeconds, clipSeconds, refsDir } = validateTopLevelFields(input, errors);
+    // None-normalization for the two style fields. The renderer disables on
+    // the literal string "None", not on null/undefined, so we collapse to it.
+    const styleCategory = normalizeStyleNone(input.style_category);
+    const stylePreset = normalizeStyleNone(input.style_preset);
+    if (errors.length > 0) {
+        return { ok: false, errors };
+    }
+    backfillTargetSeconds(validatedScenes, clipSeconds, durationSeconds);
+    const value = {
+        title,
+        projectName,
+        full_prompt: fullPrompt,
+        duration_seconds: durationSeconds,
+        clip_seconds: clipSeconds,
+        style_prefix: stylePrefix,
+        style_category: styleCategory,
+        style_preset: stylePreset,
+        use_characters: useCharacters,
+        cast_rules: castRules,
+        scenes: validatedScenes,
+    };
+    if (refsDir !== undefined)
+        value.refs_dir = refsDir;
+    return { ok: true, value };
+}
+// v0.147.0: per-shot cloud i2v model overrides for animate-cloud (Phase 4a).
+// Maps shot_id -> model id so one cloud animation can mix models across shots
+// (e.g. the standoff on Runway, the atmosphere on Seedance). Pure + testable;
+// the route supplies `allowedModelIds` (the image-input video catalog) so this
+// stays free of the model catalog import. Returns the accepted overrides plus a
+// list of human errors; the route 400s when any entry is bad rather than
+// silently dropping it (a shot the caller meant to override would otherwise run
+// on the default model unnoticed). A missing/empty input is valid (no overrides).
+export function normalizePerShotModels(raw, allowedModelIds) {
+    const perShot = {};
+    const errors = [];
+    if (raw === undefined || raw === null)
+        return { perShot, errors };
+    if (typeof raw !== "object" || Array.isArray(raw)) {
+        errors.push("perShot must be an object mapping shot_id to a model id");
+        return { perShot, errors };
+    }
+    for (const [shotId, modelId] of Object.entries(raw)) {
+        if (!shotId.trim())
+            continue;
+        if (typeof modelId !== "string" || !modelId) {
+            errors.push(`perShot["${shotId}"] must be a model id string`);
+            continue;
+        }
+        if (!allowedModelIds.has(modelId)) {
+            errors.push(`perShot["${shotId}"] "${modelId}" is not an image-input video model`);
+            continue;
+        }
+        perShot[shotId] = modelId;
+    }
+    return { perShot, errors };
+}
+// v0.151.0 (Phase 4 hybrid): per-shot BACKEND assignment for animate-hybrid.
+// Maps shot_id -> { backend: "gpu" | "cloud", model? } so one film can route
+// some shots to the pod's Wan i2v and others to a cloud i2v model. Pure +
+// testable; the route supplies `allowedModelIds` (the image-input video catalog)
+// for the cloud model check. A cloud entry may omit `model` (the route's
+// defaultCloudModel applies). Bad entries error (route 400s) rather than
+// silently dropping. Missing/empty input is valid (route falls back to
+// defaultBackend for every shot).
+export function normalizeHybridBackends(raw, allowedModelIds) {
+    const backends = {};
+    const errors = [];
+    if (raw === undefined || raw === null)
+        return { backends, errors };
+    if (typeof raw !== "object" || Array.isArray(raw)) {
+        errors.push("backends must be an object mapping shot_id to { backend, model? }");
+        return { backends, errors };
+    }
+    for (const [shotId, v] of Object.entries(raw)) {
+        if (!shotId.trim())
+            continue;
+        if (!v || typeof v !== "object" || Array.isArray(v)) {
+            errors.push(`backends["${shotId}"] must be an object { backend, model? }`);
+            continue;
+        }
+        const backend = v.backend;
+        if (backend !== "gpu" && backend !== "cloud") {
+            errors.push(`backends["${shotId}"].backend must be "gpu" or "cloud"`);
+            continue;
+        }
+        const entry = { backend };
+        if (backend === "cloud") {
+            const model = v.model;
+            if (model !== undefined) {
+                if (typeof model !== "string" || !allowedModelIds.has(model)) {
+                    errors.push(`backends["${shotId}"].model "${String(model)}" is not an image-input video model`);
+                    continue;
+                }
+                entry.model = model;
+            }
+        }
+        backends[shotId] = entry;
+    }
+    return { backends, errors };
+}
+//# sourceMappingURL=storyboard-validate.js.map