@henjicc/ai-sdk 0.9.0 → 0.10.0

package/dist/catalog/kie/wan-3.0.model.js

@@ -0,0 +1,15 @@
+import { defineModel } from '../defineModel.js';
+import { wan30Definition } from './wan30.js';
+export const kieWan30Model = defineModel({
+    meta: {
+        id: 'kie-wan-3.0', canonicalModelId: 'wan-3.0', seriesId: 'wan', seriesRank: 3,
+        provider: 'kie', type: 'video',
+        tags: ['text-to-video', 'image-to-video', 'start-end-frame', 'reference-mode'],
+        polling: { interval: 3000, maxAttempts: 400, expectedAttempts: 100 },
+    },
+    ...wan30Definition({
+        idPrefix: 'kieWan30', model: 'wan/3-0-video', name: 'Wan 3.0',
+        rates: { '480p': 0.04, '720p': 0.08, '1080p': 0.16 },
+    }),
+});
+export default kieWan30Model;

package/dist/catalog/kie/wan30.d.ts

@@ -0,0 +1,10 @@
+import type { ModelRuntimeDefinition } from '../../types/model.js';
+/** Wan 3.0 与 Wan 3.0 Prime 请求字段完全相同，只有模型 ID 与每秒单价不同。 */
+export interface Wan30Variant {
+    idPrefix: string;
+    model: string;
+    name: string;
+    /** 每秒美元价，按输出分辨率。 */
+    rates: Record<string, number>;
+}
+export declare function wan30Definition(variant: Wan30Variant): Omit<ModelRuntimeDefinition, 'meta'>;

package/dist/catalog/kie/wan30.js

@@ -0,0 +1,78 @@
+import { resolveKieImageSources, resolveKieVideoSources } from './mediaSources.js';
+const RATIOS = ['adaptive', '16:9', '4:3', '1:1', '3:4', '9:16'];
+const RESOLUTIONS = ['480p', '720p', '1080p'];
+function sources(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === 'string' && item.trim().length > 0) : [];
+}
+export function wan30Definition(variant) {
+    const p = variant.idPrefix;
+    const read = (params, key) => params[`${p}${key}`];
+    const resolution = (params) => {
+        const value = String(read(params, 'Resolution') ?? '720p');
+        return RESOLUTIONS.includes(value) ? value : '720p';
+    };
+    const seconds = (params) => Math.min(30, Math.max(2, Number(read(params, 'Duration') ?? 5) || 5));
+    return {
+        inputLimits: {
+            images: { max: 2 },
+            videos: { max: 0 },
+            audios: { max: 0 },
+            rules: [{ when: `${p}Mode === "reference-to-video"`, images: { max: 10 }, videos: { max: 5 }, audios: { max: 5 } }],
+        },
+        params: [
+            { id: `${p}Mode`, type: 'dropdown', order: 1, default: 'text-image-to-video', options: [{ value: 'text-image-to-video' }, { value: 'reference-to-video' }] },
+            { id: `${p}AspectRatio`, type: 'dropdown', order: 2, default: 'adaptive', options: RATIOS.map(value => ({ value })) },
+            { id: `${p}Resolution`, type: 'dropdown', order: 3, default: '720p', options: RESOLUTIONS.map(value => ({ value })) },
+            { id: `${p}Duration`, type: 'dropdown', order: 4, default: '5', options: Array.from({ length: 29 }, (_, index) => ({ value: String(index + 2) })) },
+            { id: `${p}Audio`, type: 'switch', order: 5, default: true },
+        ],
+        endpoints: '/api/v1/jobs/createTask',
+        request: {
+            builder: (params) => {
+                const prompt = typeof params.prompt === 'string' ? params.prompt.trim() : '';
+                if (prompt.length > 20000)
+                    throw new Error(`${variant.name} 提示词最多 20000 字符`);
+                const images = resolveKieImageSources(params);
+                const rawRatio = String(read(params, 'AspectRatio') ?? 'adaptive');
+                const input = {
+                    resolution: resolution(params).toUpperCase(),
+                    aspect_ratio: RATIOS.includes(rawRatio) ? rawRatio : 'adaptive',
+                    duration: seconds(params),
+                    audio: read(params, 'Audio') !== false,
+                };
+                if (prompt)
+                    input.prompt = prompt;
+                if (read(params, 'Mode') === 'reference-to-video') {
+                    const videos = resolveKieVideoSources(params);
+                    const audios = sources(params.uploadedAudioFilePaths).length ? sources(params.uploadedAudioFilePaths) : sources(params.audios);
+                    if (images.length > 10 || videos.length > 5 || audios.length > 5)
+                        throw new Error(`${variant.name} 最多 10 张参考图、5 段参考视频、5 段参考音频`);
+                    if (images.length)
+                        input.reference_image_urls = images;
+                    if (videos.length)
+                        input.reference_video_urls = videos;
+                    if (audios.length)
+                        input.reference_audio_urls = audios;
+                    if (!prompt && !images.length && !videos.length && !audios.length)
+                        throw new Error(`${variant.name} 需要提示词或参考素材`);
+                }
+                else {
+                    if (images.length > 2)
+                        throw new Error(`${variant.name} 首尾帧最多 2 张图片`);
+                    if (!prompt && !images.length)
+                        throw new Error(`${variant.name} 文生视频需要提示词`);
+                    if (images[0])
+                        input.first_frame_url = images[0];
+                    if (images[1])
+                        input.last_frame_url = images[1];
+                }
+                return { model: variant.model, input };
+            },
+        },
+        pricing: {
+            currency: '$',
+            calculator: params => (variant.rates[resolution(params)] ?? variant.rates['720p']) * seconds(params),
+            description: RESOLUTIONS.map(res => `${res} $${variant.rates[res]}/秒`).join('，'),
+        },
+    };
+}

