@milenyumai/film-kit 2.3.2 → 2.3.4

package/build/lib/model-registry/registry.js

@@ -0,0 +1,191 @@
+export const MODEL_REGISTRY = {
+    veo31: {
+        id: "veo31",
+        displayName: "Google Flow + Veo 3.1",
+        provider: "google",
+        modalities: ["video"],
+        lifecycleStatus: "active",
+        supportedPresets: ["single", "multi", "studio"],
+        supportedReferenceModes: ["start-end", "storyboard-reference"],
+        supportedAspects: ["16:9", "9:16", "1:1"],
+        durationRange: { minSeconds: 4, maxSeconds: 8 },
+        durationPolicy: "Default Film-Kit Veo runtime duration is 8 seconds.",
+        adapterKey: "veo31",
+        promptGrammarKey: "veo31",
+        modelProfileKey: "veo31",
+        routingRole: "primary-video",
+        capabilities: {
+            characterReference: true,
+            storyboardReference: true,
+            audioPlan: true,
+            dialogue: true,
+            startEndFrames: true,
+            customStoryboardPhases: true,
+            maxStoryboardPhases: 4
+        },
+        docsVisibility: "public"
+    },
+    "seedance-2.0": {
+        id: "seedance-2.0",
+        displayName: "Seedance 2.0",
+        provider: "bytedance",
+        modalities: ["video"],
+        lifecycleStatus: "active",
+        supportedPresets: ["single", "multi", "studio"],
+        supportedReferenceModes: ["start-end", "storyboard-reference"],
+        supportedAspects: ["16:9", "9:16", "1:1"],
+        durationRange: { minSeconds: 4, maxSeconds: 15 },
+        durationPolicy: "Seedance storyboard-reference policy uses 4-15 second shots.",
+        adapterKey: "seedance20",
+        promptGrammarKey: "seedance20",
+        modelProfileKey: "seedance20",
+        routingRole: "storyboard-video",
+        capabilities: {
+            characterReference: true,
+            storyboardReference: true,
+            multipleImageReferences: true,
+            audioPlan: true,
+            dialogue: true,
+            customStoryboardPhases: true,
+            maxStoryboardPhases: 4,
+            maxReferenceImages: 9,
+            maxReferenceVideos: 3,
+            maxReferenceAudio: 3,
+            maxReferenceFiles: 12
+        },
+        docsVisibility: "public"
+    },
+    "kling-3.0": {
+        id: "kling-3.0",
+        displayName: "Kling 3.0",
+        provider: "kuaishou",
+        modalities: ["video"],
+        lifecycleStatus: "active",
+        supportedPresets: ["single", "multi", "hybrid", "hybrid-smart", "gpt-image-smart", "studio"],
+        supportedReferenceModes: ["start-end", "storyboard-reference", "hybrid"],
+        supportedAspects: ["16:9", "9:16", "1:1"],
+        durationRange: { minSeconds: 5, maxSeconds: 15 },
+        durationPolicy: "Kling 3.0 supports Film-Kit start/end and smart-routed video generation.",
+        adapterKey: "kling30",
+        promptGrammarKey: "kling30",
+        modelProfileKey: "kling30",
+        routingRole: "primary-video",
+        capabilities: {
+            characterReference: true,
+            storyboardReference: true,
+            audioPlan: true,
+            startEndFrames: true,
+            customStoryboardPhases: true,
+            maxStoryboardPhases: 4
+        },
+        docsVisibility: "public"
+    },
+    "gpt-image-2": {
+        id: "gpt-image-2",
+        displayName: "GPT Image 2",
+        provider: "openai",
+        modalities: ["image"],
+        lifecycleStatus: "active",
+        supportedPresets: ["hybrid", "hybrid-smart", "gpt-image-smart", "studio"],
+        supportedReferenceModes: ["start-end", "storyboard-reference", "hybrid"],
+        supportedAspects: ["16:9", "9:16", "1:1"],
+        durationPolicy: "Still-image model; video duration is not applicable.",
+        adapterKey: "gptImage2",
+        promptGrammarKey: "gptImage2",
+        modelProfileKey: "gptImage2",
+        routingRole: "image-reference",
+        capabilities: {
+            characterReference: true,
+            storyboardReference: true
+        },
+        docsVisibility: "public"
+    },
+    "gemini-3-pro-image-preview": {
+        id: "gemini-3-pro-image-preview",
+        displayName: "Gemini 3 Pro Image Preview",
+        provider: "google",
+        modalities: ["image"],
+        lifecycleStatus: "experimental",
+        supportedPresets: ["hybrid", "hybrid-smart"],
+        supportedReferenceModes: ["start-end", "storyboard-reference", "hybrid"],
+        supportedAspects: ["16:9", "9:16", "1:1"],
+        durationPolicy: "Still-image model used by internal hybrid presets; video duration is not applicable.",
+        adapterKey: "none",
+        promptGrammarKey: "generic",
+        modelProfileKey: "generic",
+        routingRole: "image-reference",
+        capabilities: {
+            characterReference: true,
+            storyboardReference: true
+        },
+        docsVisibility: "internal"
+    },
+    "smart-dialogue-router": {
+        id: "smart-dialogue-router",
+        displayName: "Smart Dialogue Router",
+        provider: "film-kit",
+        modalities: ["multimodal"],
+        lifecycleStatus: "active",
+        supportedPresets: ["hybrid-smart", "gpt-image-smart"],
+        supportedReferenceModes: ["start-end", "storyboard-reference", "hybrid"],
+        supportedAspects: ["16:9", "9:16", "1:1"],
+        durationPolicy: "Internal routing policy; routes dialogue/lip-sync to Veo and non-dialogue shots to Kling.",
+        adapterKey: "none",
+        promptGrammarKey: "generic",
+        modelProfileKey: "generic",
+        routingRole: "smart-router",
+        capabilities: {
+            smartRouting: true,
+            audioPlan: true,
+            dialogue: true
+        },
+        docsVisibility: "internal"
+    },
+    "veo2": {
+        id: "veo2",
+        displayName: "Veo 2",
+        provider: "google",
+        modalities: ["video"],
+        lifecycleStatus: "deprecated",
+        supportedPresets: ["single", "multi", "studio"],
+        supportedReferenceModes: ["start-end", "storyboard-reference"],
+        supportedAspects: ["16:9", "9:16", "1:1"],
+        durationRange: { minSeconds: 4, maxSeconds: 8 },
+        durationPolicy: "Deprecated legacy video model kept only for migration warnings.",
+        adapterKey: "generic",
+        promptGrammarKey: "generic",
+        modelProfileKey: "generic",
+        routingRole: "legacy-video",
+        capabilities: {
+            characterReference: true,
+            storyboardReference: true,
+            audioPlan: true,
+            dialogue: true,
+            startEndFrames: true,
+            customStoryboardPhases: true,
+            maxStoryboardPhases: 4
+        },
+        deprecationMessage: "veo2 is deprecated. Use veo31 for current Film-Kit video generation.",
+        replacementModelId: "veo31",
+        docsVisibility: "hidden"
+    },
+    "kling-2.0": {
+        id: "kling-2.0",
+        displayName: "Kling 2.0",
+        provider: "kuaishou",
+        modalities: ["video"],
+        lifecycleStatus: "removed",
+        supportedPresets: [],
+        supportedReferenceModes: [],
+        supportedAspects: ["16:9", "9:16", "1:1"],
+        durationPolicy: "Removed legacy model. Do not route generation here.",
+        adapterKey: "none",
+        promptGrammarKey: "generic",
+        modelProfileKey: "generic",
+        routingRole: "removed",
+        capabilities: {},
+        deprecationMessage: "kling-2.0 has been removed from Film-Kit. Use kling-3.0 instead.",
+        replacementModelId: "kling-3.0",
+        docsVisibility: "hidden"
+    }
+};

