@shop-os/modelkit 0.5.0 → 0.6.1

package/dist/catalog.cjs

@@ -30,6 +30,8 @@ __export(catalog_entry_exports, {
   IMAGE_MODELS: () => IMAGE_MODELS,
   MEDIA_METHODS: () => MEDIA_METHODS,
   MEDIA_NODE_MODELS: () => MEDIA_NODE_MODELS,
+  MODEL3D_IMAGE_SLOTS: () => MODEL3D_IMAGE_SLOTS,
+  MODEL3D_MODELS: () => MODEL3D_MODELS,
   MODELS: () => MODELS,
   ModelKitError: () => ModelKitError,
   OTHER_MODELS: () => OTHER_MODELS,
@@ -47,6 +49,13 @@ __export(catalog_entry_exports, {
   isModelKitError: () => isModelKitError,
   liveCatalog: () => liveCatalog,
   liveState: () => liveState,
+  model3dConstraints: () => model3dConstraints,
+  model3dInputRefusal: () => model3dInputRefusal,
+  model3dPricingSku: () => model3dPricingSku,
+  model3dResolution: () => model3dResolution,
+  model3dSeedFits: () => model3dSeedFits,
+  model3dSkus: () => model3dSkus,
+  model3dTexture: () => model3dTexture,
   nearestAspectRatio: () => nearestAspectRatio,
   normalizeExposure: () => normalizeExposure,
   outputAudio: () => outputAudio,
@@ -208,11 +217,11 @@ function normalizeExposure(value) {
   }
   return value;
 }
-function isListedOn(row, surface) {
-  return row.lifecycle === "active" && row.exposure.includes(surface);
+function isListedOn(row2, surface) {
+  return row2.lifecycle === "active" && row2.exposure.includes(surface);
 }
-function isListed(row) {
-  return row.lifecycle === "active" && row.exposure.length > 0;
+function isListed(row2) {
+  return row2.lifecycle === "active" && row2.exposure.length > 0;
 }
 
 // src/catalog/image-fal.ts
@@ -3614,6 +3623,197 @@ var MEDIA_NODE_MODELS = [
   SAM_3_IMAGE
 ];
 
+// src/catalog/model3d.ts
+var REQUEST_USAGE = { unit: "requests" };
+function row(id, label, spec, display) {
+  return {
+    id,
+    aliases: [],
+    label,
+    type: "model3d",
+    adapter: "fal",
+    // The single-image endpoint; the adapter picks the endpoint a request needs.
+    providerModelId: spec.endpoints.image ?? id,
+    lifecycle: "active",
+    exposure: ["space_builder"],
+    constraints: { supports: [], model3d: spec },
+    defaults: {},
+    usage: REQUEST_USAGE,
+    pricingKind: "flat",
+    display
+  };
+}
+var MODEL3D_MODELS = [
+  row(
+    "trellis-2",
+    "Trellis 2",
+    {
+      family: "trellis",
+      endpoints: { image: "fal-ai/trellis-2" },
+      text: false,
+      imageRequired: true,
+      views: "none",
+      maxImages: 1,
+      texture: [],
+      pbr: false,
+      textureRef: false,
+      seed: true,
+      resolutions: { label: "Resolution", options: ["512", "1024", "1536"], default: "1024" }
+    },
+    {
+      provider: "microsoft",
+      description: "One photo to a detailed textured model. Fast and the best value.",
+      sortOrder: 70
+    }
+  ),
+  row(
+    "hunyuan3d-3.1-pro",
+    "Hunyuan3D 3.1 Pro",
+    {
+      family: "hunyuan",
+      endpoints: {
+        text: "fal-ai/hunyuan-3d/v3.1/pro/text-to-3d",
+        image: "fal-ai/hunyuan-3d/v3.1/pro/image-to-3d"
+      },
+      text: true,
+      imageRequired: false,
+      views: "named",
+      maxImages: 4,
+      texture: ["none", "standard"],
+      pbr: true,
+      textureRef: false,
+      seed: false
+    },
+    {
+      provider: "tencent",
+      description: "Photo-faithful models from a prompt, a photo, or a photo with back and side views.",
+      sortOrder: 60
+    }
+  ),
+  row(
+    "tripo-h3.1",
+    "Tripo H3.1",
+    {
+      family: "tripo",
+      endpoints: {
+        text: "tripo3d/h3.1/text-to-3d",
+        image: "tripo3d/h3.1/image-to-3d",
+        multiImage: "tripo3d/h3.1/multiview-to-3d"
+      },
+      text: true,
+      imageRequired: false,
+      views: "ordered",
+      maxImages: 4,
+      texture: ["none", "standard", "detailed"],
+      pbr: true,
+      textureRef: false,
+      seed: true
+    },
+    {
+      provider: "tripo",
+      description: "Clean, game-ready models from a prompt, a photo or four views.",
+      sortOrder: 50
+    }
+  ),
+  row(
+    "rodin-gen-2.5",
+    "Rodin Gen-2.5",
+    {
+      family: "rodin",
+      endpoints: {
+        text: "fal-ai/hyper3d/rodin/v2.5/text-to-3d",
+        image: "fal-ai/hyper3d/rodin/v2.5"
+      },
+      text: true,
+      imageRequired: false,
+      views: "unordered",
+      maxImages: 5,
+      texture: [],
+      pbr: false,
+      textureRef: false,
+      seed: true,
+      seedMax: 65535
+    },
+    {
+      provider: "hyper3d",
+      description: "Detailed PBR models from a prompt or up to five photos.",
+      sortOrder: 40
+    }
+  ),
+  row(
+    "meshy-7.1",
+    "Meshy 7.1",
+    {
+      family: "meshy",
+      endpoints: {
+        text: "meshy/v7.1/text-to-3d",
+        image: "meshy/v7.1/image-to-3d",
+        multiImage: "meshy/v7.1/multi-image-to-3d"
+      },
+      text: true,
+      imageRequired: false,
+      views: "unordered",
+      maxImages: 4,
+      texture: ["none", "standard"],
+      pbr: true,
+      textureRef: true,
+      seed: true
+    },
+    {
+      provider: "meshy",
+      description: "Models from a prompt or photos, with a texture prompt or texture image to restyle.",
+      sortOrder: 30
+    }
+  ),
+  row(
+    "hi3d-3.0",
+    "Hi3D 3.0",
+    {
+      family: "hi3d",
+      endpoints: {
+        image: "hitem3d/hi3d/v3.0/image-to-3d",
+        multiImage: "hitem3d/hi3d/v3.0/multi-view-to-3d"
+      },
+      text: false,
+      imageRequired: true,
+      views: "named",
+      maxImages: 4,
+      texture: ["none", "standard"],
+      pbr: true,
+      textureRef: false,
+      seed: false,
+      resolutions: { label: "Quality", options: ["quality", "master"], default: "quality" }
+    },
+    {
+      provider: "hitem3d",
+      description: "Highest-fidelity product models from a photo or four views. Slowest.",
+      sortOrder: 20
+    }
+  ),
+  row(
+    "sam-3d-objects",
+    "SAM 3D Objects",
+    {
+      family: "sam",
+      endpoints: { image: "fal-ai/sam-3/3d-objects" },
+      text: true,
+      imageRequired: true,
+      promptRequired: true,
+      views: "none",
+      maxImages: 1,
+      texture: [],
+      pbr: false,
+      textureRef: false,
+      seed: true
+    },
+    {
+      provider: "meta",
+      description: "Lifts one named object out of a real photo into a 3D model.",
+      sortOrder: 10
+    }
+  )
+];
+
 // src/catalog/other.ts
 var GOOGLE_LOGO2 = "https://d31vvfpk2ppdyq.cloudfront.net/assets/image/192485d2-a76a-4657-9c06-930b2c70badd_compressed.png";
 var ELEVENLABS_LOGO2 = "https://cdn.jsdelivr.net/npm/@lobehub/icons-static-png@1.97.0/light/elevenlabs.png";
@@ -5932,6 +6132,7 @@ var MODELS = [
   ...IMAGE_MODELS,
   ...VIDEO_MODELS,
   ...VIDEO_TOOL_MODELS,
+  ...MODEL3D_MODELS,
   ...OTHER_MODELS,
   ...MEDIA_NODE_MODELS
 ];
@@ -5940,11 +6141,11 @@ var MODELS = [
 var import_zod3 = require("zod");
 
 // src/resolve-provider-rules.ts
-function ruleRefusal(row, message, code) {
+function ruleRefusal(row2, message, code) {
   return new ModelKitError({
     code,
-    message: `${row.label}: ${message}`,
-    model: row.id,
+    message: `${row2.label}: ${message}`,
+    model: row2.id,
     retryable: false
   });
 }
@@ -6103,27 +6304,27 @@ function collisionIssues(rows) {
   const issues = [];
   const seenIds = /* @__PURE__ */ new Map();
   const seenAliases = /* @__PURE__ */ new Map();
-  rows.forEach((row, index) => {
-    if (seenIds.has(row.id)) {
+  rows.forEach((row2, index) => {
+    if (seenIds.has(row2.id)) {
       issues.push({
         index,
         path: ["id"],
-        message: `Duplicate model id "${row.id}"`
+        message: `Duplicate model id "${row2.id}"`
       });
     } else {
-      const aliasOwner = seenAliases.get(row.id);
+      const aliasOwner = seenAliases.get(row2.id);
       if (aliasOwner !== void 0) {
         issues.push({
           index: aliasOwner.index,
           path: ["aliases", aliasOwner.aliasIndex],
-          message: `Alias "${row.id}" collides with a model id`
+          message: `Alias "${row2.id}" collides with a model id`
         });
       }
-      seenIds.set(row.id, index);
+      seenIds.set(row2.id, index);
     }
     const local = /* @__PURE__ */ new Set();
-    for (const [aliasIndex, alias] of row.aliases.entries()) {
-      if (alias === row.id || seenIds.has(alias)) {
+    for (const [aliasIndex, alias] of row2.aliases.entries()) {
+      if (alias === row2.id || seenIds.has(alias)) {
         issues.push({
           index,
           path: ["aliases", aliasIndex],
@@ -6162,23 +6363,23 @@ var ConstraintsReadView = import_zod.z.looseObject({
   }).optional().catch(void 0)
 });
 var DEFAULT_CONVENTIONS = { referenceSyntax: "numbered" };
-function outputAudio(row) {
-  const view = ConstraintsReadView.safeParse(row.constraints);
+function outputAudio(row2) {
+  const view = ConstraintsReadView.safeParse(row2.constraints);
   return view.success ? view.data.audio : void 0;
 }
 var DefaultsReadView = import_zod.z.looseObject({
   generateAudio: import_zod.z.boolean().optional().catch(void 0)
 });
-function billedAudio(row, requested) {
-  const audio = outputAudio(row);
+function billedAudio(row2, requested) {
+  const audio = outputAudio(row2);
   if (audio === "never") return false;
   if (audio !== "optional") return true;
   if (requested !== void 0) return requested;
-  const defaults = DefaultsReadView.safeParse(row.defaults);
+  const defaults = DefaultsReadView.safeParse(row2.defaults);
   return (defaults.success ? defaults.data.generateAudio : void 0) ?? true;
 }
-function promptConventions(row) {
-  const view = ConstraintsReadView.safeParse(row.constraints);
+function promptConventions(row2) {
+  const view = ConstraintsReadView.safeParse(row2.constraints);
   const prompt = view.success ? view.data.prompt : void 0;
   if (prompt === void 0) return { ...DEFAULT_CONVENTIONS };
   const result = { referenceSyntax: prompt.referenceSyntax };
@@ -6189,22 +6390,111 @@ 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: [] };
+function normaliseConventions(row2) {
+  const view = RawConventionsView.safeParse(row2.constraints);
+  if (!view.success) return { row: row2, 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: [] };
+  if (!badAudio && !badPrompt) return { row: row2, invalidKeys: [] };
   const invalidKeys = [];
   if (badAudio) invalidKeys.push("constraints.audio");
   if (badPrompt) invalidKeys.push("constraints.prompt");
-  const entries = Object.entries(row.constraints).flatMap(([key, value]) => {
+  const entries = Object.entries(row2.constraints).flatMap(([key, value]) => {
     if (key === "audio" && badAudio) return [];
-    if (key === "prompt" && badPrompt) return [[key, promptConventions(row)]];
+    if (key === "prompt" && badPrompt) return [[key, promptConventions(row2)]];
     return [[key, value]];
   });
-  return { row: { ...row, constraints: Object.fromEntries(entries) }, invalidKeys };
+  return { row: { ...row2, constraints: Object.fromEntries(entries) }, invalidKeys };
+}
+
+// src/catalog/model3d-spec.ts
+function model3dConstraints(row2) {
+  if (row2.type !== "model3d") return void 0;
+  return row2.constraints.model3d;
+}
+var MODEL3D_IMAGE_SLOTS = {
+  none: ["image"],
+  named: ["image", "back", "left", "right"],
+  ordered: ["image", "left", "back", "right"],
+  unordered: ["image", "back", "left", "right", "top"]
+};
+function model3dInputRefusal(spec, wired) {
+  const top = spec.views === "unordered" && wired.top === true;
+  const anyView = spec.views !== "none" && (wired.back || wired.left || wired.right || top);
+  if (anyView && !wired.image) return "model3d_views_need_image";
+  if (spec.imageRequired && !wired.image) return "model3d_needs_image";
+  if (spec.promptRequired && !wired.prompt) return "model3d_needs_prompt";
+  if (!wired.image && !(spec.text && wired.prompt)) return "model3d_needs_input";
+  if (spec.views === "ordered") {
+    if ((wired.back || wired.right) && !wired.left) return "model3d_views_out_of_order";
+    if (wired.right && !wired.back) return "model3d_views_out_of_order";
+  }
+  return null;
+}
+function model3dSeedFits(spec, seed) {
+  return Number.isSafeInteger(seed) && seed >= 0 && seed <= (spec.seedMax ?? Number.MAX_SAFE_INTEGER);
+}
+function model3dTexture(spec, requested) {
+  if (requested !== void 0 && spec.texture.includes(requested)) return requested;
+  return spec.texture.includes("standard") ? "standard" : spec.texture[0] ?? "standard";
+}
+function model3dResolution(spec, requested) {
+  const res = spec.resolutions;
+  if (res === void 0) return void 0;
+  return requested !== void 0 && res.options.includes(requested) ? requested : res.default;
+}
+function model3dPricingSku(row2, options, inputs) {
+  const spec = model3dConstraints(row2);
+  if (spec === void 0) throw new Error(`${row2.id} is not a 3D model`);
+  const texture = model3dTexture(spec, options.texture);
+  const textured = spec.texture.length > 0 && texture !== "none";
+  const pbr = spec.pbr && textured && options.pbr === true;
+  const resolution = model3dResolution(spec, options.resolution);
+  switch (spec.family) {
+    case "meshy":
+      return `${row2.id}__${textured ? "textured" : "untextured"}`;
+    case "tripo":
+      return `${row2.id}__${inputs.image ? "image" : "text"}__${texture}`;
+    case "hunyuan":
+      return `${row2.id}${pbr ? "__pbr" : ""}${inputs.views ? "__views" : ""}`;
+    case "trellis":
+      return `${row2.id}__${resolution}`;
+    case "hi3d":
+      return `${row2.id}__${resolution}__${textured ? pbr ? "texture-pbr" : "texture" : "geometry"}`;
+    case "rodin":
+    case "sam":
+      return row2.id;
+  }
+}
+function model3dSkus(row2) {
+  const spec = model3dConstraints(row2);
+  if (spec === void 0) return [];
+  const textures = spec.texture.length > 0 ? spec.texture : [void 0];
+  const pbrs = spec.pbr ? [false, true] : [false];
+  const resolutions = spec.resolutions?.options ?? [void 0];
+  const images = spec.text && !spec.imageRequired ? [true, false] : [true];
+  const views = spec.views === "none" ? [false] : [false, true];
+  const skus = /* @__PURE__ */ new Set();
+  for (const texture of textures)
+    for (const pbr of pbrs)
+      for (const resolution of resolutions)
+        for (const image of images)
+          for (const view of views) {
+            if (view && !image) continue;
+            skus.add(
+              model3dPricingSku(
+                row2,
+                {
+                  ...texture !== void 0 && { texture },
+                  pbr,
+                  ...resolution !== void 0 && { resolution }
+                },
+                { image, views: view }
+              )
+            );
+          }
+  return [...skus].sort();
 }
 
 // src/catalog/input-spec.ts
@@ -6349,7 +6639,7 @@ var InputSpecSchema = import_zod2.z.strictObject({
     }
   }
 });
-function validateInputSpec(raw, row) {
+function validateInputSpec(raw, row2) {
   const parsed = InputSpecSchema.safeParse(raw);
   if (!parsed.success) {
     return {
@@ -6361,7 +6651,7 @@ function validateInputSpec(raw, row) {
     };
   }
   const spec = parsed.data;
-  const supportedTypes = TYPES_BY_ADAPTER.get(row.adapter);
+  const supportedTypes = TYPES_BY_ADAPTER.get(row2.adapter);
   if (supportedTypes === void 0) {
     return {
       ok: false,
@@ -6374,18 +6664,18 @@ function validateInputSpec(raw, row) {
     };
   }
   const issues = [];
-  const allowed = ALLOWED_KEYS_BY_TYPE.get(row.type);
-  if (allowed === void 0 || !supportedTypes.includes(row.type)) {
+  const allowed = ALLOWED_KEYS_BY_TYPE.get(row2.type);
+  if (allowed === void 0 || !supportedTypes.includes(row2.type)) {
     issues.push({
       path: [],
-      message: row.adapter === "fal" ? `inputSpec on fal rows is only supported for image rows, not "${row.type}"` : `inputSpec is not supported for "${row.type}" rows`
+      message: row2.adapter === "fal" ? `inputSpec on fal rows is only supported for image rows, not "${row2.type}"` : `inputSpec is not supported for "${row2.type}" rows`
     });
   } else {
     for (const key of Object.keys(spec.fields)) {
       if (!allowed.has(key)) {
         issues.push({
           path: ["fields", key],
-          message: `inputSpec.fields "${key}" is not supported for ${row.type} rows`
+          message: `inputSpec.fields "${key}" is not supported for ${row2.type} rows`
         });
       }
     }
@@ -6393,13 +6683,13 @@ function validateInputSpec(raw, row) {
       if (!allowed.has(key)) {
         issues.push({
           path: ["values", key],
-          message: `inputSpec.values "${key}" is not supported for ${row.type} rows`
+          message: `inputSpec.values "${key}" is not supported for ${row2.type} rows`
         });
       }
     }
   }
   if (spec.editEndpoint !== void 0) {
-    if (row.adapter !== "fal") {
+    if (row2.adapter !== "fal") {
       issues.push({
         path: ["editEndpoint"],
         message: "inputSpec.editEndpoint is only supported on fal rows"
@@ -6443,7 +6733,7 @@ function validateInputSpec(raw, row) {
       if (allowed !== void 0 && !allowed.has(key)) {
         issues.push({
           path: ["arrays", name],
-          message: `inputSpec.arrays "${key}" is not supported for ${row.type} rows`
+          message: `inputSpec.arrays "${key}" is not supported for ${row2.type} rows`
         });
       }
       if (key in spec.fields) {
@@ -6463,7 +6753,7 @@ function validateInputSpec(raw, row) {
     }
   }
   if (spec.dimensions !== void 0) {
-    if (row.type !== "image") {
+    if (row2.type !== "image") {
       issues.push({
         path: ["dimensions"],
         message: "inputSpec.dimensions is only supported on image rows"
@@ -6485,7 +6775,7 @@ function validateInputSpec(raw, row) {
       });
     }
   }
-  const supports = row.constraints.supports ?? [];
+  const supports = row2.constraints.supports ?? [];
   for (const key of INPUT_SPEC_SUPPORTS_KEYS) {
     if (supports.includes(key)) continue;
     if (key in spec.fields) {
@@ -6530,8 +6820,8 @@ function listIssues(name, values, fallback, defaultKey) {
   }
   return issues;
 }
-function optionListIssues(row) {
-  const { constraints, defaults } = row;
+function optionListIssues(row2) {
+  const { constraints, defaults } = row2;
   const issues = [
     ...listIssues(
       "voices",
@@ -6589,7 +6879,8 @@ var ModelTypeSchema = import_zod3.z.enum([
   "voice-change",
   "dubbing",
   "lipsync",
-  "transcription"
+  "transcription",
+  "model3d"
 ]);
 var LifecycleSchema = import_zod3.z.enum(["active", "deprecated", "retired"]);
 var SurfaceSchema = import_zod3.z.enum(["cowork", "space_builder"]);
@@ -6653,7 +6944,8 @@ var UsageUnitSchema = import_zod3.z.enum([
   "images",
   "seconds",
   "reported_cost_usd",
-  "compute_seconds"
+  "compute_seconds",
+  "requests"
 ]);
 var PricingKindSchema = import_zod3.z.enum(["token", "image_size", "video_per_second", "flat"]);
 var ProviderOptionValueSchema = import_zod3.z.lazy(
@@ -6707,6 +6999,156 @@ var LanguageOptionSchema = import_zod3.z.looseObject({
   code: import_zod3.z.string().min(1),
   name: import_zod3.z.string().min(1)
 });
+var MODEL3D_FAMILY_RULES = {
+  trellis: {
+    textPath: false,
+    views: ["none"],
+    multiImage: false,
+    texture: null,
+    pbr: false,
+    seed: true,
+    textureRef: false,
+    resolutions: "integer"
+  },
+  hunyuan: {
+    textPath: true,
+    views: ["none", "named"],
+    multiImage: false,
+    texture: ["none", "standard"],
+    pbr: true,
+    seed: false,
+    textureRef: false,
+    resolutions: null
+  },
+  tripo: {
+    textPath: true,
+    views: ["none", "ordered"],
+    multiImage: true,
+    texture: ["none", "standard", "detailed"],
+    pbr: true,
+    seed: true,
+    textureRef: false,
+    resolutions: null
+  },
+  rodin: {
+    textPath: true,
+    views: ["none", "unordered"],
+    multiImage: false,
+    texture: null,
+    pbr: false,
+    seed: true,
+    textureRef: false,
+    resolutions: null
+  },
+  meshy: {
+    textPath: true,
+    views: ["none", "unordered"],
+    multiImage: true,
+    texture: ["none", "standard"],
+    pbr: true,
+    seed: true,
+    textureRef: true,
+    resolutions: null
+  },
+  hi3d: {
+    textPath: false,
+    views: ["none", "named"],
+    multiImage: true,
+    texture: ["none", "standard"],
+    pbr: true,
+    seed: false,
+    textureRef: false,
+    resolutions: ["quality", "master"]
+  },
+  sam: {
+    textPath: false,
+    views: ["none"],
+    multiImage: false,
+    texture: null,
+    pbr: false,
+    seed: true,
+    textureRef: false,
+    resolutions: null
+  }
+};
+function model3dSpecIssues(spec) {
+  const issues = [];
+  const add = (path, message) => issues.push({ path, message });
+  const rules = MODEL3D_FAMILY_RULES[spec.family];
+  const promptOnly = spec.text && !spec.imageRequired;
+  if (spec.endpoints.image === void 0)
+    add(["endpoints", "image"], "every row needs an image endpoint");
+  if (promptOnly && !rules.textPath) {
+    add(
+      ["imageRequired"],
+      `${spec.family} has no text-to-3D endpoint; a text row needs an image`
+    );
+  }
+  if (promptOnly && spec.endpoints.text === void 0) {
+    add(["endpoints", "text"], "a text row needs a text endpoint");
+  }
+  if (!rules.views.includes(spec.views)) {
+    add(["views"], `${spec.family} takes views ${rules.views.join(" or ")}`);
+  }
+  if (spec.views === "none" && spec.maxImages !== 1) {
+    add(["maxImages"], "a row without views takes 1 image");
+  }
+  if (spec.views === "unordered" && spec.maxImages < 2) {
+    add(["maxImages"], "a row with views takes at least 2 images");
+  }
+  const slots = MODEL3D_IMAGE_SLOTS[spec.views].length;
+  if (spec.views !== "none" && spec.maxImages > slots) {
+    add(["maxImages"], `a row with ${spec.views} views sends at most ${slots} images`);
+  }
+  if ((spec.views === "named" || spec.views === "ordered") && spec.maxImages < slots) {
+    add(
+      ["maxImages"],
+      `a row with ${spec.views} views takes ${slots} images (front and three sides)`
+    );
+  }
+  if (spec.views !== "none" && rules.multiImage && spec.endpoints.multiImage === void 0) {
+    add(["endpoints", "multiImage"], `${spec.family} sends views to a multi-image endpoint`);
+  }
+  if (rules.texture === null) {
+    if (spec.texture.length > 0) add(["texture"], `${spec.family} has no texture switch`);
+  } else {
+    const allowed = rules.texture;
+    if (spec.texture.length === 0) add(["texture"], `${spec.family} needs its texture options`);
+    if (new Set(spec.texture).size !== spec.texture.length)
+      add(["texture"], "texture options repeat");
+    for (const t of spec.texture) {
+      if (!allowed.includes(t)) add(["texture"], `${spec.family} has no "${t}" texture`);
+    }
+  }
+  if (spec.pbr && !rules.pbr) add(["pbr"], `${spec.family} has no PBR switch`);
+  if (spec.pbr && !spec.texture.some((t) => t !== "none")) {
+    add(["pbr"], "PBR needs a textured option");
+  }
+  if (spec.seed && !rules.seed) add(["seed"], `${spec.family} takes no seed`);
+  if (spec.seedMax !== void 0 && !spec.seed) add(["seedMax"], "seedMax needs seed");
+  if (spec.textureRef && !rules.textureRef)
+    add(["textureRef"], `${spec.family} takes no texture reference`);
+  const res = spec.resolutions;
+  if (rules.resolutions === null) {
+    if (res !== void 0) add(["resolutions"], `${spec.family} has no resolution option`);
+  } else if (res === void 0) {
+    add(["resolutions"], `${spec.family} needs its resolution options`);
+  } else {
+    if (!res.options.includes(res.default)) {
+      add(["resolutions", "default"], "default must be an option");
+    }
+    if (new Set(res.options).size !== res.options.length) {
+      add(["resolutions", "options"], "resolution options repeat");
+    }
+    const allowed = rules.resolutions;
+    for (const option of res.options) {
+      const ok = allowed === "integer" ? /^[1-9][0-9]*$/.test(option) : allowed.includes(option);
+      if (!ok)
+        add(["resolutions", "options"], `${spec.family} has no "${option}" resolution`);
+    }
+  }
+  return issues;
+}
 var VideoToolConstraintsSchema = import_zod3.z.looseObject({
   kind: import_zod3.z.enum(["upscale", "interpolate", "hdr", "bg-remove", "subtitles"]),
   upscaleFactor: RangeSchema.optional(),
@@ -6723,6 +7165,30 @@ var VideoToolConstraintsSchema = import_zod3.z.looseObject({
   translationLanguages: import_zod3.z.array(import_zod3.z.string().min(1)).min(1).optional(),
   maxSecondsAbove1080p: import_zod3.z.number().positive().optional()
 });
+var Model3dTextureSchema = import_zod3.z.enum(["none", "standard", "detailed"]);
+var Model3dConstraintsSchema = import_zod3.z.looseObject({
+  family: import_zod3.z.enum(["trellis", "hunyuan", "tripo", "rodin", "meshy", "hi3d", "sam"]),
+  endpoints: import_zod3.z.looseObject({
+    text: import_zod3.z.string().min(1).optional(),
+    image: import_zod3.z.string().min(1).optional(),
+    multiImage: import_zod3.z.string().min(1).optional()
+  }),
+  text: import_zod3.z.boolean(),
+  imageRequired: import_zod3.z.boolean(),
+  promptRequired: import_zod3.z.boolean().optional(),
+  views: import_zod3.z.enum(["none", "unordered", "ordered", "named"]),
+  maxImages: import_zod3.z.number().int().positive(),
+  texture: import_zod3.z.array(Model3dTextureSchema),
+  pbr: import_zod3.z.boolean(),
+  textureRef: import_zod3.z.boolean(),
+  seed: import_zod3.z.boolean(),
+  seedMax: import_zod3.z.number().int().positive().optional(),
+  resolutions: import_zod3.z.looseObject({
+    label: import_zod3.z.string().min(1),
+    options: import_zod3.z.array(import_zod3.z.string().min(1)).min(1),
+    default: import_zod3.z.string().min(1)
+  }).optional()
+});
 var ModelConstraintsSchema = import_zod3.z.looseObject({
   aspectRatios: import_zod3.z.array(AspectRatioSchema).optional(),
   sizes: import_zod3.z.array(ImageSizeSchema).optional(),
@@ -6750,6 +7216,7 @@ var ModelConstraintsSchema = import_zod3.z.looseObject({
     returns: import_zod3.z.enum(["new", "joined"]).optional()
   }).optional(),
   tool: VideoToolConstraintsSchema.optional(),
+  model3d: Model3dConstraintsSchema.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(),
@@ -6865,29 +7332,47 @@ var CatalogModelSchemaBase = import_zod3.z.looseObject({
   pricingKind: PricingKindSchema,
   display: CatalogDisplaySchema.optional(),
   capabilities: CatalogCapabilitiesSchema.optional()
-}).superRefine((row, ctx) => {
-  if (row.lifecycle === "active" && !row.display) {
+}).superRefine((row2, ctx) => {
+  if (row2.lifecycle === "active" && !row2.display) {
     ctx.addIssue({
       code: "custom",
       path: ["display"],
       message: "active rows need display"
     });
   }
-  if (row.lifecycle === "active" && row.type === "text" && !row.capabilities?.contextWindow) {
+  if (row2.lifecycle === "active" && row2.type === "text" && !row2.capabilities?.contextWindow) {
     ctx.addIssue({
       code: "custom",
       path: ["capabilities", "contextWindow"],
       message: "active text rows need contextWindow"
     });
   }
-  if (row.type === "video-tool" && row.constraints.tool === void 0) {
+  if (row2.type === "video-tool" && row2.constraints.tool === void 0) {
     ctx.addIssue({
       code: "custom",
       path: ["constraints", "tool"],
       message: "video-tool rows need constraints.tool"
     });
   }
-  if (row.replacedBy !== void 0 && row.replacedBy === row.id) {
+  if (row2.type === "model3d") {
+    const spec = row2.constraints.model3d;
+    if (spec === void 0) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["constraints", "model3d"],
+        message: "model3d rows need constraints.model3d"
+      });
+    } else {
+      for (const issue of model3dSpecIssues(spec)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["constraints", "model3d", ...issue.path],
+          message: issue.message
+        });
+      }
+    }
+  }
+  if (row2.replacedBy !== void 0 && row2.replacedBy === row2.id) {
     ctx.addIssue({
       code: "custom",
       path: ["replacedBy"],
@@ -6896,8 +7381,8 @@ var CatalogModelSchemaBase = import_zod3.z.looseObject({
   }
 });
 var CatalogModelSchema = CatalogModelSchemaBase.superRefine(
-  (row, ctx) => {
-    const transport = row.providerOptions?.["modelkit"]?.["transport"];
+  (row2, ctx) => {
+    const transport = row2.providerOptions?.["modelkit"]?.["transport"];
     if (transport !== void 0 && transport !== "direct" && transport !== "bedrock") {
       ctx.addIssue({
         code: "custom",
@@ -6905,9 +7390,9 @@ var CatalogModelSchema = CatalogModelSchemaBase.superRefine(
         message: 'transport must be "direct" or "bedrock"'
       });
     }
-    const inputSpecRaw = row.providerOptions?.["modelkit"]?.["inputSpec"];
+    const inputSpecRaw = row2.providerOptions?.["modelkit"]?.["inputSpec"];
     if (inputSpecRaw !== void 0) {
-      const result = validateInputSpec(inputSpecRaw, row);
+      const result = validateInputSpec(inputSpecRaw, row2);
       if (!result.ok) {
         for (const issue of result.issues) {
           ctx.addIssue({
@@ -6918,7 +7403,7 @@ var CatalogModelSchema = CatalogModelSchemaBase.superRefine(
         }
       }
     }
-    const audio = row.constraints.audio;
+    const audio = row2.constraints.audio;
     if (audio !== void 0 && !AudioOutputSchema.safeParse(audio).success) {
       ctx.addIssue({
         code: "custom",
@@ -6926,7 +7411,7 @@ var CatalogModelSchema = CatalogModelSchemaBase.superRefine(
         message: 'audio must be "always", "optional" or "never"'
       });
     }
-    const refs = row.constraints.references;
+    const refs = row2.constraints.references;
     for (const kind of ["images", "videos", "audios"]) {
       const least = refs?.min?.[kind];
       const most = refs?.[kind];
@@ -6938,10 +7423,10 @@ var CatalogModelSchema = CatalogModelSchemaBase.superRefine(
         });
       }
     }
-    for (const issue of optionListIssues(row)) {
+    for (const issue of optionListIssues(row2)) {
       ctx.addIssue({ code: "custom", path: issue.path, message: issue.message });
     }
-    const prompt = row.constraints.prompt;
+    const prompt = row2.constraints.prompt;
     if (prompt !== void 0) {
       const parsed = PromptConventionsSchema.safeParse(prompt);
       if (!parsed.success) {
@@ -6956,7 +7441,7 @@ var CatalogModelSchema = CatalogModelSchemaBase.superRefine(
     }
   }
 );
-var CatalogSchema = import_zod3.z.array(CatalogModelSchemaBase.transform((row) => normaliseConventions(row).row)).superRefine((rows, ctx) => {
+var CatalogSchema = import_zod3.z.array(CatalogModelSchemaBase.transform((row2) => normaliseConventions(row2).row)).superRefine((rows, ctx) => {
   for (const issue of collisionIssues(rows)) {
     ctx.addIssue({
       code: "custom",
@@ -7030,22 +7515,22 @@ function quarantine(rawRows, logger) {
       dropped += 1;
       continue;
     }
-    const row = parsed.data;
-    const inputSpecRaw = row.providerOptions?.["modelkit"]?.["inputSpec"];
+    const row2 = parsed.data;
+    const inputSpecRaw = row2.providerOptions?.["modelkit"]?.["inputSpec"];
     if (inputSpecRaw !== void 0) {
-      const result = validateInputSpec(inputSpecRaw, row);
+      const result = validateInputSpec(inputSpecRaw, row2);
       if (!result.ok) {
         const first = result.issues[0];
         const detail = first ? dropReason(first.path, first.message) : "invalid inputSpec";
         logger.warn(
-          `[modelkit] catalog row ${row.id} has an invalid providerOptions.modelkit.inputSpec: ${detail}; calls fail until it is fixed`
+          `[modelkit] catalog row ${row2.id} has an invalid providerOptions.modelkit.inputSpec: ${detail}; calls fail until it is fixed`
         );
       }
     }
-    const normalised = normaliseConventions(row);
+    const normalised = normaliseConventions(row2);
     if (normalised.invalidKeys.length > 0) {
       logger.warn(
-        `[modelkit] catalog row ${row.id} has an invalid ${normalised.invalidKeys.join(", ")}; read as not set`
+        `[modelkit] catalog row ${row2.id} has an invalid ${normalised.invalidKeys.join(", ")}; read as not set`
       );
     }
     valid.push(normalised.row);
@@ -7059,10 +7544,10 @@ function quarantine(rawRows, logger) {
       if (!firstByIndex.has(issue.index)) firstByIndex.set(issue.index, issue);
     }
     for (const [index, issue] of [...firstByIndex.entries()].sort((a, b) => a[0] - b[0])) {
-      const row = kept[index];
-      if (!row) continue;
+      const row2 = kept[index];
+      if (!row2) continue;
       logger.warn(
-        `[modelkit] catalog row dropped id=${row.id} reason=${String(issue.path[0] ?? "")} ${issue.message}`
+        `[modelkit] catalog row dropped id=${row2.id} reason=${String(issue.path[0] ?? "")} ${issue.message}`
       );
     }
     const dropSet = new Set(firstByIndex.keys());
@@ -7281,9 +7766,9 @@ var ToolSchema = import_zod6.z.object({
   translationLanguages: import_zod6.z.array(import_zod6.z.string().min(1)).min(1).optional(),
   maxSecondsAbove1080p: import_zod6.z.number().positive().optional()
 });
-function videoToolConstraints(row) {
-  if (row.type !== "video-tool") return void 0;
-  const parsed = ToolSchema.safeParse(row.constraints.tool);
+function videoToolConstraints(row2) {
+  if (row2.type !== "video-tool") return void 0;
+  const parsed = ToolSchema.safeParse(row2.constraints.tool);
   if (!parsed.success) return void 0;
   const {
     kind,
@@ -7330,16 +7815,16 @@ function resolutionTier(width, height) {
 function fail(error) {
   return { ok: false, error };
 }
-function planVideoTool(row, req) {
-  const tool = videoToolConstraints(row);
-  if (!tool) return fail(`${row.id} is not a video tool`);
+function planVideoTool(row2, req) {
+  const tool = videoToolConstraints(row2);
+  if (!tool) return fail(`${row2.id} is not a video tool`);
   const { width, height, durationSeconds, fps } = req.source;
   if (!(width > 0 && height > 0 && durationSeconds > 0)) {
     return fail("The source video's width, height and duration are required");
   }
-  const maxSeconds = row.constraints.sourceVideoSeconds?.max;
+  const maxSeconds = row2.constraints.sourceVideoSeconds?.max;
   if (maxSeconds !== void 0 && overMax(durationSeconds, maxSeconds)) {
-    return fail(`${row.label} takes source videos up to ${maxSeconds} seconds.`);
+    return fail(`${row2.label} takes source videos up to ${maxSeconds} seconds.`);
   }
   const base = {
     durationSeconds,
@@ -7350,7 +7835,7 @@ function planVideoTool(row, req) {
     if (factor === void 0) return fail("An upscale factor is required");
     const range2 = tool.upscaleFactor;
     if (range2 && (factor < range2.min || factor > range2.max)) {
-      return fail(`${row.label} upscales by ${range2.min}x to ${range2.max}x.`);
+      return fail(`${row2.label} upscales by ${range2.min}x to ${range2.max}x.`);
     }
     const outWidth = Math.round(width * factor);
     const outHeight = Math.round(height * factor);
@@ -7378,7 +7863,7 @@ function planVideoTool(row, req) {
     }
     const range2 = tool.fps;
     if (range2 && (target < range2.min || target > range2.max)) {
-      return fail(`${row.label} outputs ${range2.min} to ${range2.max} fps.`);
+      return fail(`${row2.label} outputs ${range2.min} to ${range2.max} fps.`);
     }
     return {
       ok: true,
@@ -7407,7 +7892,7 @@ function planVideoTool(row, req) {
   if (tool.kind === "subtitles") {
     const resolution = resolutionTier(width, height);
     const problem = subtitleProblem(
-      row.label,
+      row2.label,
       tool,
       req.subtitles,
       resolution,
@@ -7419,9 +7904,9 @@ function planVideoTool(row, req) {
   const formats = tool.outputFormats ?? ["h265"];
   const format = req.outputFormat ?? formats[0] ?? "h265";
   if (!formats.includes(format)) {
-    return fail(`${row.label} writes ${formats.join(" or ")}.`);
+    return fail(`${row2.label} writes ${formats.join(" or ")}.`);
   }
-  const timing = renderedTiming(row, tool, durationSeconds, fps);
+  const timing = renderedTiming(row2, tool, durationSeconds, fps);
   if (!timing.ok) return fail(timing.error);
   const out = shrinkToShortEdge(width, height, tool.maxOutputShortEdge);
   return {
@@ -7437,7 +7922,7 @@ function planVideoTool(row, req) {
   };
 }
 var DEFAULT_FPS = 24;
-function renderedTiming(row, tool, durationSeconds, fps) {
+function renderedTiming(row2, tool, durationSeconds, fps) {
   const { maxOutputFps, minOutputFrames, maxOutputFrames } = tool;
   if (maxOutputFps === void 0 && minOutputFrames === void 0 && maxOutputFrames === void 0) {
     return fps !== void 0 ? { ok: true, fps } : { ok: true };
@@ -7446,7 +7931,7 @@ function renderedTiming(row, tool, durationSeconds, fps) {
   const frames = Math.max(minOutputFrames ?? 1, Math.round(durationSeconds * rate));
   if (maxOutputFrames !== void 0 && frames > maxOutputFrames) {
     const limit = `${maxOutputFrames} frames (${seconds(maxOutputFrames, rate)})`;
-    return { ok: false, error: `${row.label} renders up to ${limit}.` };
+    return { ok: false, error: `${row2.label} renders up to ${limit}.` };
   }
   return { ok: true, fps: rate, frames, durationSeconds: frames / rate };
 }
@@ -7790,6 +8275,30 @@ function applyFalImageRules(model, req, callerSize, warnings) {
   req.size = exact.tier;
 }
 
+// src/replicate-video-kinds.ts
+function replicateBaseModelId(providerModelId) {
+  const colon = providerModelId.indexOf(":");
+  return colon === -1 ? providerModelId : providerModelId.slice(0, colon);
+}
+var REPLICATE_VIDEO_KINDS = /* @__PURE__ */ new Map([
+  ["kling-video/v2.5-turbo/pro/image-to-video", "kling"],
+  ["kling-video/v3.0/pro/image-to-video", "kling"],
+  ["kwaivgi/kling-v3-video", "kling"],
+  ["kwaivgi/kling-v3-omni-video", "kling-omni"],
+  ["minimax/hailuo-02", "hailuo"]
+]);
+function videoKind(providerModelId) {
+  return REPLICATE_VIDEO_KINDS.get(replicateBaseModelId(providerModelId));
+}
+var KLING_TIERS = [
+  { mode: "standard", resolution: "720p" },
+  { mode: "pro", resolution: "1080p" },
+  { mode: "4k", resolution: "4k" }
+];
+function klingTier(req) {
+  return KLING_TIERS.find((tier) => tier.resolution === req.resolution) ?? KLING_TIERS.find((tier) => tier.mode === req.mode) ?? KLING_TIERS[0];
+}
+
 // src/resolve-video-rules.ts
 var MOTION_PRO = "fal-ai/kling-video/v3/pro/motion-control";
 var MOTION_STANDARD = "fal-ai/kling-video/v3/standard/motion-control";
@@ -7963,6 +8472,16 @@ function h3EndFrameRatioWarning(model, ratio) {
     message: `${model.id} follows the end frame's aspect ratio`
   };
 }
+function isReplicateKling(model) {
+  if (model.adapter !== "replicate") return false;
+  const kind = videoKind(model.providerModelId);
+  return kind === "kling" || kind === "kling-omni";
+}
+function fillReplicateKlingResolution(model, req) {
+  if (isReplicateKling(model) && req.resolution === void 0) {
+    req.resolution = klingTier(req).resolution;
+  }
+}
 function applyFalVideoRules(model, req, callerRatio, warnings) {
   if (model.adapter !== "fal") return;
   const problem = falVideoProblem(model.providerModelId, withPromptForResolve(req));
@@ -8352,8 +8871,10 @@ function resolveVideoOptions(model, request, onUnsupported = "error") {
     warnings
   );
   if (aspectRatio !== void 0) merged.aspectRatio = aspectRatio;
+  fillReplicateKlingResolution(model, merged);
   const resolution = resolveVideoResolution(merged.resolution, model, onUnsupported, warnings);
   if (resolution !== void 0) merged.resolution = resolution;
+  if (isReplicateKling(model)) delete merged.mode;
   const duration = resolveDuration(
     merged.durationSeconds,
     c.durations,
@@ -8759,7 +9280,10 @@ var MEDIA_METHODS = {
   lipsync: ["lipsync"],
   dubbing: ["dub"],
   transcription: ["transcribe"],
-  "video-tool": ["submitVideoTool"]
+  "video-tool": ["submitVideoTool"],
+  // 3D jobs run through submitModel3d, which checks the row type itself; their preflight
+  // is model3dInputRefusal, not resolveOptions.
+  model3d: []
 };
 var METHOD_NOUN = {
   generateImage: "an image model",