@orangecatai/adgen-canvas 0.0.40 → 0.1.0

package/dist/dev/chunk-2K6ZAAHB.js

@@ -0,0 +1,1535 @@
+import {
+  ADAPTIVE_ASPECT_RATIO,
+  MAX_USER_REFERENCE_IMAGES,
+  RESOLUTION_RANK
+} from "./chunk-LWUV2KR2.js";
+
+// modelCapabilities/shared.ts
+var MB = 1024 * 1024;
+var NO_FRAMES = {
+  start: { supported: false, maxImages: 0 },
+  end: { supported: false, maxImages: 0 },
+  allowsStartAndEndTogether: false,
+  endFrameRequiresStartFrame: false
+};
+var unchecked = {
+  maxImageBytes: null,
+  minEdgePx: null,
+  maxEdgePx: null,
+  inputPixels: null,
+  inputAspectRatioRange: null
+};
+
+// modelCapabilities/registry.image.ts
+var GEMINI_IMAGE_MIMES = [
+  "image/png",
+  "image/jpeg",
+  "image/webp",
+  "image/heic",
+  "image/heif"
+];
+var OPENAI_IMAGE_MIMES = ["image/png", "image/webp", "image/jpeg"];
+var SEEDREAM_IMAGE_MIMES = [
+  "image/jpeg",
+  "image/png",
+  "image/webp",
+  "image/bmp",
+  "image/tiff",
+  "image/gif",
+  "image/heic",
+  "image/heif"
+];
+var XAI_IMAGE_MIMES = ["image/jpeg", "image/png", "image/webp"];
+var GEMINI_IMAGE_DOCS = [
+  "https://ai.google.dev/gemini-api/docs/image-generation",
+  "https://ai.google.dev/gemini-api/docs/image-understanding"
+];
+var GEMINI_ASPECT_RATIOS = [
+  "21:9",
+  "16:9",
+  "4:3",
+  "3:2",
+  "1:1",
+  "9:16",
+  "3:4",
+  "2:3",
+  "5:4",
+  "4:5",
+  "4:1",
+  "1:4",
+  "8:1",
+  "1:8"
+];
+var GEMINI_ASSETS = {
+  imageMimeTypes: GEMINI_IMAGE_MIMES,
+  // No PER-FILE cap is documented. The 20 MB figure is the documented
+  // aggregate inline-request cap, which necessarily bounds a single image too,
+  // so this is a derivation rather than a guess.
+  maxImageBytes: 20 * MB,
+  minEdgePx: null,
+  maxEdgePx: null,
+  inputPixels: null,
+  inputAspectRatioRange: null,
+  maxRequestBytes: 20 * MB
+};
+var GEMINI_UNKNOWN_NOTES = {
+  "controls.aspectRatios": "Docs state 14 supported ratios but enumerate only the newly added ones. Keeping all 14; verify against a live call before trusting the tail.",
+  "assets.minEdgePx": "No input dimension floor documented. Left unchecked rather than inventing one, which would reject valid images.",
+  "assets.maxEdgePx": "No input dimension ceiling documented; docs only note that large images are tiled into 768x768 tiles."
+};
+var geminiFlashImage = {
+  modelId: "google/gemini-3.1-flash-image",
+  modality: "image",
+  verified: {
+    sources: [
+      ...GEMINI_IMAGE_DOCS,
+      "https://ai.google.dev/gemini-api/docs/models/gemini-3.1-flash-image"
+    ],
+    checkedOn: "2026-09-11"
+  },
+  unknownFields: [
+    "controls.aspectRatios",
+    "assets.minEdgePx",
+    "assets.maxEdgePx"
+  ],
+  unknownNotes: GEMINI_UNKNOWN_NOTES,
+  references: {
+    supported: true,
+    grouping: "flat",
+    // "Up to 10 images of objects" + "Up to 4 images of characters".
+    maxImages: 14,
+    maxVideos: 0,
+    maxAudios: 0,
+    acceptsImageAndVideoReferences: false,
+    canCombineWithStartFrame: false,
+    canCombineWithEndFrame: false
+  },
+  frames: NO_FRAMES,
+  assets: GEMINI_ASSETS,
+  controls: {
+    aspectRatioMode: "settable",
+    aspectRatios: GEMINI_ASPECT_RATIOS,
+    // "support for 0.5K, 2K and 4K, default 1K"
+    resolutions: ["0.5K", "1K", "2K", "4K"],
+    audio: "none",
+    supportsNegativePrompt: false,
+    supportsSeed: false
+  },
+  constraints: []
+};
+var geminiFlashLiteImage = {
+  ...geminiFlashImage,
+  modelId: "google/gemini-3.1-flash-lite-image",
+  verified: {
+    sources: [
+      ...GEMINI_IMAGE_DOCS,
+      "https://ai.google.dev/gemini-api/docs/models/gemini-3.1-flash-lite-image"
+    ],
+    checkedOn: "2026-09-11"
+  },
+  references: {
+    ...geminiFlashImage.references,
+    // "Up to 14 images of objects". Unlike Flash, no character-reference
+    // capability is documented for Flash-Lite.
+    maxImages: 14
+  },
+  controls: {
+    ...geminiFlashImage.controls,
+    // "Optimized for lower resolutions of 1K (1024x1024px)";
+    // "(Note: 2K and 4K are unsupported)".
+    resolutions: ["1K"]
+  }
+};
+var OPENAI_IMAGE_DOCS = [
+  "https://developers.openai.com/api/reference/python/resources/images/methods/edit",
+  "https://developers.openai.com/api/docs/guides/image-prompting",
+  "https://developers.openai.com/api/docs/guides/image-generation"
+];
+var OPENAI_ASPECT_RATIOS = [
+  "21:9",
+  "16:9",
+  "4:3",
+  "3:2",
+  "1:1",
+  "9:16",
+  "3:4",
+  "2:3"
+];
+var gptImage25Flare = {
+  modelId: "openai/gpt-image-2.5-flare",
+  modality: "image",
+  verified: { sources: OPENAI_IMAGE_DOCS, checkedOn: "2026-09-11" },
+  unknownFields: ["assets.maxRequestBytes"],
+  unknownNotes: {
+    "assets.maxRequestBytes": "Only the per-image 50 MB and per-mask 4 MB caps are documented; no whole-request cap."
+  },
+  references: {
+    supported: true,
+    grouping: "flat",
+    // "You can provide up to 16 images."
+    maxImages: 16,
+    maxVideos: 0,
+    maxAudios: 0,
+    acceptsImageAndVideoReferences: false,
+    canCombineWithStartFrame: false,
+    canCombineWithEndFrame: false
+  },
+  frames: NO_FRAMES,
+  assets: {
+    imageMimeTypes: OPENAI_IMAGE_MIMES,
+    // "each image should be a png, webp, or jpg file less than 50MB"
+    maxImageBytes: 50 * MB,
+    minEdgePx: null,
+    maxEdgePx: null,
+    inputPixels: null,
+    inputAspectRatioRange: null,
+    maxRequestBytes: null
+  },
+  controls: {
+    aspectRatioMode: "settable",
+    aspectRatios: OPENAI_ASPECT_RATIOS,
+    resolutions: ["1K", "2K"],
+    audio: "none",
+    supportsNegativePrompt: false,
+    supportsSeed: false,
+    outputPixels: { min: 655360, max: 8294400 },
+    outputEdge: { max: 3840, multipleOf: 16 },
+    maxOutputEdgeRatio: 3
+  },
+  constraints: []
+};
+var gptImage25Sunburst = {
+  ...gptImage25Flare,
+  modelId: "openai/gpt-image-2.5-sunburst"
+};
+var SEEDREAM_DOCS = [
+  "https://docs.byteplus.com/en/docs/ModelArk/1541523",
+  "https://docs.volcengine.com/docs/82379/1541523"
+];
+var SEEDREAM_ASSETS = {
+  imageMimeTypes: SEEDREAM_IMAGE_MIMES,
+  // "Size: Up to 30 MB"
+  maxImageBytes: 30 * MB,
+  // "Width and height (px): > 14"
+  minEdgePx: 15,
+  maxEdgePx: null,
+  // "Total pixels: [196, 6000x6000 (36,000,000)]" -- the product is bounded,
+  // not either edge individually.
+  inputPixels: { min: 196, max: 36e6 },
+  // "Aspect ratio (width / height): [1/16, 16]"
+  inputAspectRatioRange: [1 / 16, 16],
+  maxRequestBytes: null
+};
+var SEEDREAM_ASPECT_RATIOS = [
+  "21:9",
+  "16:9",
+  "4:3",
+  "3:2",
+  "1:1",
+  "9:16",
+  "3:4",
+  "2:3",
+  "5:4",
+  "4:5"
+];
+var seedream50Lite = {
+  modelId: "bytedance-seed/seedream-5-0-lite",
+  modality: "image",
+  verified: { sources: SEEDREAM_DOCS, checkedOn: "2026-09-11" },
+  unknownFields: ["assets.maxEdgePx", "assets.maxRequestBytes"],
+  unknownNotes: {
+    "assets.maxEdgePx": "Docs bound total pixels rather than either edge; see assets.inputPixels.",
+    "assets.maxRequestBytes": "No whole-request cap documented for the image API."
+  },
+  references: {
+    supported: true,
+    grouping: "flat",
+    // "Seedream 5.0 lite, 4.5, and 4.0 support up to 14 reference images."
+    maxImages: 14,
+    maxVideos: 0,
+    maxAudios: 0,
+    acceptsImageAndVideoReferences: false,
+    canCombineWithStartFrame: false,
+    canCombineWithEndFrame: false
+  },
+  frames: NO_FRAMES,
+  assets: SEEDREAM_ASSETS,
+  controls: {
+    aspectRatioMode: "settable",
+    aspectRatios: SEEDREAM_ASPECT_RATIOS,
+    // Lite and Pro have DISJOINT resolution ladders -- they are not drop-in
+    // substitutes for one another.
+    resolutions: ["2K", "3K", "4K"],
+    audio: "none",
+    supportsNegativePrompt: false,
+    supportsSeed: false,
+    // "Total pixels range: [2560x1440(3,686,400), 4096x4096(16,777,216)]"
+    outputPixels: { min: 3686400, max: 16777216 }
+  },
+  constraints: [],
+  providerCaveats: [
+    "Input reference images plus generated images must total 15 or fewer."
+  ]
+};
+var seedream50Pro = {
+  ...seedream50Lite,
+  modelId: "bytedance-seed/seedream-5-0-pro",
+  references: {
+    ...seedream50Lite.references,
+    // "Seedream 5.0 pro supports up to 10 reference images."
+    maxImages: 10
+  },
+  controls: {
+    ...seedream50Lite.controls,
+    resolutions: ["1K", "1.5K", "2K"],
+    // "Total pixels range: [1280x720(921,600), 2048x2048x1.1025(4,624,220)]"
+    outputPixels: { min: 921600, max: 4624220 }
+  },
+  providerCaveats: [
+    "Layer decomposition accepts exactly one input image and yields at most 16 layers.",
+    "Sequential image generation and streaming are not supported on Pro."
+  ]
+};
+var grokImagineImage20 = {
+  modelId: "x-ai/grok-imagine-image-2.0",
+  modality: "image",
+  verified: {
+    sources: [
+      "https://docs.x.ai/developers/rest-api-reference/inference/images",
+      "https://docs.x.ai/developers/model-capabilities/images/multi-image-editing"
+    ],
+    checkedOn: "2026-09-11"
+  },
+  unknownFields: [
+    "assets.maxImageBytes",
+    "assets.minEdgePx",
+    "assets.maxEdgePx",
+    "assets.inputPixels"
+  ],
+  unknownNotes: {
+    "assets.maxImageBytes": "xAI's documented 20 MiB / jpg-png limit is scoped to CHAT vision models and contradicts Imagine's documented WebP support, so it is deliberately not carried over. Left unchecked; the transport guard binds first anyway.",
+    "assets.minEdgePx": "No input dimension floor documented.",
+    "assets.maxEdgePx": "No input dimension ceiling documented.",
+    "assets.inputPixels": "No input pixel bound documented."
+  },
+  references: {
+    supported: true,
+    grouping: "flat",
+    // "Multi-image editing supports up to 5 source images in a single request"
+    maxImages: 5,
+    maxVideos: 0,
+    maxAudios: 0,
+    acceptsImageAndVideoReferences: false,
+    canCombineWithStartFrame: false,
+    canCombineWithEndFrame: false
+  },
+  frames: NO_FRAMES,
+  assets: {
+    imageMimeTypes: XAI_IMAGE_MIMES,
+    ...unchecked,
+    maxRequestBytes: null
+  },
+  controls: {
+    aspectRatioMode: "settable",
+    aspectRatios: [
+      "16:9",
+      "4:3",
+      "3:2",
+      "1:1",
+      "9:16",
+      "3:4",
+      "2:3",
+      "5:4",
+      "4:5"
+    ],
+    resolutions: ["1K", "2K"],
+    audio: "none",
+    supportsNegativePrompt: false,
+    supportsSeed: false
+  },
+  constraints: [],
+  providerCaveats: [
+    "The `images[]` array is mutually exclusive with the single `image` field.",
+    "By default the output ratio follows the first input image unless aspect_ratio is set."
+  ]
+};
+var maiImage26Flash = {
+  modelId: "microsoft/mai-image-2.6-flash",
+  modality: "image",
+  verified: {
+    sources: [
+      "https://learn.microsoft.com/en-us/azure/foundry/foundry-models/how-to/use-foundry-models-mai-image",
+      "https://microsoft.ai/pdf/MAI-Image-2.6-Model-Card.pdf"
+    ],
+    checkedOn: "2026-09-11"
+  },
+  unknownFields: [
+    "references.maxImages",
+    "assets.maxImageBytes",
+    "assets.minEdgePx",
+    "assets.maxEdgePx",
+    "assets.inputPixels"
+  ],
+  unknownNotes: {
+    "references.maxImages": "The edits endpoint documents a single `image` multipart field and no multi-image cap. Conservative default of 1 -- the tightest limit of any registered model, and the reason Quick Edit must not spend the slot on a user reference.",
+    "assets.maxImageBytes": "No input file size cap documented.",
+    "assets.minEdgePx": "The 768 px floor is documented for output width/height, not for input images.",
+    "assets.maxEdgePx": "No input dimension ceiling documented.",
+    "assets.inputPixels": "No input pixel bound documented."
+  },
+  references: {
+    supported: true,
+    grouping: "flat",
+    maxImages: 1,
+    maxVideos: 0,
+    maxAudios: 0,
+    acceptsImageAndVideoReferences: false,
+    canCombineWithStartFrame: false,
+    canCombineWithEndFrame: false
+  },
+  frames: NO_FRAMES,
+  assets: {
+    imageMimeTypes: ["image/jpeg", "image/png"],
+    ...unchecked,
+    maxRequestBytes: null
+  },
+  controls: {
+    aspectRatioMode: "settable",
+    // 21:9 is deliberately absent: at the documented 768 px per-side minimum
+    // it would need 1792x768 = 1,376,256 pixels, over the 1,048,576 cap.
+    aspectRatios: ["1:1", "16:9", "3:2", "4:3", "3:4", "2:3", "9:16"],
+    resolutions: ["1K"],
+    audio: "none",
+    supportsNegativePrompt: false,
+    supportsSeed: false,
+    // Microsoft's two first-party docs conflict: Learn says 1,048,576 and
+    // documents the 400 that enforces it; the model card PDF says 2,359,296.
+    // Take the lower, demonstrably enforced figure.
+    outputPixels: { min: 768 * 768, max: 1048576 },
+    outputEdge: { min: 768 }
+  },
+  constraints: [],
+  providerCaveats: [
+    "Output is always PNG, and exactly one image per request.",
+    "Learn documents a 1,048,576 output pixel cap; the model card PDF claims 2,359,296. The lower figure is enforced."
+  ]
+};
+var IMAGE_MODEL_CAPABILITIES = [
+  geminiFlashImage,
+  geminiFlashLiteImage,
+  gptImage25Flare,
+  gptImage25Sunburst,
+  seedream50Lite,
+  seedream50Pro,
+  grokImagineImage20,
+  maiImage26Flash
+];
+
+// modelCapabilities/registry.video.ts
+var VEO_DOCS = ["https://ai.google.dev/gemini-api/docs/veo"];
+var VEO_ASSET_UNKNOWNS = [
+  "assets.imageMimeTypes",
+  "assets.maxImageBytes",
+  "assets.minEdgePx",
+  "assets.maxEdgePx",
+  "assets.inputPixels",
+  "assets.inputAspectRatioRange"
+];
+var VEO_ASSETS = {
+  // Empty list means "do not check" -- see `unchecked` in ./shared.
+  imageMimeTypes: [],
+  ...unchecked,
+  maxRequestBytes: null
+};
+var veo31Fast = {
+  modelId: "google/veo-3.1-fast",
+  modality: "video",
+  verified: {
+    sources: [
+      ...VEO_DOCS,
+      "https://ai.google.dev/gemini-api/docs/models/veo-3.1-generate-preview"
+    ],
+    checkedOn: "2026-09-11"
+  },
+  unknownFields: [
+    "references.canCombineWithStartFrame",
+    "references.canCombineWithEndFrame",
+    "controls.supportsNegativePrompt",
+    ...VEO_ASSET_UNKNOWNS
+  ],
+  unknownNotes: {
+    "references.canCombineWithStartFrame": "Google documents neither permission nor prohibition. The guide establishes that referenceImages accepts up to 3, that lastFrame requires image, and that duration must be 8 when using reference images -- but never whether references and frames may coexist. Defaulted to `false` so the combination is blocked as REFERENCE_FRAME_COMBINATION_UNVERIFIED rather than discovered by the provider after charging.",
+    "references.canCombineWithEndFrame": "Same gap as canCombineWithStartFrame.",
+    "controls.supportsNegativePrompt": "Absent from the Gemini API Veo parameter table, but Vertex accepts negativePrompt inside the google-vertex `parameters` block, which is how the host forwards it today. Defaulted to supported so validation does not reject a working passthrough; confirm against the Vertex reference.",
+    "assets.imageMimeTypes": "Not stated in the Gemini API Veo guide; the Vertex AI pages do not serve their body.",
+    "assets.maxImageBytes": "Not stated.",
+    "assets.minEdgePx": "Not stated.",
+    "assets.maxEdgePx": "Not stated.",
+    "assets.inputPixels": "Not stated.",
+    "assets.inputAspectRatioRange": "Not stated."
+  },
+  references: {
+    supported: true,
+    grouping: "flat",
+    // "up to three asset images of a single person, character, or product"
+    maxImages: 3,
+    maxVideos: 0,
+    maxAudios: 0,
+    acceptsImageAndVideoReferences: false,
+    canCombineWithStartFrame: false,
+    canCombineWithEndFrame: false
+  },
+  frames: {
+    start: { supported: true, maxImages: 1 },
+    end: { supported: true, maxImages: 1 },
+    allowsStartAndEndTogether: true,
+    // "Must be used in combination with the `image` parameter"
+    endFrameRequiresStartFrame: true
+  },
+  assets: VEO_ASSETS,
+  controls: {
+    aspectRatioMode: "settable",
+    aspectRatios: ["16:9", "9:16"],
+    resolutions: ["720p", "1080p", "4K"],
+    durationsSeconds: [4, 6, 8],
+    audio: "always-on",
+    supportsNegativePrompt: true,
+    // "It doesn't guarantee determinism, but slightly improves it"
+    supportsSeed: true
+  },
+  constraints: [
+    {
+      whenAny: [
+        { kind: "hasReferences" },
+        { kind: "resolutionIn", values: ["1080p", "4K"] }
+      ],
+      requires: { kind: "durationMustBe", seconds: 8 },
+      message: "Veo 3.1 requires an 8 second duration when using reference images, 1080p or 4K."
+    }
+  ],
+  providerCaveats: [
+    "personGeneration is restricted to allow_adult for image-to-video, interpolation and reference-image modes.",
+    "Video extension is 720p only."
+  ]
+};
+var veo31Lite = {
+  modelId: "google/veo-3.1-lite",
+  modality: "video",
+  verified: {
+    sources: [
+      ...VEO_DOCS,
+      "https://ai.google.dev/gemini-api/docs/models/veo-3.1-lite-generate-preview"
+    ],
+    checkedOn: "2026-09-11"
+  },
+  unknownFields: [
+    "controls.supportsSeed",
+    "controls.supportsNegativePrompt",
+    ...VEO_ASSET_UNKNOWNS
+  ],
+  unknownNotes: {
+    "controls.supportsNegativePrompt": "Same Vertex passthrough as Veo 3.1 Fast \u2014 see that record's note.",
+    "controls.supportsSeed": "The guide's seed note refers to 'Veo 3 models' generically and is not confirmed per-model for Lite. Defaulted to unsupported so we never send a parameter the model may reject.",
+    "assets.imageMimeTypes": "Not stated.",
+    "assets.maxImageBytes": "Not stated.",
+    "assets.minEdgePx": "Not stated.",
+    "assets.maxEdgePx": "Not stated.",
+    "assets.inputPixels": "Not stated.",
+    "assets.inputAspectRatioRange": "Not stated."
+  },
+  references: {
+    // `referenceImages` is explicitly `n/a` for Veo 3.1 Lite.
+    supported: false,
+    grouping: "flat",
+    maxImages: 0,
+    maxVideos: 0,
+    maxAudios: 0,
+    acceptsImageAndVideoReferences: false,
+    canCombineWithStartFrame: false,
+    canCombineWithEndFrame: false
+  },
+  frames: veo31Fast.frames,
+  assets: VEO_ASSETS,
+  controls: {
+    aspectRatioMode: "settable",
+    aspectRatios: ["16:9", "9:16"],
+    // "Veo 3.1 Lite Preview does not support 4K outputs or Extension."
+    resolutions: ["720p", "1080p"],
+    durationsSeconds: [4, 6, 8],
+    audio: "always-on",
+    supportsNegativePrompt: true,
+    supportsSeed: false
+  },
+  constraints: [
+    {
+      whenAny: [{ kind: "resolutionIn", values: ["1080p"] }],
+      requires: { kind: "durationMustBe", seconds: 8 },
+      message: "Veo 3.1 Lite requires an 8 second duration for 1080p output."
+    }
+  ]
+};
+var KLING_DOCS = [
+  "https://klingai.com/document-api/api/video/3-0-omni/image-to-video",
+  "https://klingai.com/document-api/api/video/3-0-omni/elements",
+  "https://klingai.com/document-api/guides/capability-map/video"
+];
+var klingBase = {
+  modality: "video",
+  verified: { sources: KLING_DOCS, checkedOn: "2026-09-11" },
+  unknownFields: ["assets.maxEdgePx", "assets.inputPixels"],
+  unknownNotes: {
+    "assets.maxEdgePx": "Only the 300 px floor is documented; no ceiling is stated.",
+    "assets.inputPixels": "No input pixel bound documented."
+  },
+  references: {
+    supported: true,
+    // Kling references are nested SUBJECTS, not a flat list: each Element is
+    // built from "at least 1 frontal reference image" plus "1-3 other
+    // reference images" that must differ from it.
+    grouping: "elements",
+    maxGroups: 3,
+    imagesPerGroup: { min: 2, max: 4 },
+    maxImages: 12,
+    maxVideos: 0,
+    maxAudios: 0,
+    acceptsImageAndVideoReferences: false,
+    canCombineWithStartFrame: true,
+    canCombineWithEndFrame: true
+  },
+  frames: {
+    start: { supported: true, maxImages: 1 },
+    end: { supported: true, maxImages: 1 },
+    allowsStartAndEndTogether: true,
+    // "Supports first-frame-to-video and first-and-last-frame-to-video
+    // generation; last-frame-only video generation is not supported."
+    endFrameRequiresStartFrame: true
+  },
+  assets: {
+    imageMimeTypes: ["image/jpeg", "image/png"],
+    // 50 MB on the current API; the legacy /v1/videos/image2video endpoint
+    // caps at 10 MB.
+    maxImageBytes: 50 * MB,
+    minEdgePx: 300,
+    maxEdgePx: null,
+    inputPixels: null,
+    // "The image aspect ratio must be between 1:2.5 and 2.5:1."
+    inputAspectRatioRange: [0.4, 2.5],
+    maxRequestBytes: null
+  },
+  constraints: [],
+  providerCaveats: [
+    "Image-to-video has no aspect_ratio parameter; the output ratio follows the first frame.",
+    "Prompt length must not exceed 3072 characters.",
+    "Multi-image reference-to-video (as distinct from Elements) is not supported on Kling 3.0."
+  ]
+};
+var KLING_CONTROLS = {
+  // Text-to-video accepts an explicit ratio; image-to-video has no such
+  // parameter at all, so the control must disappear once a frame is attached.
+  aspectRatioMode: "notApplicableWithFrames",
+  aspectRatios: ["16:9", "9:16", "1:1"],
+  minDurationSeconds: 3,
+  maxDurationSeconds: 15,
+  // `audio` defaults to `off` on Kling, unlike every other toggle model here.
+  audio: "toggle-default-off",
+  // The current API folds negative guidance into `prompt`; the legacy
+  // image2video endpoint documents a `negative_prompt` field (max 2500
+  // chars). Either way the provider accepts negative guidance, so rejecting
+  // it here would be wrong.
+  supportsNegativePrompt: true,
+  supportsSeed: false
+};
+var klingV3Pro = {
+  ...klingBase,
+  modelId: "kwaivgi/kling-v3.0-pro",
+  controls: { ...KLING_CONTROLS, resolutions: ["1080p", "4K"] }
+};
+var klingV3Std = {
+  ...klingBase,
+  modelId: "kwaivgi/kling-v3.0-std",
+  controls: { ...KLING_CONTROLS, resolutions: ["720p"] }
+};
+var SEEDANCE_DOCS = [
+  "https://docs.byteplus.com/en/docs/ModelArk/1520757",
+  "https://docs.byteplus.com/en/docs/ModelArk/2607688"
+];
+var SEEDANCE_ASSETS = {
+  imageMimeTypes: [
+    "image/jpeg",
+    "image/png",
+    "image/webp",
+    "image/bmp",
+    "image/tiff",
+    "image/gif",
+    "image/heic",
+    "image/heif"
+  ],
+  // "Single image must be less than 30 MB"
+  maxImageBytes: 30 * MB,
+  // "Width and height (px): [300, 6000]"
+  minEdgePx: 300,
+  maxEdgePx: 6e3,
+  inputPixels: null,
+  // "Aspect ratio (width/height): [0.4, 2.5]"
+  inputAspectRatioRange: [0.4, 2.5],
+  // "Request body size does not exceed 64 MB."
+  maxRequestBytes: 64 * MB
+};
+var SEEDANCE_CAVEATS = [
+  "Reference images and videos containing real human faces are rejected. Use model-generated faces, preset digital characters (asset://), or authorized assets.",
+  "The first and last frame images may be identical; mismatched ratios crop the last frame to the first."
+];
+var seedance20Mini = {
+  modelId: "bytedance/seedance-2.0-mini",
+  modality: "video",
+  verified: { sources: SEEDANCE_DOCS, checkedOn: "2026-09-11" },
+  unknownFields: ["controls.supportsNegativePrompt"],
+  unknownNotes: {
+    "controls.supportsNegativePrompt": "The word 'negative' does not appear anywhere in the video generation API reference. Defaulted to unsupported."
+  },
+  references: {
+    supported: true,
+    grouping: "flat",
+    // "Dreamina Seedance 2.0 series (1-9 images)"
+    maxImages: 9,
+    maxVideos: 3,
+    maxAudios: 3,
+    // "15 (9 images + 3 videos + 3 audios)"
+    maxTotalAssets: 15,
+    acceptsImageAndVideoReferences: true,
+    // Documented prohibition, NOT a conservative default.
+    canCombineWithStartFrame: false,
+    canCombineWithEndFrame: false
+  },
+  frames: {
+    start: { supported: true, maxImages: 1 },
+    end: { supported: true, maxImages: 1 },
+    allowsStartAndEndTogether: true,
+    // Only "first frame" and "first and last frames" are documented modes;
+    // there is no last-frame-only mode.
+    endFrameRequiresStartFrame: true
+  },
+  assets: SEEDANCE_ASSETS,
+  controls: {
+    // "ratio must be adaptive" once a first frame is supplied.
+    aspectRatioMode: "forcedAdaptiveWithFrames",
+    // 9:21 is NOT supported, despite previously appearing in our registry.
+    aspectRatios: ["16:9", "4:3", "1:1", "3:4", "9:16", "21:9", "adaptive"],
+    resolutions: ["480p", "720p"],
+    minDurationSeconds: 4,
+    maxDurationSeconds: 15,
+    supportsAutoDuration: true,
+    audio: "toggle-default-on",
+    supportsNegativePrompt: false,
+    // `seed` exists on the shared video API but its "Supported models" list
+    // names only Seedance 1.5 pro and 1.0 pro -- 2.x is deliberately absent.
+    supportsSeed: false
+  },
+  constraints: [],
+  providerCaveats: [
+    ...SEEDANCE_CAVEATS,
+    "Audio-only references are not supported; an image or video reference is required."
+  ]
+};
+var seedance25 = {
+  ...seedance20Mini,
+  modelId: "bytedance/seedance-2.5",
+  references: {
+    ...seedance20Mini.references,
+    // "Dreamina Seedance 2.5 (1-30 images)"
+    maxImages: 30,
+    maxVideos: 10,
+    maxAudios: 10,
+    // "50 (30 images + 10 video clips + 10 audio clips)"
+    maxTotalAssets: 50
+  },
+  controls: {
+    ...seedance20Mini.controls,
+    resolutions: ["480p", "720p", "1080p"],
+    maxDurationSeconds: 30
+  },
+  providerCaveats: SEEDANCE_CAVEATS
+};
+var grokImagineVideo15 = {
+  modelId: "x-ai/grok-imagine-video-1.5",
+  modality: "video",
+  verified: {
+    sources: [
+      "https://docs.x.ai/developers/rest-api-reference/inference/videos",
+      "https://docs.x.ai/developers/model-capabilities/video",
+      "https://docs.x.ai/developers/model-capabilities/video/reference-to-video"
+    ],
+    checkedOn: "2026-09-11"
+  },
+  unknownFields: [
+    "references.maxImages",
+    "assets.maxImageBytes",
+    "assets.minEdgePx",
+    "assets.maxEdgePx",
+    "assets.inputPixels"
+  ],
+  unknownNotes: {
+    "references.maxImages": "The schema caps reference_audios at 3 entries but states no cap for reference_images. Defaulted to 3 to match the documented audio cap and the docs' own examples. The 5-image figure in xAI's docs is scoped to IMAGE editing, not video, and is deliberately not carried over.",
+    "assets.maxImageBytes": "Not stated for video inputs.",
+    "assets.minEdgePx": "Not stated.",
+    "assets.maxEdgePx": "Not stated.",
+    "assets.inputPixels": "Not stated."
+  },
+  references: {
+    supported: true,
+    grouping: "flat",
+    maxImages: 3,
+    maxVideos: 0,
+    // "Max 3 voices per request"
+    maxAudios: 3,
+    acceptsImageAndVideoReferences: false,
+    // The ONLY registered model that explicitly permits this.
+    canCombineWithStartFrame: true,
+    canCombineWithEndFrame: true
+  },
+  frames: {
+    start: { supported: true, maxImages: 1 },
+    end: { supported: true, maxImages: 1 },
+    allowsStartAndEndTogether: true,
+    // "last_frame only | Pinned last frame. The model generates the opening
+    // and lands on the pinned image." -- a documented standalone mode.
+    endFrameRequiresStartFrame: false
+  },
+  assets: {
+    imageMimeTypes: ["image/jpeg", "image/png", "image/webp"],
+    ...unchecked,
+    maxRequestBytes: null
+  },
+  controls: {
+    aspectRatioMode: "settable",
+    aspectRatios: ["1:1", "16:9", "9:16", "4:3", "3:4", "3:2", "2:3"],
+    resolutions: ["480p", "720p", "1080p"],
+    minDurationSeconds: 1,
+    maxDurationSeconds: 15,
+    audio: "toggle-default-on",
+    supportsNegativePrompt: false,
+    supportsSeed: false
+  },
+  constraints: [
+    {
+      whenAny: [{ kind: "hasReferences" }],
+      requires: { kind: "resolutionAtMost", value: "720p" },
+      message: "Grok Imagine Video caps reference-to-video at 720p; 1080p is available only for text-to-video and image-to-video."
+    }
+  ],
+  providerCaveats: [
+    "Prompt is optional whenever image, reference_images or last_frame is supplied.",
+    "The legacy grok-imagine-video model rejects last_frame and rejects combining image with reference inputs; 1.5 does not."
+  ]
+};
+var WAN_DOCS = [
+  "https://help.aliyun.com/zh/model-studio/wan3-video-generation-api-reference"
+];
+var wanBase = {
+  modality: "video",
+  unknownFields: ["frames.endFrameRequiresStartFrame", "controls.supportsNegativePrompt"],
+  unknownNotes: {
+    "frames.endFrameRequiresStartFrame": "The docs enumerate the permitted material combinations and warn that 'passing other combinations returns an error', but a last-frame-only combination is not among those listed. Defaulted to requiring a start frame rather than sending an unlisted combination.",
+    "controls.supportsNegativePrompt": "No negative_prompt field exists on the API reference; the adjacent knob is prompt_extend. Defaulted to unsupported."
+  },
+  references: {
+    supported: true,
+    grouping: "flat",
+    // "reference_image: reference image. At most 10."
+    maxImages: 10,
+    maxVideos: 5,
+    maxAudios: 5,
+    acceptsImageAndVideoReferences: true,
+    // Documented prohibition, quoted at the top of this file.
+    canCombineWithStartFrame: false,
+    canCombineWithEndFrame: false
+  },
+  frames: {
+    start: { supported: true, maxImages: 1 },
+    end: { supported: true, maxImages: 1 },
+    allowsStartAndEndTogether: true,
+    endFrameRequiresStartFrame: true
+  },
+  assets: {
+    imageMimeTypes: ["image/jpeg", "image/png", "image/bmp", "image/webp"],
+    // "File size: no more than 20MB."
+    maxImageBytes: 20 * MB,
+    // "Resolution: single side [240, 8000] pixels."
+    minEdgePx: 240,
+    maxEdgePx: 8e3,
+    inputPixels: null,
+    // "Aspect ratio: no more than 8:1."
+    inputAspectRatioRange: [1 / 8, 8],
+    maxRequestBytes: null
+  },
+  controls: {
+    aspectRatioMode: "settable",
+    aspectRatios: ["adaptive", "16:9", "4:3", "1:1", "3:4", "9:16"],
+    resolutions: ["480p", "720p", "1080p"],
+    minDurationSeconds: 2,
+    maxDurationSeconds: 30,
+    supportsAutoDuration: true,
+    audio: "toggle-default-on",
+    supportsNegativePrompt: false,
+    // "seed integer (optional) random seed, used to reproduce results."
+    supportsSeed: true
+  },
+  constraints: [],
+  providerCaveats: [
+    "Input PNGs must not carry an alpha channel.",
+    "Input aspect ratio must not exceed 8:1.",
+    "With a video input, input duration plus output duration must not exceed 30 seconds.",
+    "reference_image, reference_video and reference_audio combine freely with each other, but never with a frame."
+  ]
+};
+var wan30Prime = {
+  ...wanBase,
+  modelId: "alibaba/wan-3.0-prime",
+  verified: {
+    sources: [
+      ...WAN_DOCS,
+      "https://www.alibabacloud.com/help/zh/model-studio/wan3-0-video-prime"
+    ],
+    checkedOn: "2026-09-11"
+  }
+};
+var wan30 = {
+  ...wanBase,
+  modelId: "alibaba/wan-3.0",
+  verified: {
+    sources: [
+      ...WAN_DOCS,
+      "https://www.alibabacloud.com/help/zh/model-studio/wan3-0-video"
+    ],
+    checkedOn: "2026-09-11"
+  }
+};
+var VIDEO_MODEL_CAPABILITIES = [
+  veo31Fast,
+  veo31Lite,
+  klingV3Pro,
+  klingV3Std,
+  seedance20Mini,
+  seedance25,
+  grokImagineVideo15,
+  wan30Prime,
+  wan30
+];
+
+// modelCapabilities/validate.ts
+var AUTO_DURATION = -1;
+var asList = (value) => {
+  if (!value) {
+    return [];
+  }
+  return Array.isArray(value) ? value : [value];
+};
+function normalizeInputs(raw) {
+  const startFrames = asList(raw.startFrame);
+  const endFrames = asList(raw.endFrame);
+  return {
+    startFrame: startFrames[0] ?? null,
+    endFrame: endFrames[0] ?? null,
+    startFrameCount: startFrames.length,
+    endFrameCount: endFrames.length,
+    referenceImages: raw.referenceImages ? [...raw.referenceImages] : [],
+    referenceVideos: raw.referenceVideos ? [...raw.referenceVideos] : [],
+    referenceAudios: raw.referenceAudios ? [...raw.referenceAudios] : [],
+    referenceGroups: raw.referenceGroups ? [...raw.referenceGroups] : [],
+    sourceImage: raw.sourceImage ?? null,
+    brandLogo: raw.brandLogo ?? null,
+    hostReferences: raw.hostReferences ? [...raw.hostReferences] : []
+  };
+}
+function groupImages(group) {
+  return [group.frontal, ...group.additional].filter(Boolean);
+}
+function providerCountedImages(caps, inputs) {
+  const grouped = caps.references.grouping === "elements" ? inputs.referenceGroups.flatMap(groupImages) : [];
+  return [
+    ...inputs.referenceImages,
+    ...grouped,
+    ...inputs.sourceImage ? [inputs.sourceImage] : [],
+    ...inputs.brandLogo ? [inputs.brandLogo] : [],
+    ...inputs.hostReferences
+  ];
+}
+function effectiveUserReferenceLimit(caps, reserved, globalLimit = MAX_USER_REFERENCE_IMAGES) {
+  if (!caps.references.supported) {
+    return 0;
+  }
+  return Math.max(0, Math.min(globalLimit, caps.references.maxImages - reserved));
+}
+var hasBytes = (asset) => asset.dataUrl !== "";
+function validateAsset(caps, asset, field) {
+  const errors = [];
+  const { assets } = caps;
+  if (!hasBytes(asset)) {
+    return errors;
+  }
+  if (assets.imageMimeTypes.length > 0 && asset.mimeType && !assets.imageMimeTypes.includes(asset.mimeType.toLowerCase())) {
+    errors.push({
+      code: "UNSUPPORTED_MEDIA_TYPE",
+      modelId: caps.modelId,
+      field,
+      message: `${caps.modelId} does not accept ${asset.mimeType} input images.`,
+      allowed: assets.imageMimeTypes,
+      received: asset.mimeType
+    });
+  }
+  if (assets.maxImageBytes != null && (asset.bytes ?? 0) > assets.maxImageBytes) {
+    errors.push({
+      code: "REQUEST_TOO_LARGE",
+      modelId: caps.modelId,
+      field,
+      message: `${field} is larger than the ${Math.round(
+        assets.maxImageBytes / (1024 * 1024)
+      )} MB per-image limit for ${caps.modelId}.`,
+      allowed: assets.maxImageBytes,
+      received: asset.bytes
+    });
+  }
+  const { widthPx: w, heightPx: h } = asset;
+  if (w == null || h == null || w <= 0 || h <= 0) {
+    return errors;
+  }
+  const shortest = Math.min(w, h);
+  const longest = Math.max(w, h);
+  if (assets.minEdgePx != null && shortest < assets.minEdgePx) {
+    errors.push({
+      code: "UNSUPPORTED_DIMENSIONS",
+      modelId: caps.modelId,
+      field,
+      message: `${field} is ${w}x${h}; ${caps.modelId} requires at least ${assets.minEdgePx}px on each side.`,
+      allowed: assets.minEdgePx,
+      received: `${w}x${h}`
+    });
+  }
+  if (assets.maxEdgePx != null && longest > assets.maxEdgePx) {
+    errors.push({
+      code: "UNSUPPORTED_DIMENSIONS",
+      modelId: caps.modelId,
+      field,
+      message: `${field} is ${w}x${h}; ${caps.modelId} allows at most ${assets.maxEdgePx}px on any side.`,
+      allowed: assets.maxEdgePx,
+      received: `${w}x${h}`
+    });
+  }
+  if (assets.inputPixels) {
+    const pixels = w * h;
+    if (pixels < assets.inputPixels.min || pixels > assets.inputPixels.max) {
+      errors.push({
+        code: "UNSUPPORTED_DIMENSIONS",
+        modelId: caps.modelId,
+        field,
+        message: `${field} is ${pixels.toLocaleString()} pixels; ${caps.modelId} accepts ${assets.inputPixels.min.toLocaleString()}-${assets.inputPixels.max.toLocaleString()}.`,
+        received: `${w}x${h}`
+      });
+    }
+  }
+  if (assets.inputAspectRatioRange) {
+    const [min, max] = assets.inputAspectRatioRange;
+    const ratio = w / h;
+    if (ratio < min || ratio > max) {
+      errors.push({
+        code: "UNSUPPORTED_DIMENSIONS",
+        modelId: caps.modelId,
+        field,
+        message: `${field} has a ${ratio.toFixed(2)}:1 aspect ratio; ${caps.modelId} accepts ${min}-${max}.`,
+        received: `${w}x${h}`
+      });
+    }
+  }
+  return errors;
+}
+function validateFrames(caps, inputs) {
+  const errors = [];
+  const { frames, modelId } = caps;
+  const hasStart = inputs.startFrame != null;
+  const hasEnd = inputs.endFrame != null;
+  if (hasStart && !frames.start.supported) {
+    errors.push({
+      code: "START_FRAME_NOT_SUPPORTED",
+      modelId,
+      field: "startFrame",
+      message: `${modelId} does not accept a start frame.`
+    });
+  }
+  if (hasEnd && !frames.end.supported) {
+    errors.push({
+      code: "END_FRAME_NOT_SUPPORTED",
+      modelId,
+      field: "endFrame",
+      message: `${modelId} does not accept an end frame.`
+    });
+  }
+  if (inputs.startFrameCount > frames.start.maxImages) {
+    errors.push({
+      code: "TOO_MANY_START_FRAMES",
+      modelId,
+      field: "startFrame",
+      message: `${modelId} accepts ${frames.start.maxImages} start frame image(s).`,
+      allowed: frames.start.maxImages,
+      received: inputs.startFrameCount
+    });
+  }
+  if (inputs.endFrameCount > frames.end.maxImages) {
+    errors.push({
+      code: "TOO_MANY_END_FRAMES",
+      modelId,
+      field: "endFrame",
+      message: `${modelId} accepts ${frames.end.maxImages} end frame image(s).`,
+      allowed: frames.end.maxImages,
+      received: inputs.endFrameCount
+    });
+  }
+  if (hasEnd && frames.end.supported && !hasStart && frames.endFrameRequiresStartFrame) {
+    errors.push({
+      code: "END_FRAME_REQUIRES_START_FRAME",
+      modelId,
+      field: "endFrame",
+      message: `${modelId} only accepts an end frame alongside a start frame.`
+    });
+  }
+  if (hasStart && hasEnd && !frames.allowsStartAndEndTogether) {
+    errors.push({
+      code: "START_AND_END_FRAME_NOT_SUPPORTED_TOGETHER",
+      modelId,
+      message: `${modelId} cannot take a start frame and an end frame in the same job.`
+    });
+  }
+  return errors;
+}
+function validateReferences(caps, inputs) {
+  const errors = [];
+  const { references: refs, modelId } = caps;
+  const isElements = refs.grouping === "elements";
+  const flatCount = inputs.referenceImages.length;
+  const groupCount = inputs.referenceGroups.length;
+  const countedImages = providerCountedImages(caps, inputs);
+  const userSuppliedCount = flatCount + inputs.referenceGroups.flatMap(groupImages).length;
+  if (!refs.supported && userSuppliedCount > 0) {
+    errors.push({
+      code: "REFERENCES_NOT_SUPPORTED",
+      modelId,
+      field: "referenceImages",
+      message: `${modelId} does not accept reference images.`,
+      received: userSuppliedCount
+    });
+    return errors;
+  }
+  if (isElements && flatCount > 0) {
+    errors.push({
+      code: "REFERENCES_NOT_SUPPORTED",
+      modelId,
+      field: "referenceImages",
+      message: `${modelId} takes reference subjects (each a frontal image plus other angles), not a flat reference list.`,
+      received: flatCount
+    });
+  }
+  if (!isElements && groupCount > 0) {
+    errors.push({
+      code: "REFERENCES_NOT_SUPPORTED",
+      modelId,
+      field: "referenceGroups",
+      message: `${modelId} does not support grouped reference subjects.`,
+      received: groupCount
+    });
+  }
+  if (isElements) {
+    if (refs.maxGroups != null && groupCount > refs.maxGroups) {
+      errors.push({
+        code: "TOO_MANY_REFERENCE_GROUPS",
+        modelId,
+        field: "referenceGroups",
+        message: `${modelId} accepts at most ${refs.maxGroups} reference subjects.`,
+        allowed: refs.maxGroups,
+        received: groupCount
+      });
+    }
+    if (refs.imagesPerGroup) {
+      const { min, max } = refs.imagesPerGroup;
+      inputs.referenceGroups.forEach((group, index) => {
+        const size = groupImages(group).length;
+        if (size < min || size > max) {
+          errors.push({
+            code: "INVALID_REFERENCE_GROUP_SIZE",
+            modelId,
+            field: `referenceGroups[${index}]`,
+            message: `${group.label ?? `Subject ${index + 1}`} has ${size} image(s); ${modelId} needs a frontal image plus ${min - 1}-${max - 1} other angles.`,
+            allowed: max,
+            received: size
+          });
+        }
+      });
+    }
+  }
+  if (countedImages.length > refs.maxImages) {
+    errors.push({
+      code: "TOO_MANY_REFERENCE_IMAGES",
+      modelId,
+      field: "referenceImages",
+      message: `${modelId} accepts ${refs.maxImages} reference image(s); this request has ${countedImages.length}.`,
+      allowed: refs.maxImages,
+      received: countedImages.length
+    });
+  }
+  if (inputs.referenceVideos.length > refs.maxVideos) {
+    errors.push({
+      code: "TOO_MANY_REFERENCE_VIDEOS",
+      modelId,
+      field: "referenceVideos",
+      message: `${modelId} accepts ${refs.maxVideos} reference video(s).`,
+      allowed: refs.maxVideos,
+      received: inputs.referenceVideos.length
+    });
+  }
+  if (inputs.referenceAudios.length > refs.maxAudios) {
+    errors.push({
+      code: "TOO_MANY_REFERENCE_AUDIOS",
+      modelId,
+      field: "referenceAudios",
+      message: `${modelId} accepts ${refs.maxAudios} reference audio clip(s).`,
+      allowed: refs.maxAudios,
+      received: inputs.referenceAudios.length
+    });
+  }
+  if (refs.maxTotalAssets != null) {
+    const total = countedImages.length + inputs.referenceVideos.length + inputs.referenceAudios.length;
+    if (total > refs.maxTotalAssets) {
+      errors.push({
+        code: "TOO_MANY_REFERENCE_ASSETS",
+        modelId,
+        message: `${modelId} accepts ${refs.maxTotalAssets} reference assets in total; this request has ${total}.`,
+        allowed: refs.maxTotalAssets,
+        received: total
+      });
+    }
+  }
+  return errors;
+}
+function validateCombination(caps, inputs) {
+  const { references: refs, modelId, unknownFields } = caps;
+  const hasRefs = inputs.referenceImages.length > 0 || inputs.referenceGroups.length > 0 || inputs.referenceVideos.length > 0 || inputs.referenceAudios.length > 0;
+  if (!hasRefs) {
+    return [];
+  }
+  const errors = [];
+  const blocked = (slot, unknownPath) => {
+    const isUnverified = unknownFields.includes(unknownPath);
+    return {
+      code: isUnverified ? "REFERENCE_FRAME_COMBINATION_UNVERIFIED" : "FRAME_REFERENCE_COMBINATION_NOT_SUPPORTED",
+      modelId,
+      field: slot,
+      message: isUnverified ? `Combining reference images with a ${slot === "startFrame" ? "start" : "end"} frame is not documented for ${modelId}, so it is blocked rather than risking a failed paid request. Use references or frames, not both.` : `${modelId} cannot combine reference images with a ${slot === "startFrame" ? "start" : "end"} frame \u2014 the provider documents these as mutually exclusive.`
+    };
+  };
+  if (inputs.startFrame && !refs.canCombineWithStartFrame) {
+    errors.push(
+      blocked("startFrame", "references.canCombineWithStartFrame")
+    );
+  }
+  if (inputs.endFrame && !refs.canCombineWithEndFrame) {
+    errors.push(blocked("endFrame", "references.canCombineWithEndFrame"));
+  }
+  if (inputs.referenceVideos.length > 0 && inputs.referenceImages.length > 0 && !refs.acceptsImageAndVideoReferences) {
+    errors.push({
+      code: "FRAME_REFERENCE_COMBINATION_NOT_SUPPORTED",
+      modelId,
+      message: `${modelId} cannot take image references and video references in the same request.`
+    });
+  }
+  return errors;
+}
+var resolutionRank = (value) => RESOLUTION_RANK[value.toLowerCase()];
+function validateControls(caps, inputs, controls) {
+  const errors = [];
+  const { controls: cfg, modelId } = caps;
+  const hasFrame = inputs.startFrame != null || inputs.endFrame != null;
+  if (controls.aspectRatio != null) {
+    const mode = cfg.aspectRatioMode;
+    if (mode === "notApplicable" || mode === "notApplicableWithFrames" && hasFrame) {
+      errors.push({
+        code: "UNSUPPORTED_CONTROL",
+        modelId,
+        field: "aspectRatio",
+        message: `${modelId} has no aspect ratio setting when a frame is supplied \u2014 the output follows the frame.`,
+        received: controls.aspectRatio
+      });
+    } else if (mode === "forcedAdaptiveWithFrames" && hasFrame && controls.aspectRatio !== ADAPTIVE_ASPECT_RATIO) {
+      errors.push({
+        code: "UNSUPPORTED_CONTROL",
+        modelId,
+        field: "aspectRatio",
+        message: `${modelId} requires an adaptive aspect ratio when a frame is supplied; it derives the ratio from the first frame.`,
+        allowed: [ADAPTIVE_ASPECT_RATIO],
+        received: controls.aspectRatio
+      });
+    } else if (!cfg.aspectRatios.includes(controls.aspectRatio)) {
+      errors.push({
+        code: "UNSUPPORTED_CONTROL",
+        modelId,
+        field: "aspectRatio",
+        message: `${modelId} does not support a ${controls.aspectRatio} aspect ratio.`,
+        allowed: cfg.aspectRatios,
+        received: controls.aspectRatio
+      });
+    }
+  }
+  if (controls.resolution != null && !cfg.resolutions.some(
+    (r) => r.toLowerCase() === controls.resolution.toLowerCase()
+  )) {
+    errors.push({
+      code: "UNSUPPORTED_CONTROL",
+      modelId,
+      field: "resolution",
+      message: `${modelId} does not support ${controls.resolution} output.`,
+      allowed: cfg.resolutions,
+      received: controls.resolution
+    });
+  }
+  const duration = controls.durationSeconds;
+  if (duration != null) {
+    if (duration === AUTO_DURATION) {
+      if (!cfg.supportsAutoDuration) {
+        errors.push({
+          code: "UNSUPPORTED_CONTROL",
+          modelId,
+          field: "durationSeconds",
+          message: `${modelId} requires an explicit duration.`,
+          received: duration
+        });
+      }
+    } else if (cfg.durationsSeconds) {
+      if (!cfg.durationsSeconds.includes(duration)) {
+        errors.push({
+          code: "UNSUPPORTED_CONTROL",
+          modelId,
+          field: "durationSeconds",
+          message: `${modelId} supports ${cfg.durationsSeconds.join(
+            ", "
+          )} second durations.`,
+          allowed: cfg.durationsSeconds.map(String),
+          received: duration
+        });
+      }
+    } else {
+      const min = cfg.minDurationSeconds;
+      const max = cfg.maxDurationSeconds;
+      if (min != null && duration < min || max != null && duration > max) {
+        errors.push({
+          code: "UNSUPPORTED_CONTROL",
+          modelId,
+          field: "durationSeconds",
+          message: `${modelId} supports durations between ${min} and ${max} seconds.`,
+          received: duration
+        });
+      }
+    }
+  }
+  if (controls.seed != null && !cfg.supportsSeed) {
+    errors.push({
+      code: "UNSUPPORTED_CONTROL",
+      modelId,
+      field: "seed",
+      message: `${modelId} does not document a seed parameter.`,
+      received: controls.seed
+    });
+  }
+  if (controls.negativePrompt && !cfg.supportsNegativePrompt) {
+    errors.push({
+      code: "UNSUPPORTED_CONTROL",
+      modelId,
+      field: "negativePrompt",
+      message: `${modelId} does not document a negative prompt parameter. Put negative guidance in the prompt instead.`
+    });
+  }
+  return errors;
+}
+function conditionHolds(condition, inputs, controls) {
+  switch (condition.kind) {
+    case "hasReferences":
+      return inputs.referenceImages.length > 0 || inputs.referenceGroups.length > 0 || inputs.referenceVideos.length > 0;
+    case "hasStartFrame":
+      return inputs.startFrame != null;
+    case "hasEndFrame":
+      return inputs.endFrame != null;
+    case "hasAnyFrame":
+      return inputs.startFrame != null || inputs.endFrame != null;
+    case "resolutionIn":
+      return controls.resolution != null && condition.values.some(
+        (v) => v.toLowerCase() === controls.resolution.toLowerCase()
+      );
+    default:
+      return false;
+  }
+}
+function validateConstraints(caps, inputs, controls) {
+  const errors = [];
+  for (const constraint of caps.constraints) {
+    const fires = constraint.whenAny.some(
+      (c) => conditionHolds(c, inputs, controls)
+    );
+    if (!fires) {
+      continue;
+    }
+    const { requires } = constraint;
+    if (requires.kind === "durationMustBe" && controls.durationSeconds != null && controls.durationSeconds !== requires.seconds) {
+      errors.push({
+        code: "CONTROL_CONSTRAINT_VIOLATED",
+        modelId: caps.modelId,
+        field: "durationSeconds",
+        message: constraint.message,
+        allowed: requires.seconds,
+        received: controls.durationSeconds
+      });
+    }
+    if (requires.kind === "resolutionAtMost" && controls.resolution != null) {
+      const cap = resolutionRank(requires.value);
+      const requested = resolutionRank(controls.resolution);
+      if (cap != null && requested != null && requested > cap) {
+        errors.push({
+          code: "CONTROL_CONSTRAINT_VIOLATED",
+          modelId: caps.modelId,
+          field: "resolution",
+          message: constraint.message,
+          allowed: requires.value,
+          received: controls.resolution
+        });
+      }
+    }
+    if (requires.kind === "aspectRatioMustBe" && controls.aspectRatio != null && controls.aspectRatio !== requires.value) {
+      errors.push({
+        code: "CONTROL_CONSTRAINT_VIOLATED",
+        modelId: caps.modelId,
+        field: "aspectRatio",
+        message: constraint.message,
+        allowed: requires.value,
+        received: controls.aspectRatio
+      });
+    }
+  }
+  return errors;
+}
+function requiredDurationFor(caps, inputs, controls) {
+  if (!caps) {
+    return null;
+  }
+  for (const constraint of caps.constraints) {
+    if (constraint.requires.kind !== "durationMustBe") {
+      continue;
+    }
+    if (constraint.whenAny.some((c) => conditionHolds(c, inputs, controls))) {
+      return constraint.requires.seconds;
+    }
+  }
+  return null;
+}
+function maxResolutionFor(caps, inputs, controls) {
+  if (!caps) {
+    return null;
+  }
+  for (const constraint of caps.constraints) {
+    if (constraint.requires.kind !== "resolutionAtMost") {
+      continue;
+    }
+    if (constraint.whenAny.some((c) => conditionHolds(c, inputs, controls))) {
+      return constraint.requires.value;
+    }
+  }
+  return null;
+}
+function allowedResolutionsFor(caps, inputs, controls) {
+  if (!caps) {
+    return [];
+  }
+  const cap = maxResolutionFor(caps, inputs, controls);
+  if (!cap) {
+    return caps.controls.resolutions;
+  }
+  const ceiling = resolutionRank(cap);
+  if (ceiling == null) {
+    return caps.controls.resolutions;
+  }
+  return caps.controls.resolutions.filter((r) => {
+    const rank = resolutionRank(r);
+    return rank == null || rank <= ceiling;
+  });
+}
+function validateInputs(caps, inputs, controls) {
+  if (!caps) {
+    return [
+      {
+        code: "UNKNOWN_MODEL_CAPABILITIES",
+        modelId: "",
+        message: "This model has no verified input capability record, so the request cannot be validated or sent."
+      }
+    ];
+  }
+  const assetErrors = [];
+  const named = [
+    [inputs.startFrame, "startFrame"],
+    [inputs.endFrame, "endFrame"],
+    [inputs.sourceImage, "sourceImage"],
+    [inputs.brandLogo, "brandLogo"]
+  ];
+  for (const [asset, field] of named) {
+    if (asset) {
+      assetErrors.push(...validateAsset(caps, asset, field));
+    }
+  }
+  inputs.referenceImages.forEach((asset, i) => {
+    assetErrors.push(...validateAsset(caps, asset, `referenceImages[${i}]`));
+  });
+  inputs.referenceGroups.forEach((group, gi) => {
+    groupImages(group).forEach((asset, i) => {
+      assetErrors.push(
+        ...validateAsset(caps, asset, `referenceGroups[${gi}][${i}]`)
+      );
+    });
+  });
+  return [
+    ...assetErrors,
+    ...validateFrames(caps, inputs),
+    ...validateReferences(caps, inputs),
+    ...validateCombination(caps, inputs),
+    ...validateControls(caps, inputs, controls),
+    ...validateConstraints(caps, inputs, controls)
+  ];
+}
+
+// modelCapabilities/index.ts
+var ALL_MODEL_CAPABILITIES = [
+  ...IMAGE_MODEL_CAPABILITIES,
+  ...VIDEO_MODEL_CAPABILITIES
+];
+var BY_ID = new Map(
+  ALL_MODEL_CAPABILITIES.map((caps) => [caps.modelId, caps])
+);
+function getCapabilities(modelId) {
+  if (!modelId || typeof modelId !== "string") {
+    return null;
+  }
+  const base = modelId.endsWith(":online") ? modelId.slice(0, -":online".length) : modelId;
+  return BY_ID.get(base) ?? null;
+}
+function registeredModelIds() {
+  return [...BY_ID.keys()];
+}
+
+export {
+  IMAGE_MODEL_CAPABILITIES,
+  VIDEO_MODEL_CAPABILITIES,
+  AUTO_DURATION,
+  normalizeInputs,
+  groupImages,
+  effectiveUserReferenceLimit,
+  requiredDurationFor,
+  maxResolutionFor,
+  allowedResolutionsFor,
+  validateInputs,
+  ALL_MODEL_CAPABILITIES,
+  getCapabilities,
+  registeredModelIds
+};
+//# sourceMappingURL=chunk-2K6ZAAHB.js.map