package/build/lib/model-registry/selectors.d.ts

@@ -0,0 +1,23 @@
+import { type ActiveModelId, type DeprecatedModelId, type ImageModelId, type KnownModelId, type RemovedModelId, type VideoModelId } from "./registry.js";
+import type { ModelAdapterKey, ModelRegistryEntry, ModelRegistryPreset, ModelRegistryReferenceMode } from "./types.js";
+export declare function getModel(id: string): ModelRegistryEntry | undefined;
+export declare function requireModel(id: string): ModelRegistryEntry;
+export declare function listModels(): ModelRegistryEntry[];
+export declare function listActiveModels(): ModelRegistryEntry[];
+export declare function listVideoModels(): ModelRegistryEntry[];
+export declare function listImageModels(): ModelRegistryEntry[];
+export declare function listModelsForPreset(preset: ModelRegistryPreset): ModelRegistryEntry[];
+export declare function listModelsForReferenceMode(referenceMode: ModelRegistryReferenceMode): ModelRegistryEntry[];
+export declare function listRunnableVideoModels(): ModelRegistryEntry[];
+export declare function listRunnableVideoModelIds(): VideoModelId[];
+export declare function listActiveVideoModelIds(): VideoModelId[];
+export declare function isKnownModelId(value: string): value is KnownModelId;
+export declare function isActiveModelId(value: string): value is ActiveModelId;
+export declare function isDeprecatedModelId(value: string): value is DeprecatedModelId;
+export declare function isRemovedModelId(value: string): value is RemovedModelId;
+export declare function isVideoModelId(value: string): value is VideoModelId;
+export declare function isImageModelId(value: string): value is ImageModelId;
+export declare function isModelSupportedByPreset(modelId: string, preset: ModelRegistryPreset): boolean;
+export declare function getModelAdapterKey(modelId: string): ModelAdapterKey;
+export declare function getReplacementModel(modelId: string): ModelRegistryEntry | undefined;
+export declare function getModelDisplayName(modelId: string): string;

