@shop-os/modelkit 0.2.19 → 0.2.20

package/dist/catalog.cjs

@@ -21,6 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var catalog_entry_exports = {};
 __export(catalog_entry_exports, {
   ADAPTER_IDS: () => ADAPTER_IDS,
+  AUDIO_OUTPUTS: () => AUDIO_OUTPUTS,
   Catalog: () => Catalog,
   CatalogModelSchema: () => CatalogModelSchema,
   CatalogModelSchemaBase: () => CatalogModelSchemaBase,
@@ -30,6 +31,7 @@ __export(catalog_entry_exports, {
   MODELS: () => MODELS,
   ModelKitError: () => ModelKitError,
   OTHER_MODELS: () => OTHER_MODELS,
+  REFERENCE_SYNTAXES: () => REFERENCE_SYNTAXES,
   SURFACES: () => SURFACES2,
   SurfaceSchema: () => SurfaceSchema,
   TEXT_MODELS: () => TEXT_MODELS,
@@ -42,7 +44,9 @@ __export(catalog_entry_exports, {
   liveState: () => liveState,
   nearestAspectRatio: () => nearestAspectRatio,
   normalizeExposure: () => normalizeExposure,
+  outputAudio: () => outputAudio,
   primeCatalog: () => primeCatalog,
+  promptConventions: () => promptConventions,
   resetLiveCatalog: () => resetLiveCatalog,
   resolveAudioOptions: () => resolveAudioOptions,
   resolveImageOptions: () => resolveImageOptions,
@@ -217,7 +221,9 @@ function geminiImage(id, label, aliases, sizes, display, exposure, references) {
   const constraints = {
     aspectRatios: [...GEMINI_RATIOS],
     sizes,
-    supports: ["safetySettings", "temperature"]
+    supports: ["safetySettings", "temperature"],
+    // google-image sends MediaRef.label as a text part beside each reference.
+    prompt: { referenceSyntax: "caption" }
   };
   if (references !== void 0) constraints.references = references;
   const model = {
@@ -504,6 +510,7 @@ var IMAGE_MODELS = [
     constraints: {
       aspectRatios: ["1:1", "2:3", "3:2", "16:9", "9:16", "4:3", "3:4", "4:5", "5:4", "21:9"],
       sizes: ["1K"],
+      references: { images: 8 },
       // flux-2-pro's job type always returns image/png; only the seed is forwarded.
       supports: ["seed"]
     },
@@ -1327,7 +1334,8 @@ var VIDEO_MODELS = [
       resolutions: ["720p", "1080p", "4k"],
       durations: [8],
       references: { images: 3 },
-      supports: ["lastFrame", "seed"]
+      supports: ["lastFrame", "seed"],
+      audio: "always"
     },
     defaults: { durationSeconds: 8, resolution: "720p", aspectRatio: "16:9" },
     usage: { ...VIDEO_USAGE, slug: "veo" },
@@ -1357,7 +1365,8 @@ var VIDEO_MODELS = [
       resolutions: ["720p", "1080p", "4k"],
       durations: [4, 6, 8],
       references: { images: 3 },
-      supports: ["lastFrame", "seed"]
+      supports: ["lastFrame", "seed"],
+      audio: "always"
     },
     defaults: { durationSeconds: 8, resolution: "720p", aspectRatio: "16:9" },
     usage: { ...VIDEO_USAGE },
@@ -1385,7 +1394,8 @@ var VIDEO_MODELS = [
       aspectRatios: [...OMNI_RATIOS],
       resolutions: ["720p", "1080p"],
       durations: [4, 6, 8],
-      supports: ["lastFrame", "seed"]
+      supports: ["lastFrame", "seed"],
+      audio: "always"
     },
     defaults: { durationSeconds: 8, resolution: "720p", aspectRatio: "16:9" },
     usage: { ...VIDEO_USAGE },
@@ -1419,7 +1429,10 @@ var VIDEO_MODELS = [
       durations: [3, 4, 5, 6, 7, 8, 9, 10],
       references: { images: 6, videos: 1, videoSeconds: { max: 10 } },
       sourceVideoSeconds: { max: 10 },
-      supports: []
+      supports: [],
+      // generateOmniVideo sends MediaRef.label as a text part beside each image.
+      prompt: { referenceSyntax: "caption" },
+      audio: "always"
     },
     defaults: {},
     usage: { ...VIDEO_USAGE, slug: "gemini_omni" },
@@ -1453,7 +1466,10 @@ var VIDEO_MODELS = [
       // chain by `previousInteractionId` (the API rejects the id together
       // with a video task, so those calls carry the prompt alone).
       supports: ["videoExtension"],
-      extension: { segmentSeconds: 10, maxTotalSeconds: 40 }
+      extension: { segmentSeconds: 10, maxTotalSeconds: 40 },
+      // generateOmniVideo sends MediaRef.label as a text part beside each image.
+      prompt: { referenceSyntax: "caption" },
+      audio: "always"
     },
     defaults: {},
     usage: { ...VIDEO_USAGE },
@@ -1489,7 +1505,8 @@ var VIDEO_MODELS = [
       },
       sourceVideoSeconds: { min: 2, max: 15, inReferenceTotal: true },
       ratioIgnoredWith: ["firstFrame", "sourceVideo"],
-      supports: ["generateAudio", "seed", "lastFrame", "watermark"]
+      supports: ["generateAudio", "seed", "lastFrame", "watermark"],
+      audio: "optional"
     },
     defaults: {
       durationSeconds: 5,
@@ -1528,7 +1545,8 @@ var VIDEO_MODELS = [
       },
       sourceVideoSeconds: { min: 2, max: 15, inReferenceTotal: true },
       ratioIgnoredWith: ["firstFrame", "sourceVideo"],
-      supports: ["generateAudio", "seed", "lastFrame", "watermark"]
+      supports: ["generateAudio", "seed", "lastFrame", "watermark"],
+      audio: "optional"
     },
     defaults: {
       durationSeconds: 5,
@@ -1568,7 +1586,8 @@ var VIDEO_MODELS = [
       },
       sourceVideoSeconds: { min: 2, max: 30, editMin: 4, inReferenceTotal: true },
       ratioIgnoredWith: ["firstFrame", "sourceVideo"],
-      supports: ["generateAudio", "seed", "lastFrame", "watermark", "taskType"]
+      supports: ["generateAudio", "seed", "lastFrame", "watermark", "taskType"],
+      audio: "optional"
     },
     defaults: {
       durationSeconds: 5,
@@ -1601,7 +1620,9 @@ var VIDEO_MODELS = [
       durations: { min: 1, max: 15 },
       durationPresets: [4, 6, 8, 10],
       references: { images: 5 },
-      supports: []
+      supports: [],
+      // xAI can switch sound off (generate_audio); xai-video.ts never sends it.
+      audio: "always"
     },
     // No resolution default: xAI picks its own unless the caller asks.
     defaults: { durationSeconds: 8, aspectRatio: "16:9" },
@@ -1627,7 +1648,8 @@ var VIDEO_MODELS = [
       aspectRatios: [...KLING_RATIOS],
       durations: [5, 10],
       requires: ["firstFrame"],
-      supports: ["cfgScale", "negativePrompt", "lastFrame"]
+      supports: ["cfgScale", "negativePrompt", "lastFrame"],
+      audio: "never"
     },
     defaults: {
       durationSeconds: 5,
@@ -1658,7 +1680,9 @@ var VIDEO_MODELS = [
       aspectRatios: [...KLING_RATIOS],
       durations: { min: 3, max: 15 },
       requires: ["firstFrame"],
-      supports: ["cfgScale", "negativePrompt", "lastFrame"]
+      supports: ["cfgScale", "negativePrompt", "lastFrame"],
+      // Higgsfield has a `sound` switch (default on); KlingCreate doesn't send it.
+      audio: "always"
     },
     defaults: {
       durationSeconds: 5,
@@ -1693,7 +1717,8 @@ var VIDEO_MODELS = [
       resolutions: ["720p", "1080p"],
       durations: { min: 3, max: 15 },
       references: { images: 7, imagesWithVideo: 4 },
-      supports: ["generateAudio", "lastFrame"]
+      supports: ["generateAudio", "lastFrame"],
+      audio: "optional"
     },
     defaults: { durationSeconds: 5, aspectRatio: "16:9", generateAudio: false, mode: "pro" },
     usage: { unit: "compute_seconds" },
@@ -1718,7 +1743,8 @@ var VIDEO_MODELS = [
       aspectRatios: [...H3_RATIOS],
       resolutions: ["480p", "768p", "2k", "4k"],
       durations: { min: 5, max: 15 },
-      supports: ["seed", "promptExpansion", "lastFrame", "safetyChecker"]
+      supports: ["seed", "promptExpansion", "lastFrame", "safetyChecker"],
+      audio: "always"
     },
     defaults: {
       durationSeconds: 5,
@@ -1748,7 +1774,8 @@ var VIDEO_MODELS = [
       aspectRatios: [...H3_RATIOS],
       resolutions: ["480p", "768p"],
       durations: { min: 5, max: 15 },
-      supports: ["seed", "promptExpansion", "lastFrame", "safetyChecker"]
+      supports: ["seed", "promptExpansion", "lastFrame", "safetyChecker"],
+      audio: "always"
     },
     defaults: {
       durationSeconds: 5,
@@ -1786,7 +1813,8 @@ var VIDEO_MODELS = [
         audioOnly: false,
         videoSeconds: { min: 2, max: 15, total: 15 }
       },
-      supports: ["seed", "promptExpansion", "safetyChecker"]
+      supports: ["seed", "promptExpansion", "safetyChecker"],
+      audio: "always"
     },
     defaults: {
       durationSeconds: 5,
@@ -1801,7 +1829,9 @@ var VIDEO_MODELS = [
       logo: "https://d31vvfpk2ppdyq.cloudfront.net/assets/image/f4c2e906-28b7-4a4a-b491-df8fef7808ed.png",
       description: "MiniMax H3 reference-to-video mode guided by up to 9 reference images, 3 reference videos, and 3 audio clips; reference and image-to-video inputs cannot be mixed."
     },
-    capabilities: {}
+    // fal's reference-to-video endpoint never reads a frame; the resolver must drop the
+    // references instead of the adapter silently dropping the frame.
+    capabilities: { ...FRAMES_EXCLUDE_REFERENCES }
   },
   {
     id: "minimax-h3-max-reference",
@@ -1824,7 +1854,8 @@ var VIDEO_MODELS = [
         audioOnly: false,
         videoSeconds: { min: 2, max: 15, total: 15 }
       },
-      supports: ["seed", "promptExpansion", "safetyChecker"]
+      supports: ["seed", "promptExpansion", "safetyChecker"],
+      audio: "always"
     },
     defaults: {
       durationSeconds: 5,
@@ -1839,7 +1870,9 @@ var VIDEO_MODELS = [
       logo: "https://d31vvfpk2ppdyq.cloudfront.net/assets/image/f4c2e906-28b7-4a4a-b491-df8fef7808ed.png",
       description: "MiniMax H3 Max reference-to-video on fal; conditions on reference images, videos, and audio. MiniMax's own docs do not list a reference mode for H3 Max."
     },
-    capabilities: {}
+    // fal's reference-to-video endpoint never reads a frame; the resolver must drop the
+    // references instead of the adapter silently dropping the frame.
+    capabilities: { ...FRAMES_EXCLUDE_REFERENCES }
   },
   {
     // Duration 3-10s per trigger-workflows mapDuration; the endpoint takes no resolution.
@@ -1856,7 +1889,8 @@ var VIDEO_MODELS = [
       durations: { min: 3, max: 10 },
       requires: ["sourceVideo"],
       sourceVideoSeconds: { min: 3, max: 10.05 },
-      supports: []
+      supports: [],
+      audio: "never"
     },
     defaults: { durationSeconds: 5, aspectRatio: "16:9" },
     usage: { ...VIDEO_USAGE },
@@ -1880,7 +1914,8 @@ var VIDEO_MODELS = [
     constraints: {
       resolutions: ["768p"],
       durations: [6, 10],
-      supports: ["lastFrame"]
+      supports: ["lastFrame"],
+      audio: "never"
     },
     defaults: { durationSeconds: 6, resolution: "768p" },
     usage: { unit: "compute_seconds" },
@@ -1903,7 +1938,8 @@ var VIDEO_MODELS = [
     exposure: [],
     constraints: {
       requires: ["firstFrame"],
-      supports: ["seed", "lastFrame"]
+      supports: ["seed", "lastFrame"],
+      audio: "never"
     },
     defaults: {},
     usage: { ...VIDEO_USAGE },
@@ -1925,7 +1961,7 @@ var MODELS = [
 ];
 
 // src/catalog/schema.ts
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 
 // src/catalog/collisions.ts
 function collisionIssues(rows) {
@@ -1972,8 +2008,61 @@ function collisionIssues(rows) {
   return issues;
 }
 
-// src/catalog/input-spec.ts
+// src/catalog/conventions.ts
 var import_zod = require("zod");
+var AudioOutputSchema = import_zod.z.enum(["always", "optional", "never"]);
+var ReferenceSyntaxSchema = import_zod.z.enum(["numbered", "caption", "descriptive"]);
+var MaxCharsSchema = import_zod.z.number().int().positive();
+var PromptConventionsSchema = import_zod.z.strictObject({
+  referenceSyntax: ReferenceSyntaxSchema,
+  maxChars: MaxCharsSchema.optional()
+});
+var AUDIO_OUTPUTS = AudioOutputSchema.options;
+var REFERENCE_SYNTAXES = ReferenceSyntaxSchema.options;
+var ConstraintsReadView = import_zod.z.looseObject({
+  audio: AudioOutputSchema.optional().catch(void 0),
+  prompt: import_zod.z.looseObject({
+    referenceSyntax: ReferenceSyntaxSchema.catch("numbered"),
+    maxChars: MaxCharsSchema.optional().catch(void 0)
+  }).optional().catch(void 0)
+});
+var DEFAULT_CONVENTIONS = { referenceSyntax: "numbered" };
+function outputAudio(row) {
+  const view = ConstraintsReadView.safeParse(row.constraints);
+  return view.success ? view.data.audio : void 0;
+}
+function promptConventions(row) {
+  const view = ConstraintsReadView.safeParse(row.constraints);
+  const prompt = view.success ? view.data.prompt : void 0;
+  if (prompt === void 0) return { ...DEFAULT_CONVENTIONS };
+  const result = { referenceSyntax: prompt.referenceSyntax };
+  if (prompt.maxChars !== void 0) result.maxChars = prompt.maxChars;
+  return result;
+}
+var RawConventionsView = import_zod.z.looseObject({
+  audio: import_zod.z.unknown().optional(),
+  prompt: import_zod.z.unknown().optional()
+});
+function normaliseConventions(row) {
+  const view = RawConventionsView.safeParse(row.constraints);
+  if (!view.success) return { row, invalidKeys: [] };
+  const { audio, prompt } = view.data;
+  const badAudio = audio !== void 0 && !AudioOutputSchema.safeParse(audio).success;
+  const badPrompt = prompt !== void 0 && !PromptConventionsSchema.safeParse(prompt).success;
+  if (!badAudio && !badPrompt) return { row, invalidKeys: [] };
+  const invalidKeys = [];
+  if (badAudio) invalidKeys.push("constraints.audio");
+  if (badPrompt) invalidKeys.push("constraints.prompt");
+  const entries = Object.entries(row.constraints).flatMap(([key, value]) => {
+    if (key === "audio" && badAudio) return [];
+    if (key === "prompt" && badPrompt) return [[key, promptConventions(row)]];
+    return [[key, value]];
+  });
+  return { row: { ...row, constraints: Object.fromEntries(entries) }, invalidKeys };
+}
+
+// src/catalog/input-spec.ts
+var import_zod2 = require("zod");
 var VIDEO_INPUT_SPEC_KEYS = [
   "prompt",
   "durationSeconds",
@@ -2012,8 +2101,8 @@ var ALL_KEY_SET = /* @__PURE__ */ new Set([
   ...VIDEO_INPUT_SPEC_KEYS,
   ...AUDIO_INPUT_SPEC_KEYS
 ]);
-var ProviderScalarSchema = import_zod.z.union([import_zod.z.string(), import_zod.z.number(), import_zod.z.boolean()]);
-var FieldsSchema = import_zod.z.record(import_zod.z.string(), import_zod.z.string().min(1)).superRefine((fields, ctx) => {
+var ProviderScalarSchema = import_zod2.z.union([import_zod2.z.string(), import_zod2.z.number(), import_zod2.z.boolean()]);
+var FieldsSchema = import_zod2.z.record(import_zod2.z.string(), import_zod2.z.string().min(1)).superRefine((fields, ctx) => {
   const keys = Object.keys(fields);
   if (keys.length === 0) {
     ctx.addIssue({
@@ -2031,7 +2120,7 @@ var FieldsSchema = import_zod.z.record(import_zod.z.string(), import_zod.z.strin
     }
   }
 });
-var ValuesSchema = import_zod.z.record(import_zod.z.string(), import_zod.z.record(import_zod.z.string(), ProviderScalarSchema)).superRefine((values, ctx) => {
+var ValuesSchema = import_zod2.z.record(import_zod2.z.string(), import_zod2.z.record(import_zod2.z.string(), ProviderScalarSchema)).superRefine((values, ctx) => {
   for (const key of Object.keys(values)) {
     if (!ALL_KEY_SET.has(key)) {
       ctx.addIssue({
@@ -2041,8 +2130,8 @@ var ValuesSchema = import_zod.z.record(import_zod.z.string(), import_zod.z.recor
     }
   }
 });
-var StaticSchema = import_zod.z.record(import_zod.z.string(), ProviderScalarSchema);
-var InputSpecSchema = import_zod.z.strictObject({
+var StaticSchema = import_zod2.z.record(import_zod2.z.string(), ProviderScalarSchema);
+var InputSpecSchema = import_zod2.z.strictObject({
   fields: FieldsSchema,
   values: ValuesSchema.optional(),
   static: StaticSchema.optional()
@@ -2146,16 +2235,16 @@ var ADAPTER_IDS = [
   "higgsfield",
   "xai-video"
 ];
-var ModelTypeSchema = import_zod2.z.enum(["text", "image", "video", "audio", "upscale", "bg-remove"]);
-var LifecycleSchema = import_zod2.z.enum(["active", "deprecated", "retired"]);
-var SurfaceSchema = import_zod2.z.enum(["cowork", "space_builder"]);
+var ModelTypeSchema = import_zod3.z.enum(["text", "image", "video", "audio", "upscale", "bg-remove"]);
+var LifecycleSchema = import_zod3.z.enum(["active", "deprecated", "retired"]);
+var SurfaceSchema = import_zod3.z.enum(["cowork", "space_builder"]);
 var SURFACES2 = SurfaceSchema.options;
-var ExposureSchema = import_zod2.z.preprocess(
+var ExposureSchema = import_zod3.z.preprocess(
   normalizeExposure,
-  import_zod2.z.array(SurfaceSchema)
+  import_zod3.z.array(SurfaceSchema)
 );
-var AdapterSchema = import_zod2.z.enum(ADAPTER_IDS);
-var AspectRatioSchema = import_zod2.z.enum([
+var AdapterSchema = import_zod3.z.enum(ADAPTER_IDS);
+var AspectRatioSchema = import_zod3.z.enum([
   "1:1",
   "16:9",
   "9:16",
@@ -2170,12 +2259,12 @@ var AspectRatioSchema = import_zod2.z.enum([
   "97:30",
   "adaptive"
 ]);
-var ImageSizeSchema = import_zod2.z.enum(["512", "1K", "2K", "4K"]);
-var VideoResolutionSchema = import_zod2.z.enum(["360p", "480p", "720p", "768p", "1080p", "2k", "4k"]);
-var ImageQualitySchema = import_zod2.z.enum(["auto", "low", "medium", "high", "xhigh", "max"]);
-var OutputFormatSchema = import_zod2.z.enum(["png", "jpeg", "webp"]);
-var RequiredInputSchema = import_zod2.z.enum(["firstFrame", "sourceVideo", "references"]);
-var SupportedOptionSchema = import_zod2.z.enum([
+var ImageSizeSchema = import_zod3.z.enum(["512", "1K", "2K", "4K"]);
+var VideoResolutionSchema = import_zod3.z.enum(["360p", "480p", "720p", "768p", "1080p", "2k", "4k"]);
+var ImageQualitySchema = import_zod3.z.enum(["auto", "low", "medium", "high", "xhigh", "max"]);
+var OutputFormatSchema = import_zod3.z.enum(["png", "jpeg", "webp"]);
+var RequiredInputSchema = import_zod3.z.enum(["firstFrame", "sourceVideo", "references"]);
+var SupportedOptionSchema = import_zod3.z.enum([
   "seed",
   "quality",
   "negativePrompt",
@@ -2195,142 +2284,146 @@ var SupportedOptionSchema = import_zod2.z.enum([
   "videoExtension",
   "instrumental"
 ]);
-var UsageUnitSchema = import_zod2.z.enum([
+var UsageUnitSchema = import_zod3.z.enum([
   "tokens",
   "images",
   "seconds",
   "reported_cost_usd",
   "compute_seconds"
 ]);
-var PricingKindSchema = import_zod2.z.enum(["token", "image_size", "video_per_second", "flat"]);
-var ProviderOptionValueSchema = import_zod2.z.lazy(
-  () => import_zod2.z.union([
-    import_zod2.z.string(),
-    import_zod2.z.number(),
-    import_zod2.z.boolean(),
-    import_zod2.z.array(ProviderOptionValueSchema),
-    import_zod2.z.record(import_zod2.z.string(), ProviderOptionValueSchema)
+var PricingKindSchema = import_zod3.z.enum(["token", "image_size", "video_per_second", "flat"]);
+var ProviderOptionValueSchema = import_zod3.z.lazy(
+  () => import_zod3.z.union([
+    import_zod3.z.string(),
+    import_zod3.z.number(),
+    import_zod3.z.boolean(),
+    import_zod3.z.array(ProviderOptionValueSchema),
+    import_zod3.z.record(import_zod3.z.string(), ProviderOptionValueSchema)
   ])
 );
-var ProviderOptionsSchema = import_zod2.z.record(import_zod2.z.string(), import_zod2.z.record(import_zod2.z.string(), ProviderOptionValueSchema));
-var VideoSecondsLimitsSchema = import_zod2.z.looseObject({
-  min: import_zod2.z.number().optional(),
-  max: import_zod2.z.number().optional(),
-  total: import_zod2.z.number().optional(),
-  editMin: import_zod2.z.number().optional()
+var ProviderOptionsSchema = import_zod3.z.record(import_zod3.z.string(), import_zod3.z.record(import_zod3.z.string(), ProviderOptionValueSchema));
+var VideoSecondsLimitsSchema = import_zod3.z.looseObject({
+  min: import_zod3.z.number().optional(),
+  max: import_zod3.z.number().optional(),
+  total: import_zod3.z.number().optional(),
+  editMin: import_zod3.z.number().optional()
 });
-var ReferenceLimitsSchema = import_zod2.z.looseObject({
-  images: import_zod2.z.number().optional(),
-  imagesWithVideo: import_zod2.z.number().optional(),
-  videos: import_zod2.z.number().optional(),
-  audios: import_zod2.z.number().optional(),
-  total: import_zod2.z.number().optional(),
-  audioOnly: import_zod2.z.boolean().optional(),
+var ReferenceLimitsSchema = import_zod3.z.looseObject({
+  images: import_zod3.z.number().optional(),
+  imagesWithVideo: import_zod3.z.number().optional(),
+  videos: import_zod3.z.number().optional(),
+  audios: import_zod3.z.number().optional(),
+  total: import_zod3.z.number().optional(),
+  audioOnly: import_zod3.z.boolean().optional(),
   videoSeconds: VideoSecondsLimitsSchema.optional()
 });
-var ModelConstraintsSchema = import_zod2.z.looseObject({
-  aspectRatios: import_zod2.z.array(AspectRatioSchema).optional(),
-  sizes: import_zod2.z.array(ImageSizeSchema).optional(),
-  resolutions: import_zod2.z.array(VideoResolutionSchema).optional(),
-  durations: import_zod2.z.union([import_zod2.z.looseObject({ min: import_zod2.z.number(), max: import_zod2.z.number() }), import_zod2.z.array(import_zod2.z.number())]).optional(),
-  durationPresets: import_zod2.z.array(import_zod2.z.number()).optional(),
-  qualityOptions: import_zod2.z.array(import_zod2.z.string()).optional(),
-  exactSizes: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.string()).optional(),
+var ModelConstraintsSchema = import_zod3.z.looseObject({
+  aspectRatios: import_zod3.z.array(AspectRatioSchema).optional(),
+  sizes: import_zod3.z.array(ImageSizeSchema).optional(),
+  resolutions: import_zod3.z.array(VideoResolutionSchema).optional(),
+  durations: import_zod3.z.union([import_zod3.z.looseObject({ min: import_zod3.z.number(), max: import_zod3.z.number() }), import_zod3.z.array(import_zod3.z.number())]).optional(),
+  durationPresets: import_zod3.z.array(import_zod3.z.number()).optional(),
+  qualityOptions: import_zod3.z.array(import_zod3.z.string()).optional(),
+  exactSizes: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.string()).optional(),
   references: ReferenceLimitsSchema.optional(),
-  requires: import_zod2.z.array(RequiredInputSchema).optional(),
-  supports: import_zod2.z.array(SupportedOptionSchema).optional(),
-  ratioIgnoredWith: import_zod2.z.array(import_zod2.z.enum(["firstFrame", "sourceVideo"])).optional(),
-  sourceVideoSeconds: VideoSecondsLimitsSchema.omit({ total: true }).extend({ inReferenceTotal: import_zod2.z.boolean().optional() }).optional(),
-  extension: import_zod2.z.looseObject({ segmentSeconds: import_zod2.z.number(), maxTotalSeconds: import_zod2.z.number() }).optional()
+  requires: import_zod3.z.array(RequiredInputSchema).optional(),
+  supports: import_zod3.z.array(SupportedOptionSchema).optional(),
+  ratioIgnoredWith: import_zod3.z.array(import_zod3.z.enum(["firstFrame", "sourceVideo"])).optional(),
+  sourceVideoSeconds: VideoSecondsLimitsSchema.omit({ total: true }).extend({ inReferenceTotal: import_zod3.z.boolean().optional() }).optional(),
+  extension: import_zod3.z.looseObject({ segmentSeconds: import_zod3.z.number(), maxTotalSeconds: import_zod3.z.number() }).optional(),
+  // Loose on purpose: the read path keeps a row whose value is invalid (the accessors in
+  // conventions.ts read it as "not set"); CatalogModelSchema below rejects it on write.
+  audio: import_zod3.z.unknown().optional(),
+  prompt: import_zod3.z.unknown().optional()
 });
-var MediaRefSchema = import_zod2.z.union([
-  import_zod2.z.looseObject({
-    url: import_zod2.z.string(),
-    label: import_zod2.z.string().optional(),
-    durationSeconds: import_zod2.z.number().optional()
+var MediaRefSchema = import_zod3.z.union([
+  import_zod3.z.looseObject({
+    url: import_zod3.z.string(),
+    label: import_zod3.z.string().optional(),
+    durationSeconds: import_zod3.z.number().optional()
   }),
-  import_zod2.z.looseObject({
-    bytes: import_zod2.z.instanceof(Uint8Array),
-    mime: import_zod2.z.string(),
-    label: import_zod2.z.string().optional(),
-    durationSeconds: import_zod2.z.number().optional()
+  import_zod3.z.looseObject({
+    bytes: import_zod3.z.instanceof(Uint8Array),
+    mime: import_zod3.z.string(),
+    label: import_zod3.z.string().optional(),
+    durationSeconds: import_zod3.z.number().optional()
   })
 ]);
-var ImageSafetySettingSchema = import_zod2.z.looseObject({ category: import_zod2.z.string(), threshold: import_zod2.z.string() });
-var UpscaleOptionsSchema = import_zod2.z.looseObject({
-  enhanceModel: import_zod2.z.string().optional(),
-  subjectDetection: import_zod2.z.string().optional(),
-  faceEnhancement: import_zod2.z.boolean().optional(),
-  faceEnhancementCreativity: import_zod2.z.number().optional(),
-  faceEnhancementStrength: import_zod2.z.number().optional()
+var ImageSafetySettingSchema = import_zod3.z.looseObject({ category: import_zod3.z.string(), threshold: import_zod3.z.string() });
+var UpscaleOptionsSchema = import_zod3.z.looseObject({
+  enhanceModel: import_zod3.z.string().optional(),
+  subjectDetection: import_zod3.z.string().optional(),
+  faceEnhancement: import_zod3.z.boolean().optional(),
+  faceEnhancementCreativity: import_zod3.z.number().optional(),
+  faceEnhancementStrength: import_zod3.z.number().optional()
 });
-var DefaultsSchema = import_zod2.z.looseObject({
-  references: import_zod2.z.array(MediaRefSchema).optional(),
+var DefaultsSchema = import_zod3.z.looseObject({
+  references: import_zod3.z.array(MediaRefSchema).optional(),
   aspectRatio: AspectRatioSchema.optional(),
   size: ImageSizeSchema.optional(),
-  exactSize: import_zod2.z.string().optional(),
+  exactSize: import_zod3.z.string().optional(),
   quality: ImageQualitySchema.optional(),
-  seed: import_zod2.z.number().optional(),
-  count: import_zod2.z.number().optional(),
+  seed: import_zod3.z.number().optional(),
+  count: import_zod3.z.number().optional(),
   outputFormat: OutputFormatSchema.optional(),
-  scaleFactor: import_zod2.z.number().optional(),
-  safetySettings: import_zod2.z.array(ImageSafetySettingSchema).optional(),
-  temperature: import_zod2.z.number().optional(),
+  scaleFactor: import_zod3.z.number().optional(),
+  safetySettings: import_zod3.z.array(ImageSafetySettingSchema).optional(),
+  temperature: import_zod3.z.number().optional(),
   upscale: UpscaleOptionsSchema.optional(),
   firstFrame: MediaRefSchema.optional(),
   lastFrame: MediaRefSchema.optional(),
   sourceVideo: MediaRefSchema.optional(),
-  referenceImages: import_zod2.z.array(MediaRefSchema).optional(),
-  referenceVideos: import_zod2.z.array(MediaRefSchema).optional(),
-  referenceAudios: import_zod2.z.array(MediaRefSchema).optional(),
+  referenceImages: import_zod3.z.array(MediaRefSchema).optional(),
+  referenceVideos: import_zod3.z.array(MediaRefSchema).optional(),
+  referenceAudios: import_zod3.z.array(MediaRefSchema).optional(),
   resolution: VideoResolutionSchema.optional(),
-  durationSeconds: import_zod2.z.number().optional(),
-  generateAudio: import_zod2.z.boolean().optional(),
-  negativePrompt: import_zod2.z.string().optional(),
-  cfgScale: import_zod2.z.number().optional(),
-  promptExpansion: import_zod2.z.enum(["fast", "balanced", "quality"]).optional(),
-  watermark: import_zod2.z.boolean().optional(),
-  safetyChecker: import_zod2.z.boolean().optional(),
-  taskType: import_zod2.z.enum(["reference", "edit", "extend"]).optional(),
-  mode: import_zod2.z.enum(["standard", "pro"]).optional(),
-  instrumental: import_zod2.z.boolean().optional()
+  durationSeconds: import_zod3.z.number().optional(),
+  generateAudio: import_zod3.z.boolean().optional(),
+  negativePrompt: import_zod3.z.string().optional(),
+  cfgScale: import_zod3.z.number().optional(),
+  promptExpansion: import_zod3.z.enum(["fast", "balanced", "quality"]).optional(),
+  watermark: import_zod3.z.boolean().optional(),
+  safetyChecker: import_zod3.z.boolean().optional(),
+  taskType: import_zod3.z.enum(["reference", "edit", "extend"]).optional(),
+  mode: import_zod3.z.enum(["standard", "pro"]).optional(),
+  instrumental: import_zod3.z.boolean().optional()
 });
-var CatalogDisplaySchema = import_zod2.z.looseObject({
-  provider: import_zod2.z.string(),
-  description: import_zod2.z.string(),
-  logo: import_zod2.z.string().optional(),
-  costTier: import_zod2.z.union([import_zod2.z.literal(1), import_zod2.z.literal(2), import_zod2.z.literal(3)]).optional(),
-  recommended: import_zod2.z.boolean().optional(),
-  sortOrder: import_zod2.z.number().optional(),
-  chat: import_zod2.z.looseObject({
+var CatalogDisplaySchema = import_zod3.z.looseObject({
+  provider: import_zod3.z.string(),
+  description: import_zod3.z.string(),
+  logo: import_zod3.z.string().optional(),
+  costTier: import_zod3.z.union([import_zod3.z.literal(1), import_zod3.z.literal(2), import_zod3.z.literal(3)]).optional(),
+  recommended: import_zod3.z.boolean().optional(),
+  sortOrder: import_zod3.z.number().optional(),
+  chat: import_zod3.z.looseObject({
     providerOptions: ProviderOptionsSchema.optional(),
-    temperature: import_zod2.z.number().optional()
+    temperature: import_zod3.z.number().optional()
   }).optional()
 });
-var CatalogCapabilitiesSchema = import_zod2.z.looseObject({
-  acceptsSourceVideo: import_zod2.z.boolean().optional(),
-  framesExcludeReferences: import_zod2.z.boolean().optional(),
-  reasoning: import_zod2.z.boolean().optional(),
-  vision: import_zod2.z.boolean().optional(),
-  contextWindow: import_zod2.z.number().optional()
+var CatalogCapabilitiesSchema = import_zod3.z.looseObject({
+  acceptsSourceVideo: import_zod3.z.boolean().optional(),
+  framesExcludeReferences: import_zod3.z.boolean().optional(),
+  reasoning: import_zod3.z.boolean().optional(),
+  vision: import_zod3.z.boolean().optional(),
+  contextWindow: import_zod3.z.number().optional()
 });
-var CatalogModelSchemaBase = import_zod2.z.looseObject({
-  id: import_zod2.z.string().min(1),
-  aliases: import_zod2.z.array(import_zod2.z.string()).default([]),
-  label: import_zod2.z.string().min(1),
+var CatalogModelSchemaBase = import_zod3.z.looseObject({
+  id: import_zod3.z.string().min(1),
+  aliases: import_zod3.z.array(import_zod3.z.string()).default([]),
+  label: import_zod3.z.string().min(1),
   type: ModelTypeSchema,
   adapter: AdapterSchema,
-  providerModelId: import_zod2.z.string().min(1),
+  providerModelId: import_zod3.z.string().min(1),
   lifecycle: LifecycleSchema,
-  replacedBy: import_zod2.z.string().optional(),
+  replacedBy: import_zod3.z.string().optional(),
   exposure: ExposureSchema,
   constraints: ModelConstraintsSchema,
   defaults: DefaultsSchema,
   providerOptions: ProviderOptionsSchema.optional(),
-  usage: import_zod2.z.looseObject({
+  usage: import_zod3.z.looseObject({
     unit: UsageUnitSchema,
-    slug: import_zod2.z.string().optional(),
-    providerLabel: import_zod2.z.string().optional()
+    slug: import_zod3.z.string().optional(),
+    providerLabel: import_zod3.z.string().optional()
   }),
   pricingKind: PricingKindSchema,
   display: CatalogDisplaySchema.optional(),
@@ -2381,9 +2474,30 @@ var CatalogModelSchema = CatalogModelSchemaBase.superRefine(
         }
       }
     }
+    const audio = row.constraints.audio;
+    if (audio !== void 0 && !AudioOutputSchema.safeParse(audio).success) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["constraints", "audio"],
+        message: 'audio must be "always", "optional" or "never"'
+      });
+    }
+    const prompt = row.constraints.prompt;
+    if (prompt !== void 0) {
+      const parsed = PromptConventionsSchema.safeParse(prompt);
+      if (!parsed.success) {
+        for (const issue of parsed.error.issues) {
+          ctx.addIssue({
+            code: "custom",
+            path: ["constraints", "prompt", ...issue.path.map(String)],
+            message: issue.message
+          });
+        }
+      }
+    }
   }
 );
-var CatalogSchema = import_zod2.z.array(CatalogModelSchemaBase).superRefine((rows, ctx) => {
+var CatalogSchema = import_zod3.z.array(CatalogModelSchemaBase.transform((row) => normaliseConventions(row).row)).superRefine((rows, ctx) => {
   for (const issue of collisionIssues(rows)) {
     ctx.addIssue({
       code: "custom",
@@ -2406,42 +2520,42 @@ var liveState = store[KEY] ??= {
 var liveCatalog = liveState.catalog;
 
 // src/json.ts
-var import_zod3 = require("zod");
-var JsonValueSchema = import_zod3.z.lazy(
-  () => import_zod3.z.union([
-    import_zod3.z.string(),
-    import_zod3.z.number(),
-    import_zod3.z.boolean(),
-    import_zod3.z.null(),
-    import_zod3.z.array(JsonValueSchema),
-    import_zod3.z.record(import_zod3.z.string(), JsonValueSchema)
+var import_zod4 = require("zod");
+var JsonValueSchema = import_zod4.z.lazy(
+  () => import_zod4.z.union([
+    import_zod4.z.string(),
+    import_zod4.z.number(),
+    import_zod4.z.boolean(),
+    import_zod4.z.null(),
+    import_zod4.z.array(JsonValueSchema),
+    import_zod4.z.record(import_zod4.z.string(), JsonValueSchema)
   ])
 );
-var JsonObjectSchema = import_zod3.z.record(import_zod3.z.string(), JsonValueSchema);
-var thrownErrorSchema = import_zod3.z.object({
-  message: import_zod3.z.string().optional(),
-  status: import_zod3.z.number().optional(),
-  statusCode: import_zod3.z.number().optional(),
-  responseBody: import_zod3.z.string().optional()
+var JsonObjectSchema = import_zod4.z.record(import_zod4.z.string(), JsonValueSchema);
+var thrownErrorSchema = import_zod4.z.object({
+  message: import_zod4.z.string().optional(),
+  status: import_zod4.z.number().optional(),
+  statusCode: import_zod4.z.number().optional(),
+  responseBody: import_zod4.z.string().optional()
 });
 
 // src/catalog/load.ts
-var import_zod4 = require("zod");
+var import_zod5 = require("zod");
 function rowCount() {
   return liveCatalog.list({ lifecycle: ["active", "deprecated", "retired"] }).length;
 }
 function authHeaders(auth) {
   return "bearer" in auth ? { Authorization: `Bearer ${auth.bearer}` } : { "x-api-key": auth.apiKey };
 }
-var EnvelopeSchema = import_zod4.z.object({
-  rows: import_zod4.z.array(JsonValueSchema),
-  revision: import_zod4.z.string().optional()
+var EnvelopeSchema = import_zod5.z.object({
+  rows: import_zod5.z.array(JsonValueSchema),
+  revision: import_zod5.z.string().optional()
 });
 function dropReason(path, message) {
   return path.length === 0 ? message : `${path.map((part) => String(part)).join(".")} ${message}`;
 }
 function rowId(raw) {
-  const parsed = import_zod4.z.object({ id: import_zod4.z.string().min(1) }).loose().safeParse(raw);
+  const parsed = import_zod5.z.object({ id: import_zod5.z.string().min(1) }).loose().safeParse(raw);
   if (!parsed.success) return "?";
   return parsed.data.id;
 }
@@ -2469,7 +2583,13 @@ function quarantine(rawRows, logger) {
         );
       }
     }
-    valid.push(row);
+    const normalised = normaliseConventions(row);
+    if (normalised.invalidKeys.length > 0) {
+      logger.warn(
+        `[modelkit] catalog row ${row.id} has an invalid ${normalised.invalidKeys.join(", ")}; read as not set`
+      );
+    }
+    valid.push(normalised.row);
   }
   let kept = valid;
   for (; ; ) {