@milenyumai/film-kit 2.3.3 → 2.3.5

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

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

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);
 }