package/build/lib/model-registry/selectors.js

@@ -0,0 +1,80 @@
+import { MODEL_REGISTRY } from "./registry.js";
+function entries() {
+    return Object.values(MODEL_REGISTRY);
+}
+function hasModality(model, modality) {
+    return model.modalities.includes(modality);
+}
+export function getModel(id) {
+    return MODEL_REGISTRY[id];
+}
+export function requireModel(id) {
+    const model = getModel(id);
+    if (!model) {
+        throw new Error(`Unknown model: ${id}.`);
+    }
+    return model;
+}
+export function listModels() {
+    return entries();
+}
+export function listActiveModels() {
+    return entries().filter(model => model.lifecycleStatus === "active" || model.lifecycleStatus === "experimental");
+}
+export function listVideoModels() {
+    return entries().filter(model => hasModality(model, "video"));
+}
+export function listImageModels() {
+    return entries().filter(model => hasModality(model, "image"));
+}
+export function listModelsForPreset(preset) {
+    return entries().filter(model => model.supportedPresets.includes(preset));
+}
+export function listModelsForReferenceMode(referenceMode) {
+    return entries().filter(model => model.supportedReferenceModes.includes(referenceMode));
+}
+export function listRunnableVideoModels() {
+    return listVideoModels().filter(model => model.lifecycleStatus !== "removed");
+}
+export function listRunnableVideoModelIds() {
+    return listRunnableVideoModels().map(model => model.id);
+}
+export function listActiveVideoModelIds() {
+    return listActiveModels()
+        .filter(model => hasModality(model, "video"))
+        .map(model => model.id);
+}
+export function isKnownModelId(value) {
+    return Object.prototype.hasOwnProperty.call(MODEL_REGISTRY, value);
+}
+export function isActiveModelId(value) {
+    const model = getModel(value);
+    return model?.lifecycleStatus === "active" || model?.lifecycleStatus === "experimental";
+}
+export function isDeprecatedModelId(value) {
+    return getModel(value)?.lifecycleStatus === "deprecated";
+}
+export function isRemovedModelId(value) {
+    return getModel(value)?.lifecycleStatus === "removed";
+}
+export function isVideoModelId(value) {
+    const model = getModel(value);
+    return Boolean(model && hasModality(model, "video"));
+}
+export function isImageModelId(value) {
+    const model = getModel(value);
+    return Boolean(model && hasModality(model, "image"));
+}
+export function isModelSupportedByPreset(modelId, preset) {
+    return Boolean(getModel(modelId)?.supportedPresets.includes(preset));
+}
+export function getModelAdapterKey(modelId) {
+    return requireModel(modelId).adapterKey;
+}
+export function getReplacementModel(modelId) {
+    const replacementModelId = getModel(modelId)?.replacementModelId;
+    return replacementModelId ? getModel(replacementModelId) : undefined;
+}
+export function getModelDisplayName(modelId) {
+    return requireModel(modelId).displayName;
+}