package/dist/catalog/kie/z-image.model.js

@@ -6,7 +6,7 @@ export const kieZImageModel = defineModel({
         canonicalModelId: 'z-image-turbo',
         provider: 'kie',
         type: 'image',
-        tags: ['text-to-image', 'provider-kie'],
+        tags: ['text-to-image'],
         aliases: ['z-image-kie']
     },
     inputLimits: {

package/dist/catalog/modelscope/flux-1-krea-dev.model.js

@@ -9,7 +9,8 @@ export const modelscopeFluxKreaDevModel = defineModel({
         canonicalModelId: 'flux-1-krea-dev',
         provider: 'modelscope',
         type: 'image',
-        tags: ['text-to-image', 'english-prompt-only', 'provider-modelscope'],
+        tags: ['text-to-image'],
+        promptLanguage: 'en',
         polling: {
             interval: 3000,
             maxAttempts: 120,
@@ -35,7 +36,8 @@ export const modelscopeFluxKreaDevModel = defineModel({
             default: 1024,
             min: 64,
             max: 1024,
-            step: 8
+            // 实际尺寸按 16 对齐（resolveModelscopeSize），步长与它一致。
+            step: 16
         },
         {
             id: 'modelscopeSteps',

package/dist/catalog/modelscope/majicmix-realistic.model.js

@@ -9,7 +9,7 @@ export const modelscopeMajicMixRealisticModel = defineModel({
         canonicalModelId: 'majicmix-realistic',
         provider: 'modelscope',
         type: 'image',
-        tags: ['text-to-image', 'provider-modelscope'],
+        tags: ['text-to-image'],
         polling: {
             interval: 3000,
             maxAttempts: 120,
@@ -35,7 +35,8 @@ export const modelscopeMajicMixRealisticModel = defineModel({
             default: 1024,
             min: 64,
             max: 2048,
-            step: 8
+            // 实际尺寸按 16 对齐（resolveModelscopeSize），步长与它一致。
+            step: 16
         },
         {
             id: 'modelscopeSteps',

package/dist/catalog/modelscope/modelscope-custom.model.js

@@ -22,7 +22,7 @@ export const modelscopeCustomModel = defineModel({
         canonicalModelId: 'modelscope-custom',
         provider: 'modelscope',
         type: 'image',
-        tags: ['text-to-image', 'image-to-image', 'provider-modelscope'],
+        tags: ['text-to-image', 'image-to-image'],
         polling: {
             interval: 3000,
             maxAttempts: 120,
@@ -55,7 +55,8 @@ export const modelscopeCustomModel = defineModel({
             default: 1024,
             min: 512,
             max: 2048,
-            step: 8
+            // 实际尺寸按 16 对齐（resolveModelscopeSize），步长与它一致。
+            step: 16
         },
         {
             id: 'modelscopeSteps',

package/dist/catalog/modelscope/qwen-image-2512.model.d.ts

@@ -0,0 +1,5 @@
+/**
+ * ModelScope Qwen-Image-2512 模型（运行时契约）
+ */
+export declare const modelscopeQwenImage2512Model: import("../../index.js").ModelRuntimeDefinition;
+export default modelscopeQwenImage2512Model;

package/dist/catalog/modelscope/{qwen-image.model.js → qwen-image-2512.model.js}

@@ -1,15 +1,17 @@
 /**
- * ModelScope Qwen-Image 模型（运行时契约）
+ * ModelScope Qwen-Image-2512 模型（运行时契约）
  */
 import { defineModel } from '../defineModel.js';
 import { buildModelscopeRequest, MODELSCOPE_ASPECT_RATIO_OPTIONS, MODELSCOPE_CREATE_TASK_ENDPOINT } from './utils.js';
-export const modelscopeQwenImageModel = defineModel({
+export const modelscopeQwenImage2512Model = defineModel({
     meta: {
-        id: 'Qwen/Qwen-Image',
-        canonicalModelId: 'qwen-image',
+        id: 'Qwen/Qwen-Image-2512',
+        canonicalModelId: 'qwen-image-2512',
+        // 2512 是 Qwen-Image 的直接后继，接口与参数相同；旧工程里的 Qwen-Image 按别名打开。
+        aliases: ['Qwen/Qwen-Image'],
         provider: 'modelscope',
         type: 'image',
-        tags: ['text-to-image', 'provider-modelscope'],
+        tags: ['text-to-image'],
         polling: {
             interval: 3000,
             maxAttempts: 120,
@@ -35,7 +37,8 @@ export const modelscopeQwenImageModel = defineModel({
             default: 1024,
             min: 64,
             max: 1664,
-            step: 8
+            // 实际尺寸按 16 对齐（resolveModelscopeSize），步长与它一致。
+            step: 16
         },
         {
             id: 'modelscopeSteps',
@@ -65,7 +68,7 @@ export const modelscopeQwenImageModel = defineModel({
     endpoints: MODELSCOPE_CREATE_TASK_ENDPOINT,
     request: {
         builder: (params) => buildModelscopeRequest(params, {
-            modelId: 'Qwen/Qwen-Image',
+            modelId: 'Qwen/Qwen-Image-2512',
             allowGuidance: true,
             allowNegativePrompt: true,
             allowImage: false,
@@ -81,4 +84,4 @@ export const modelscopeQwenImageModel = defineModel({
         description: '2 魔粒/次（ultra 档），魔搭免费额度约 250 魔粒/天'
     }
 });
-export default modelscopeQwenImageModel;
+export default modelscopeQwenImage2512Model;

package/dist/catalog/modelscope/qwen-image-edit-2511.model.d.ts

@@ -0,0 +1,5 @@
+/**
+ * ModelScope Qwen-Image-Edit-2511 模型（运行时契约）
+ */
+export declare const modelscopeQwenImageEdit2511Model: import("../../index.js").ModelRuntimeDefinition;
+export default modelscopeQwenImageEdit2511Model;

package/dist/catalog/modelscope/{qwen-image-edit-2509.model.js → qwen-image-edit-2511.model.js}

@@ -1,15 +1,17 @@
 /**
- * ModelScope Qwen-Image-Edit-2509 模型（运行时契约）
+ * ModelScope Qwen-Image-Edit-2511 模型（运行时契约）
  */
 import { defineModel } from '../defineModel.js';
 import { buildModelscopeRequest, MODELSCOPE_ASPECT_RATIO_OPTIONS, MODELSCOPE_CREATE_TASK_ENDPOINT } from './utils.js';
-export const modelscopeQwenImageEdit2509Model = defineModel({
+export const modelscopeQwenImageEdit2511Model = defineModel({
     meta: {
-        id: 'Qwen/Qwen-Image-Edit-2509',
-        canonicalModelId: 'qwen-image-edit-2509',
+        id: 'Qwen/Qwen-Image-Edit-2511',
+        canonicalModelId: 'qwen-image-edit-2511',
+        // 2511 是 2509 的直接后继，接口与参数相同；旧工程里的 2509 按别名打开。
+        aliases: ['Qwen/Qwen-Image-Edit-2509'],
         provider: 'modelscope',
         type: 'image',
-        tags: ['image-to-image', 'supports-image-editing', 'supports-multi-image', 'provider-modelscope'],
+        tags: ['image-to-image'],
         polling: {
             interval: 3000,
             maxAttempts: 120,
@@ -64,7 +66,7 @@ export const modelscopeQwenImageEdit2509Model = defineModel({
     endpoints: MODELSCOPE_CREATE_TASK_ENDPOINT,
     request: {
         builder: (params) => buildModelscopeRequest(params, {
-            modelId: 'Qwen/Qwen-Image-Edit-2509',
+            modelId: 'Qwen/Qwen-Image-Edit-2511',
             allowGuidance: false,
             allowNegativePrompt: false,
             allowImage: true,
@@ -80,4 +82,4 @@ export const modelscopeQwenImageEdit2509Model = defineModel({
         description: '2 魔粒/次（ultra 档），魔搭免费额度约 250 魔粒/天'
     }
 });
-export default modelscopeQwenImageEdit2509Model;
+export default modelscopeQwenImageEdit2511Model;

package/dist/catalog/modelscope/sdxl-14-ckpt.model.js

@@ -9,7 +9,7 @@ export const modelscopeSdxl14Model = defineModel({
         canonicalModelId: 'sdxl-14-checkpoint',
         provider: 'modelscope',
         type: 'image',
-        tags: ['text-to-image', 'provider-modelscope'],
+        tags: ['text-to-image'],
         polling: {
             interval: 3000,
             maxAttempts: 120,
@@ -35,7 +35,8 @@ export const modelscopeSdxl14Model = defineModel({
             default: 1024,
             min: 64,
             max: 2048,
-            step: 8
+            // 实际尺寸按 16 对齐（resolveModelscopeSize），步长与它一致。
+            step: 16
         },
         {
             id: 'modelscopeSteps',

package/dist/catalog/modelscope/utils.js

@@ -24,7 +24,7 @@ const BASE_SIZE_STEP = 8;
  */
 export const MODELSCOPE_DEFAULT_SIZE_BOUNDS = { min: 64, max: 2048 };
 /**
- * Qwen-Image-Edit-2509 专用分辨率计算（不使用基数系统，每个比例自动计算 [64, 2048] 范围内的最佳值）。
+ * Qwen-Image-Edit 专用分辨率计算（不使用基数系统，每个比例自动计算 [64, 2048] 范围内的最佳值）。
  * 原实现在应用侧 `src/utils/qwenResolutionCalculator.ts`，这里内联一份纯函数副本——
  * 该文件同时被 UI 组件 `UniversalResolutionSelector.tsx` 消费，SDK 不能反向依赖 `@/utils`，
  * 只搬运 `resolveModelscopeSize` 实际用到的这一个函数（不含 logger 的批量/展示层变体）。
@@ -114,7 +114,7 @@ export function resolveModelscopeSize(modelId, imageSize, baseSize, bounds = MOD
     const [w, h] = ratio.split(':').map(Number);
     if (!w || !h)
         return undefined;
-    if (modelId === 'Qwen/Qwen-Image-Edit-2509') {
+    if (modelId === 'Qwen/Qwen-Image-Edit-2511') {
         const size = calculateQwenResolution(w, h);
         return `${size.width}x${size.height}`;
     }

package/dist/catalog/modelscope/z-image-turbo.model.js

@@ -9,7 +9,7 @@ export const modelscopeZImageTurboModel = defineModel({
         canonicalModelId: 'z-image-turbo',
         provider: 'modelscope',
         type: 'image',
-        tags: ['text-to-image', 'provider-modelscope'],
+        tags: ['text-to-image'],
         polling: {
             interval: 3000,
             maxAttempts: 120,
@@ -35,7 +35,8 @@ export const modelscopeZImageTurboModel = defineModel({
             default: 1440,
             min: 512,
             max: 2048,
-            step: 8
+            // 实际尺寸按 16 对齐（resolveModelscopeSize），步长与它一致。
+            step: 16
         },
         {
             id: 'modelscopeSteps',

package/dist/catalog/ppio/kling-3.0.model.js

@@ -8,7 +8,8 @@ export const kling30Model = defineModel({
         seriesRank: 3.0,
         provider: 'ppio',
         type: 'video',
-        tags: ['text-to-video', 'image-to-video', 'start-end-frame', 'motion-control', 'provider-ppio'],
+        deprecated: '派欧云只保留大语言模型，不再提供生成模型',
+        tags: ['text-to-video', 'image-to-video', 'start-end-frame', 'motion-control'],
         polling: {
             interval: 3000,
             maxAttempts: 120,
@@ -19,10 +20,12 @@ export const kling30Model = defineModel({
         images: { max: 2 },
         videos: { max: 0 },
         rules: [
+            { imageConstraints: { minShortSidePx: 300, minAspectRatio: 0.4, maxAspectRatio: 2.5 } },
             {
                 when: 'ppioKling30Mode === "motion-control"',
                 images: { exact: 1 },
                 videos: { exact: 1 },
+                imageConstraints: { minShortSidePx: 300 },
                 videoConstraints: {
                     maxSizeMB: 10,
                     minDurationSec: 3,

package/dist/catalog/ppio/minimax-speech.model.js

@@ -11,7 +11,8 @@ export const minimaxSpeechModel = defineModel({
         canonicalModelId: 'minimax-speech-2.8',
         provider: 'ppio',
         type: 'audio',
-        tags: ['audio', 'text-to-speech', 'voice-synthesis', 'voice-cloning', 'voice-clone', 'provider-ppio'],
+        deprecated: '派欧云只保留大语言模型，不再提供生成模型',
+        tags: ['text-to-audio', 'voice-clone'],
         polling: {
             interval: 3000,
             maxAttempts: 120,

package/dist/catalog/shared/mediaPresence.d.ts

@@ -8,11 +8,13 @@
  * 会在以上三种场景都被调用到，只查其中一个键会导致另外两个场景判断错误（典型表现：某个参数该
  * 隐藏却没隐藏、模式自动切换在画布里完全不触发、计价该按"有视频"算却按"无视频"算）。
  *
- * 这几个函数统一查三个键，跨 kie/ppio/fal/modelscope 各 provider 通用。
+ * 这几个函数统一查三个键，跨 kie/ppio/fal/modelscope 各 provider 通用。音频同理：
+ * uploadedAudioFilePaths / audios / uploadedAudios。
  */
 import type { JsonObject } from '../../types/runtime.js';
 export declare function resolveUploadedImageSources(params: JsonObject): string[];
 export declare function resolveUploadedVideoSources(params: JsonObject): string[];
+export declare function resolveUploadedAudioSources(params: JsonObject): string[];
 export declare function countUploadedImages(params: JsonObject): number;
 export declare function countUploadedVideos(params: JsonObject): number;
 /**
@@ -20,5 +22,10 @@ export declare function countUploadedVideos(params: JsonObject): number;
  * 旧宿主只有首段时长时保留“首段 × 数量”的兼容估算，最后才使用调用方声明的单段兜底。
  */
 export declare function resolveUploadedVideoDurationSeconds(params: JsonObject, fallbackPerVideoSeconds?: number): number;
+/**
+ * 返回所有音频输入的计费总时长。`__audioDurationSeconds` 由宿主按 pricing.mediaContext
+ * 用媒体探针补齐（估价与提交前的付费确认都会补）；读不到时按调用方声明的单段兜底估算。
+ */
+export declare function resolveUploadedAudioDurationSeconds(params: JsonObject, fallbackPerAudioSeconds?: number): number;
 export declare function hasUploadedImage(params: JsonObject): boolean;
 export declare function hasUploadedVideo(params: JsonObject): boolean;

package/dist/catalog/shared/mediaPresence.js

@@ -8,7 +8,8 @@
  * 会在以上三种场景都被调用到，只查其中一个键会导致另外两个场景判断错误（典型表现：某个参数该
  * 隐藏却没隐藏、模式自动切换在画布里完全不触发、计价该按"有视频"算却按"无视频"算）。
  *
- * 这几个函数统一查三个键，跨 kie/ppio/fal/modelscope 各 provider 通用。
+ * 这几个函数统一查三个键，跨 kie/ppio/fal/modelscope 各 provider 通用。音频同理：
+ * uploadedAudioFilePaths / audios / uploadedAudios。
  */
 function cleanMediaSources(candidate) {
     if (!Array.isArray(candidate))
@@ -42,6 +43,9 @@ export function resolveUploadedImageSources(params) {
 export function resolveUploadedVideoSources(params) {
     return richestMediaSources([params.uploadedVideoFilePaths, params.videos, params.uploadedVideos]);
 }
+export function resolveUploadedAudioSources(params) {
+    return richestMediaSources([params.uploadedAudioFilePaths, params.audios, params.uploadedAudios]);
+}
 export function countUploadedImages(params) {
     return maxMediaSourceCount([params.uploadedFilePaths, params.images, params.uploadedImages]);
 }
@@ -78,6 +82,22 @@ export function resolveUploadedVideoDurationSeconds(params, fallbackPerVideoSeco
         : 0;
     return fallback * videoCount;
 }
+/**
+ * 返回所有音频输入的计费总时长。`__audioDurationSeconds` 由宿主按 pricing.mediaContext
+ * 用媒体探针补齐（估价与提交前的付费确认都会补）；读不到时按调用方声明的单段兜底估算。
+ */
+export function resolveUploadedAudioDurationSeconds(params, fallbackPerAudioSeconds = 0) {
+    const audioCount = resolveUploadedAudioSources(params).length;
+    if (audioCount === 0)
+        return 0;
+    const duration = params.__audioDurationSeconds;
+    if (typeof duration === 'number' && Number.isFinite(duration) && duration > 0)
+        return duration;
+    const fallback = Number.isFinite(fallbackPerAudioSeconds) && fallbackPerAudioSeconds > 0
+        ? fallbackPerAudioSeconds
+        : 0;
+    return fallback * audioCount;
+}
 export function hasUploadedImage(params) {
     return countUploadedImages(params) > 0;
 }

package/dist/catalog/shared/nanoBanana21.d.ts

@@ -0,0 +1,11 @@
+import type { JsonObject, JsonValue } from '../../types/runtime.js';
+export declare const NANO21_RATIOS: readonly ["1:1", "2:3", "3:2", "1:4", "4:1", "3:4", "4:3", "4:5", "5:4", "1:8", "8:1", "9:16", "16:9", "21:9"];
+export declare const NANO21_RESOLUTIONS: readonly ["1K", "2K", "4K"];
+export declare const nano21Options: (values: readonly string[]) => {
+    value: string;
+}[];
+export declare function nano21Choice(value: JsonValue, choices: readonly string[], fallback: string): string;
+export declare function nano21Count(value: JsonValue, max: number): number;
+export declare function nano21Prompt(params: JsonObject, max?: number): string;
+/** 智能比例使用供应商原生 auto，不自行裁剪参考图或重新猜测比例。 */
+export declare function nano21Ratio(value: JsonValue): string;

package/dist/catalog/shared/nanoBanana21.js

@@ -0,0 +1,30 @@
+export const NANO21_RATIOS = ['1:1', '2:3', '3:2', '1:4', '4:1', '3:4', '4:3', '4:5', '5:4', '1:8', '8:1', '9:16', '16:9', '21:9'];
+export const NANO21_RESOLUTIONS = ['1K', '2K', '4K'];
+export const nano21Options = (values) => values.map(value => ({ value }));
+export function nano21Choice(value, choices, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (typeof value !== 'string' || !choices.includes(value))
+        throw new Error(`Nano Banana 2.1 不支持参数值 ${String(value)}`);
+    return value;
+}
+export function nano21Count(value, max) {
+    if (value === undefined)
+        return 1;
+    if (typeof value !== 'number' || !Number.isInteger(value) || value < 1 || value > max) {
+        throw new Error(`Nano Banana 2.1 当前渠道每次支持 1–${max} 张输出图`);
+    }
+    return value;
+}
+export function nano21Prompt(params, max) {
+    if (typeof params.prompt !== 'string' || !params.prompt.trim())
+        throw new Error('请输入 Nano Banana 2.1 提示词');
+    if (max !== undefined && params.prompt.length > max)
+        throw new Error(`Nano Banana 2.1 提示词最多 ${max} 字符`);
+    return params.prompt;
+}
+/** 智能比例使用供应商原生 auto，不自行裁剪参考图或重新猜测比例。 */
+export function nano21Ratio(value) {
+    const ratio = nano21Choice(value, ['smart', 'auto', ...NANO21_RATIOS], 'smart');
+    return ratio === 'smart' ? 'auto' : ratio;
+}

package/dist/catalog/shared/shotList.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 分镜列表参数的值结构与校验：`[{ id?, prompt, duration }]`，按顺序成片，总时长等于各镜秒数之和。
+ * 界面（生成面板与画布节点）共用同一个 `shot-list` 面板写入这个结构，请求构建只读这里。
+ */
+import type { JsonValue } from '../../types/runtime.js';
+export interface ShotEntry {
+    prompt: string;
+    duration: number;
+}
+export interface ShotListLimits {
+    /** 单镜提示词最多字符数 */
+    maxPromptLength: number;
+    minShotSeconds: number;
+    maxShotSeconds: number;
+    /** 总时长范围，与不分镜时的时长参数一致 */
+    minTotalSeconds: number;
+    maxTotalSeconds: number;
+}
+/** 读出分镜；不是数组或没有镜头时返回空数组，表示没有使用分镜。 */
+export declare function readShots(value: JsonValue | undefined): ShotEntry[];
+/** 估价与界面汇总用：非法秒数按 0 计，结果夹在总时长范围内。 */
+export declare function shotTotalSeconds(value: JsonValue | undefined, limits: Pick<ShotListLimits, 'minTotalSeconds' | 'maxTotalSeconds'>): number;
+/**
+ * 提交前校验并转成供应商的 `multi_prompt` 结构；不合法时抛出能直接给用户看的原因。
+ * 平台的分镜与主提示词二选一，所以主提示词当作整体描述（人物、风格、场景）拼在每一镜前面，
+ * 每镜只写这一镜发生什么，不必重复交代。
+ */
+export declare function buildShotPrompts(value: JsonValue | undefined, limits: ShotListLimits, modelName: string, sharedPrompt?: string): Array<{
+    prompt: string;
+    duration: number;
+}>;

package/dist/catalog/shared/shotList.js

@@ -0,0 +1,48 @@
+/**
+ * 分镜列表参数的值结构与校验：`[{ id?, prompt, duration }]`，按顺序成片，总时长等于各镜秒数之和。
+ * 界面（生成面板与画布节点）共用同一个 `shot-list` 面板写入这个结构，请求构建只读这里。
+ */
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** 读出分镜；不是数组或没有镜头时返回空数组，表示没有使用分镜。 */
+export function readShots(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter(isObject).map((shot) => ({
+        prompt: typeof shot.prompt === 'string' ? shot.prompt.trim() : '',
+        duration: Math.round(Number(shot.duration)),
+    }));
+}
+/** 估价与界面汇总用：非法秒数按 0 计，结果夹在总时长范围内。 */
+export function shotTotalSeconds(value, limits) {
+    const total = readShots(value).reduce((sum, shot) => sum + (Number.isFinite(shot.duration) && shot.duration > 0 ? shot.duration : 0), 0);
+    return Math.min(limits.maxTotalSeconds, Math.max(limits.minTotalSeconds, total));
+}
+/**
+ * 提交前校验并转成供应商的 `multi_prompt` 结构；不合法时抛出能直接给用户看的原因。
+ * 平台的分镜与主提示词二选一，所以主提示词当作整体描述（人物、风格、场景）拼在每一镜前面，
+ * 每镜只写这一镜发生什么，不必重复交代。
+ */
+export function buildShotPrompts(value, limits, modelName, sharedPrompt = '') {
+    const shared = sharedPrompt.trim();
+    const shots = readShots(value).map(shot => ({ ...shot, prompt: shot.prompt && shared ? `${shared}\n${shot.prompt}` : shot.prompt }));
+    shots.forEach((shot, index) => {
+        const label = `${modelName} 第 ${index + 1} 镜`;
+        if (!shot.prompt)
+            throw new Error(`${label}的提示词不能为空`);
+        if (shot.prompt.length > limits.maxPromptLength) {
+            throw new Error(shared
+                ? `${label}加上主提示词后超过 ${limits.maxPromptLength} 字符，请缩短主提示词或这一镜`
+                : `${label}的提示词最多 ${limits.maxPromptLength} 字符`);
+        }
+        if (!Number.isInteger(shot.duration) || shot.duration < limits.minShotSeconds || shot.duration > limits.maxShotSeconds) {
+            throw new Error(`${label}的时长须为 ${limits.minShotSeconds}–${limits.maxShotSeconds} 秒`);
+        }
+    });
+    const total = shots.reduce((sum, shot) => sum + shot.duration, 0);
+    if (shots.length > 0 && (total < limits.minTotalSeconds || total > limits.maxTotalSeconds)) {
+        throw new Error(`${modelName} 分镜总时长须为 ${limits.minTotalSeconds}–${limits.maxTotalSeconds} 秒，当前 ${total} 秒`);
+    }
+    return shots.map(({ prompt, duration }) => ({ prompt, duration }));
+}

package/dist/catalog/shared/subjectElements.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 元素（角色 / 物体主体）参数的值结构与校验，供 Kling 4.0 在 Fal 与 KIE 上共用。
+ *
+ * 值结构：`[{ id?, name?, kind: 'image' | 'video', images: string[], videos: string[], videoSeconds? }]`，
+ * `videoSeconds` 是上传时读到的视频时长，只用于估价，不发给平台。
+ * 图片元素第 1 张是正面主图、其余是其他角度；视频元素只用一段 3–8 秒单镜头视频。
+ * Fal 在提示词里按顺序写 `@Element1`，KIE 写元素名 `@名称`，所以名称只对 KIE 有意义。
+ * 媒体值是本地受管路径，由公共上传预处理按字段名（`frontal_image_url`、`image_urls`、`video_url`）上传替换。
+ */
+import type { JsonObject, JsonValue } from '../../types/runtime.js';
+export interface SubjectElementEntry {
+    name: string;
+    kind: 'image' | 'video';
+    images: string[];
+    video?: string;
+    videoSeconds?: number;
+}
+/** 两家对元素的共同上限：最多 7 个，其中视频元素最多 3 个；图片元素 2–4 张图。 */
+export declare const SUBJECT_ELEMENT_LIMITS: {
+    readonly maxItems: 7;
+    readonly maxVideoItems: 3;
+    readonly minImages: 2;
+    readonly maxImages: 4;
+};
+export declare function readSubjectElements(value: JsonValue | undefined): SubjectElementEntry[];
+/** 视频元素按视频输入计费的总秒数：用上传时读到的时长，读不到按上限计。 */
+export declare function subjectElementVideoSeconds(value: JsonValue | undefined): number;
+/** Fal：图片元素拆成正面主图与其他角度，视频元素只给视频；提示词按顺序引用 `@Element1`。 */
+export declare function buildFalSubjectElements(value: JsonValue | undefined, modelName: string): JsonObject[];
+/**
+ * KIE：每个元素必须有唯一名称，提示词用 `@名称` 引用。
+ * Flash 端点用 `type` 区分图片与视频元素，标准版没有这个字段。
+ */
+export declare function buildKieSubjectElements(value: JsonValue | undefined, modelName: string, options: {
+    sendType: boolean;
+}): JsonObject[];