package/build/lib/model-registry/types.d.ts

@@ -0,0 +1,59 @@
+export type ModelModality = "video" | "image" | "audio" | "multimodal";
+export type ModelLifecycleStatus = "active" | "experimental" | "deprecated" | "removed";
+export type ModelRegistryPreset = "single" | "multi" | "hybrid" | "hybrid-smart" | "gpt-image-smart" | "studio";
+export type ModelRegistryReferenceMode = "start-end" | "storyboard-reference" | "hybrid";
+export type ModelRegistryAspectRatio = "16:9" | "9:16" | "1:1";
+export type ModelAdapterKey = "veo31" | "seedance20" | "kling30" | "generic" | "gptImage2" | "none";
+export type PromptGrammarKey = "veo31" | "seedance20" | "kling30" | "gptImage2" | "generic";
+export type ModelProfileKey = "veo31" | "seedance20" | "kling30" | "gptImage2" | "generic";
+export type ModelRoutingRole = "primary-video" | "storyboard-video" | "image-reference" | "smart-router" | "legacy-video" | "removed";
+export interface ModelDurationRange {
+    minSeconds: number;
+    maxSeconds: number;
+}
+export interface ModelCapabilities {
+    characterReference?: boolean;
+    storyboardReference?: boolean;
+    multipleImageReferences?: boolean;
+    audioPlan?: boolean;
+    dialogue?: boolean;
+    startEndFrames?: boolean;
+    smartRouting?: boolean;
+    customStoryboardPhases?: boolean;
+    maxStoryboardPhases?: number;
+    maxReferenceImages?: number;
+    maxReferenceVideos?: number;
+    maxReferenceAudio?: number;
+    maxReferenceFiles?: number;
+}
+export interface ModelRegistryEntry {
+    id: string;
+    displayName: string;
+    provider: string;
+    modalities: readonly ModelModality[];
+    lifecycleStatus: ModelLifecycleStatus;
+    supportedPresets: readonly ModelRegistryPreset[];
+    supportedReferenceModes: readonly ModelRegistryReferenceMode[];
+    supportedAspects: readonly ModelRegistryAspectRatio[];
+    durationRange?: ModelDurationRange;
+    durationPolicy?: string;
+    adapterKey: ModelAdapterKey;
+    promptGrammarKey: PromptGrammarKey;
+    modelProfileKey: ModelProfileKey;
+    routingRole: ModelRoutingRole;
+    capabilities: ModelCapabilities;
+    deprecationMessage?: string;
+    replacementModelId?: string;
+    docsVisibility: "public" | "internal" | "hidden";
+}
+export interface ModelAllowedContext {
+    preset?: ModelRegistryPreset;
+    referenceMode?: ModelRegistryReferenceMode;
+    requiredModalities?: readonly ModelModality[];
+    allowDeprecated?: boolean;
+    usage?: string;
+}
+export interface ModelAllowedResult {
+    model: ModelRegistryEntry;
+    warnings: string[];
+}

package/build/lib/model-registry/types.js

@@ -0,0 +1 @@
+export {};

package/build/lib/model-registry/validation.d.ts

@@ -0,0 +1,3 @@
+import type { ModelAllowedContext, ModelAllowedResult, ModelRegistryEntry } from "./types.js";
+export declare function validateModelAllowed(modelId: string, context?: ModelAllowedContext): ModelAllowedResult;
+export declare function assertModelAllowed(modelId: string, context?: ModelAllowedContext): ModelRegistryEntry;

package/build/lib/model-registry/validation.js

@@ -0,0 +1,42 @@
+import { getModel, getReplacementModel, listRunnableVideoModelIds } from "./selectors.js";
+function formatModelList(models) {
+    return models.join(", ");
+}
+function hasRequiredModalities(model, required) {
+    return !required || required.every(modality => model.modalities.includes(modality));
+}
+export function validateModelAllowed(modelId, context = {}) {
+    const model = getModel(modelId);
+    const usage = context.usage ? `${context.usage} ` : "";
+    if (!model) {
+        throw new Error(`Unknown ${usage}model: ${modelId}. Supported video models: ${formatModelList(listRunnableVideoModelIds())}`);
+    }
+    if (model.lifecycleStatus === "removed") {
+        const replacement = getReplacementModel(model.id);
+        const replacementText = replacement ? ` Use ${replacement.id} instead.` : "";
+        throw new Error(`${model.deprecationMessage ?? `${model.id} has been removed.`}${replacementText}`);
+    }
+    if (!hasRequiredModalities(model, context.requiredModalities)) {
+        throw new Error(`Model ${model.id} is not valid for ${usage.trim() || "this usage"}. ` +
+            `Required modalities: ${context.requiredModalities?.join(", ") ?? "none"}.`);
+    }
+    if (context.preset && !model.supportedPresets.includes(context.preset)) {
+        throw new Error(`Model ${model.id} is not supported by preset ${context.preset}.`);
+    }
+    if (context.referenceMode && !model.supportedReferenceModes.includes(context.referenceMode)) {
+        throw new Error(`Model ${model.id} is not supported by reference mode ${context.referenceMode}.`);
+    }
+    const warnings = [];
+    if (model.lifecycleStatus === "deprecated") {
+        if (context.allowDeprecated === false) {
+            throw new Error(model.deprecationMessage ?? `Model ${model.id} is deprecated.`);
+        }
+        const replacement = getReplacementModel(model.id);
+        warnings.push(model.deprecationMessage
+            ?? `Model ${model.id} is deprecated.${replacement ? ` Use ${replacement.id} instead.` : ""}`);
+    }
+    return { model, warnings };
+}
+export function assertModelAllowed(modelId, context = {}) {
+    return validateModelAllowed(modelId, context).model;
+}

package/build/lib/storyboard-reference/adapters/base.js

@@ -1,3 +1,4 @@
+import { getModelDisplayName } from "../../model-registry/index.js";
 export class BaseVideoModelPromptAdapter {
     validate(output) {
         const prompt = output.promptText;
@@ -53,9 +54,5 @@ export function formatPhaseLines(phases) {
         .join("\n");
 }
 export function getDisplayName(model) {
-    if (model === "seedance-2.0")
-        return "Seedance 2.0";
-    if (model === "kling-3.0")
-        return "Kling 3.0";
-    return "Veo 3.1";
+    return getModelDisplayName(model);
 }

package/build/lib/storyboard-reference/defaults.js

@@ -1,9 +1,10 @@
+import { listActiveVideoModelIds } from "../model-registry/index.js";
 export const STORYBOARD_REFERENCE_MODE = "storyboard-reference";
 export const DEFAULT_STORYBOARD_DURATION_SECONDS = 8;
 export const DEFAULT_STORYBOARD_ASPECT_RATIO = "16:9";
 export const DEFAULT_STORYBOARD_LANGUAGE = "NONE";
 export const DEFAULT_STORYBOARD_OUTPUT_DIR = "./outputs";
-export const DEFAULT_STORYBOARD_TARGET_MODELS = ["veo31", "seedance-2.0", "kling-3.0"];
+export const DEFAULT_STORYBOARD_TARGET_MODELS = listActiveVideoModelIds();
 export const DEFAULT_STORYBOARD_REFERENCE_RUNTIME = {
     enabled: true,
     maxStoryboardPhases: 4,

package/build/lib/storyboard-reference/output-writer.js

@@ -41,6 +41,37 @@ function formatProviderTokens(bundle) {
     })
         .join("\n");
 }
+function getProviderToken(bundle, role, fallback) {
+    return Object.values(bundle.providerAssetMapping)
+        .find(entry => entry.role === role)?.token ?? fallback;
+}
+function formatCoverageReferences(bundle) {
+    const interpretation = bundle.storyboardInterpretation;
+    const characterTokens = Object.values(bundle.providerAssetMapping)
+        .filter(entry => entry.role === "character_identity")
+        .map(entry => entry.token)
+        .join(", ") || "@Image1";
+    const storyboardToken = getProviderToken(bundle, "storyboard_plan", "@Image2");
+    const visualWorld = interpretation.visualWorld;
+    const camera = interpretation.cameraPlan;
+    const firstPhase = interpretation.phases[0];
+    const lastPhase = interpretation.phases.at(-1) ?? firstPhase;
+    return `## Coverage References In Same File
+
+Coverage is standalone editorial material for this shot only. Do not chain coverage into the next main shot. Keep the same generated character identity, wardrobe, props, lighting direction, environment, screen direction, and visual_world.
+
+### ${bundle.shotId}A - ECU Reaction | 3s
+
+\`\`\`text
+Use ${characterTokens} as the exact identity source and ${storyboardToken} only for scene continuity. Extreme close-up reaction coverage during ${firstPhase?.timeRange ?? "the opening beat"}: ${firstPhase?.subjectAction ?? "the character registers the story beat"}. Keep ${visualWorld.lighting}, ${visualWorld.atmosphere}, and ${camera.screenDirection}. Static or barely drifting camera, shallow depth of field, natural skin texture, visible breath or eye tension, no new action beat, no new identity. Audio: close breath, subtle clothing sound, matched ambience, Music: NONE. Avoid: identity drift, face drift, wardrobe drift, beauty filter, plastic skin, distorted eyes, flicker, warping, on-screen text, watermark, logo.
+\`\`\`
+
+### ${bundle.shotId}B - Insert / Environmental Detail | 3s
+
+\`\`\`text
+Use ${storyboardToken} only for composition and environment continuity; do not introduce a new character identity. Tight insert coverage tied to ${lastPhase?.timeRange ?? "the final beat"}: ${lastPhase?.subjectAction ?? "the action resolves into a clear visual detail"}. Show a physically plausible detail from the same visual world: foreground texture, prop contact, reflection, light spill, hand tension, fabric motion, or environment response. Keep ${visualWorld.environment}; ${visualWorld.foreground}; ${visualWorld.background}; ${visualWorld.lighting}. Audio: matched practical SFX and ambience, no dialogue unless explicitly present in the main Audio Plan, Music: NONE. Avoid: new location, new character, clear logo, readable text, impossible physics, wrong reflection angle, identity override, flicker, warping, cartoon style, CGI look.
+\`\`\``;
+}
 export function renderShotMarkdown(bundle) {
     const interpretation = bundle.storyboardInterpretation;
     const audioPlan = getAudioPlan(bundle);
@@ -104,6 +135,8 @@ ${JSON.stringify(audioPlan ?? null, null, 2)}
 
 ${modelPrompts}
 
+${formatCoverageReferences(bundle)}
+
 ## QA
 ${formatQa(bundle)}
 `;

package/build/lib/storyboard-reference/prompt-bundle-builder.js

@@ -1,15 +1,47 @@
 import { resolveAssetRoles } from "./asset-role-resolver.js";
+import { GenericPromptAdapter } from "./adapters/generic.js";
 import { Kling30PromptAdapter } from "./adapters/kling30.js";
 import { Seedance20PromptAdapter } from "./adapters/seedance20.js";
 import { Veo31PromptAdapter } from "./adapters/veo31.js";
+import { getModelAdapterKey, requireModel } from "../model-registry/index.js";
 import { normalizeVideoPromptRequest } from "./request-normalizer.js";
 import { buildStoryboardPhaseBudget, inferContinuityMode, interpretStoryboard } from "./storyboard-interpreter.js";
 import { assertSafeStoryboardReferenceRequest, validateCharacterReferenceSheetPrompts, validateModelPromptOutput, validatePromptBundle } from "./validators.js";
 const ADAPTERS = {
     veo31: new Veo31PromptAdapter(),
-    "seedance-2.0": new Seedance20PromptAdapter(),
-    "kling-3.0": new Kling30PromptAdapter()
+    seedance20: new Seedance20PromptAdapter(),
+    kling30: new Kling30PromptAdapter()
 };
+function buildGenericCapabilities(model) {
+    const registryModel = requireModel(model);
+    const capabilities = {
+        supportsImageReference: Boolean(registryModel.capabilities.characterReference),
+        supportsMultipleImageReferences: Boolean(registryModel.capabilities.multipleImageReferences),
+        supportsStoryboardReference: Boolean(registryModel.capabilities.storyboardReference),
+        supportsAudio: Boolean(registryModel.capabilities.audioPlan),
+        supportsDialogue: Boolean(registryModel.capabilities.dialogue),
+        supportsCustomStoryboardPhases: Boolean(registryModel.capabilities.customStoryboardPhases),
+        preferredPromptShape: "natural-language"
+    };
+    if (registryModel.durationRange?.maxSeconds !== undefined) {
+        capabilities.maxDurationSeconds = registryModel.durationRange.maxSeconds;
+    }
+    if (registryModel.capabilities.maxStoryboardPhases !== undefined) {
+        capabilities.maxStoryboardPhases = registryModel.capabilities.maxStoryboardPhases;
+    }
+    return capabilities;
+}
+function resolvePromptAdapter(model) {
+    const adapterKey = getModelAdapterKey(model);
+    if (adapterKey === "generic") {
+        return new GenericPromptAdapter(model, buildGenericCapabilities(model));
+    }
+    const adapter = ADAPTERS[adapterKey];
+    if (!adapter) {
+        throw new Error(`Model ${model} does not have a storyboard-reference video adapter.`);
+    }
+    return adapter;
+}
 function getStoryboardPanelCount(request, phaseBudget) {
     return request.storyboardPanelCountHint
         ?? request.shotCountHint
@@ -320,7 +352,7 @@ function buildStoryboardReferencePolicy(request, phaseBudget, providerFileLimits
 function buildModelPrompts(request, bundleInput) {
     const modelPrompts = {};
     for (const model of request.targetModels) {
-        const adapter = ADAPTERS[model];
+        const adapter = resolvePromptAdapter(model);
         const output = adapter.buildPrompt({ ...bundleInput, request });
         const validatorQa = validateModelPromptOutput(output);
         output.qa = {

package/build/lib/storyboard-reference/request-normalizer.js

@@ -1,5 +1,5 @@
+import { validateModelAllowed } from "../model-registry/index.js";
 import { DEFAULT_STORYBOARD_ASPECT_RATIO, DEFAULT_STORYBOARD_DURATION_SECONDS, DEFAULT_STORYBOARD_LANGUAGE, DEFAULT_STORYBOARD_OUTPUT_DIR, DEFAULT_STORYBOARD_TARGET_MODELS, STORYBOARD_REFERENCE_MODE, resolveStoryboardReferenceRuntime } from "./defaults.js";
-const SUPPORTED_MODELS = ["veo31", "seedance-2.0", "kling-3.0"];
 const SUPPORTED_ASPECT_RATIOS = ["16:9", "9:16", "1:1"];
 function normalizePositiveInteger(value, fallback, fieldName) {
     const normalized = value ?? fallback;
@@ -13,9 +13,11 @@ function assertSupportedModels(models) {
         return DEFAULT_STORYBOARD_TARGET_MODELS.slice();
     }
     for (const model of models) {
-        if (!SUPPORTED_MODELS.includes(model)) {
-            throw new Error(`Unsupported target model: ${model}. Supported: ${SUPPORTED_MODELS.join(", ")}`);
-        }
+        validateModelAllowed(model, {
+            requiredModalities: ["video"],
+            referenceMode: STORYBOARD_REFERENCE_MODE,
+            usage: "storyboard target"
+        });
     }
     return Array.from(new Set(models));
 }

package/build/lib/storyboard-reference/validators.js

@@ -99,8 +99,12 @@ export function validateModelPromptOutput(output) {
 }
 export function validatePromptBundle(bundle, assets, voiceCast = []) {
     const roleIssues = validateResolvedAssetRoles(assets);
+    const modelValidationResults = Object.values(bundle.modelPrompts)
+        .filter((output) => Boolean(output))
+        .map(validateModelPromptOutput);
     const modelIssues = Object.values(bundle.modelPrompts)
-        .flatMap(output => output?.qa.issues ?? []);
+        .flatMap(output => output?.qa.issues ?? [])
+        .concat(modelValidationResults.flatMap(result => result.issues));
     const voiceCastKeys = new Set(voiceCast.map(entry => entry.speakerKey));
     const audioPlans = Object.values(bundle.modelPrompts)
         .map(output => output?.audioPlan)
@@ -110,9 +114,10 @@ export function validatePromptBundle(bundle, assets, voiceCast = []) {
         hasStoryboardReference: assets.storyboards.length >= 1 || Boolean(bundle.storyboardImagePrompt),
         hasStoryboardImagePrompt: Boolean(bundle.storyboardImagePrompt?.promptText.trim()),
         storyboardPromptHasReferenceLockStructure: hasGptImageStillPromptContract(bundle.storyboardImagePrompt?.promptText ?? ""),
-        hasAvoidLineEverywhere: Object.values(bundle.modelPrompts).every(output => Boolean(output?.qa.checks.hasAvoidLine ?? output?.qa.checks.hasAvoidOrNegative)),
+        hasAvoidLineEverywhere: Object.values(bundle.modelPrompts).every(output => Boolean(output) && hasAvoidOrNegativePrompt(output.promptText)),
         storyboardPromptHasAvoidLine: hasAvoidOrNegativePrompt(bundle.storyboardImagePrompt?.promptText ?? ""),
-        modelGrammarPasses: Object.values(bundle.modelPrompts).every(output => output?.qa.verdict === "pass"),
+        modelGrammarPasses: Object.values(bundle.modelPrompts).every(output => output?.qa.verdict === "pass")
+            && modelValidationResults.every(result => result.verdict === "pass"),
         storyboardDoesNotOverrideIdentity: Object.values(bundle.modelPrompts).every(output => /storyboard.*staging|storyboard.*planning|storyboard.*composition|storyboard.*only/i.test(output?.promptText ?? "")),
         audioPlanPresent: Object.values(bundle.modelPrompts).every(output => Boolean(output?.audioPlan)),
         speakingAudioPlansHaveActiveSpeaker: audioPlans.every(plan => plan.dialogueTranscript === "NONE" || Boolean(plan.activeSpeakerKey)),
@@ -131,10 +136,20 @@ export function validatePromptBundle(bundle, assets, voiceCast = []) {
     };
 }
 export function assertStoryboardReferenceBuildPass(result) {
-    const failedBundles = result.bundles.filter(bundle => bundle.qa.verdict !== "pass");
-    const issues = failedBundles.flatMap(bundle => (bundle.qa.issues.length > 0
-        ? bundle.qa.issues.map(issue => `${bundle.shotId}: ${issue}`)
-        : [`${bundle.shotId}: bundle QA failed without a detailed issue.`]));
+    const issues = validateCharacterReferenceSheetPrompts(result.characterReferenceSheetPrompts)
+        .map(issue => `character-sheet: ${issue}`);
+    for (const bundle of result.bundles) {
+        const currentQa = validatePromptBundle(bundle, result.assets, result.plan.voiceCast);
+        if (bundle.qa.verdict !== "pass" || currentQa.verdict !== "pass") {
+            const bundleIssues = [
+                ...bundle.qa.issues,
+                ...currentQa.issues
+            ];
+            issues.push(...(bundleIssues.length > 0
+                ? bundleIssues.map(issue => `${bundle.shotId}: ${issue}`)
+                : [`${bundle.shotId}: bundle QA failed without a detailed issue.`]));
+        }
+    }
     if (result.bundles.length === 0) {
         issues.push("No storyboard-reference prompt bundles were generated.");
     }

package/build/lib/storyboard-reference/visual-world-builder.js

@@ -11,7 +11,7 @@ export function buildCameraPlan(request) {
         lens: wideShot ? "35mm lens feel" : closeShot ? "85mm lens feel" : "50mm lens feel",
         framing: wideShot ? "layered wide composition" : closeShot ? "eye-level close framing" : "stable mid-shot framing",
         stabilization: "tripod-stable with minimal organic drift",
-        screenDirection: "preserve the storyboard's screen direction and eyeline relationships"
+        screenDirection: "storyboard screen direction and eyeline relationships"
     };
 }
 export function buildVisualWorld(request) {

package/build/lib/types.d.ts

@@ -1,5 +1,6 @@
+import type { VideoModelId } from "./model-registry/index.js";
 export type SupportedPlatform = "cursor" | "claude" | "copilot" | "antigravity" | "codex";
-export type SupportedModel = "veo31" | "kling-3.0" | "seedance-2.0";
+export type SupportedModel = VideoModelId;
 export type KlingPreset = "ultra-realism" | "balanced" | "custom";
 export type FilmKitPreset = "single" | "multi" | "hybrid" | "hybrid-smart" | "gpt-image-smart" | "studio";
 export type ReferenceMode = "start-end" | "storyboard-reference" | "hybrid";