@shop-os/modelkit 0.5.0 → 0.6.0

package/dist/index.cjs

@@ -46,6 +46,8 @@ __export(index_exports, {
   InputSpecSchema: () => InputSpecSchema,
   JsonObjectSchema: () => JsonObjectSchema,
   JsonValueSchema: () => JsonValueSchema,
+  MODEL3D_IMAGE_SLOTS: () => MODEL3D_IMAGE_SLOTS,
+  MODEL3D_MODELS: () => MODEL3D_MODELS,
   MODELS: () => MODELS,
   ModelKitError: () => ModelKitError,
   SURFACES: () => SURFACES2,
@@ -88,6 +90,14 @@ __export(index_exports, {
   liveState: () => liveState,
   mergeTextProviderOptions: () => mergeTextProviderOptions,
   missingTierKeys: () => missingTierKeys,
+  model3dCall: () => model3dCall,
+  model3dConstraints: () => model3dConstraints,
+  model3dInputRefusal: () => model3dInputRefusal,
+  model3dPricingSku: () => model3dPricingSku,
+  model3dResolution: () => model3dResolution,
+  model3dSeedFits: () => model3dSeedFits,
+  model3dSkus: () => model3dSkus,
+  model3dTexture: () => model3dTexture,
   nearestAspectRatio: () => nearestAspectRatio,
   normalizeExposure: () => normalizeExposure,
   openaiImageAdapter: () => openaiImageAdapter,
@@ -265,18 +275,18 @@ function normalizeExposure(value) {
     if (value.every(
       (entry) => SURFACES.includes(entry)
     )) {
-      const present = new Set(value);
-      return SURFACES.filter((surface) => present.has(surface));
+      const present2 = new Set(value);
+      return SURFACES.filter((surface) => present2.has(surface));
     }
     return 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
@@ -3678,6 +3688,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";
@@ -5996,6 +6197,7 @@ var MODELS = [
   ...IMAGE_MODELS,
   ...VIDEO_MODELS,
   ...VIDEO_TOOL_MODELS,
+  ...MODEL3D_MODELS,
   ...OTHER_MODELS,
   ...MEDIA_NODE_MODELS
 ];
@@ -6004,11 +6206,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
   });
 }
@@ -6167,27 +6369,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],
@@ -6229,8 +6431,8 @@ var DEFAULT_CONVENTIONS = { referenceSyntax: "numbered" };
 var DefaultsReadView = import_zod.z.looseObject({
   generateAudio: import_zod.z.boolean().optional().catch(void 0)
 });
-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 };
@@ -6241,22 +6443,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
@@ -6407,7 +6698,7 @@ function isInputSpecKey(key) {
 function isArrayInputSpecKey(key) {
   return ARRAY_KEY_SET.has(key);
 }
-function validateInputSpec(raw, row) {
+function validateInputSpec(raw, row2) {
   const parsed = InputSpecSchema.safeParse(raw);
   if (!parsed.success) {
     return {
@@ -6419,7 +6710,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,
@@ -6432,18 +6723,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`
         });
       }
     }
@@ -6451,13 +6742,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"
@@ -6501,7 +6792,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) {
@@ -6521,7 +6812,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"
@@ -6543,7 +6834,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) {
@@ -6588,8 +6879,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",
@@ -6647,7 +6938,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"]);
@@ -6711,7 +7003,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(
@@ -6765,6 +7058,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(),
@@ -6781,6 +7224,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(),
@@ -6808,6 +7275,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(),
@@ -6923,29 +7391,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"],
@@ -6954,8 +7440,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",
@@ -6963,9 +7449,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({
@@ -6976,7 +7462,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",
@@ -6984,7 +7470,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];
@@ -6996,10 +7482,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) {
@@ -7014,7 +7500,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",
@@ -8017,7 +8503,7 @@ async function generateSeedanceVideo(req, ctx) {
 }
 
 // src/adapters/fal.ts
-var import_zod18 = require("zod");
+var import_zod20 = require("zod");
 var import_client = require("@fal-ai/client");
 
 // src/adapters/fal-http.ts
@@ -8322,7 +8808,7 @@ async function passthroughVideoJob(ctx, endpoint, input, decode) {
 }
 
 // src/adapters/fal-video-tools.ts
-var import_zod12 = require("zod");
+var import_zod13 = require("zod");
 
 // src/video-length.ts
 function tenths(seconds3) {
@@ -8413,28 +8899,99 @@ function subtitleFields(tool, options) {
   return out;
 }
 
-// src/catalog/video-tools-spec.ts
+// src/adapters/fal-queue.ts
 var import_zod11 = require("zod");
-var RangeSchema2 = import_zod11.z.object({ min: import_zod11.z.number(), max: import_zod11.z.number() });
-var ToolSchema = import_zod11.z.object({
-  kind: import_zod11.z.enum(["upscale", "interpolate", "hdr", "bg-remove", "subtitles"]),
+var FAL_QUEUE_ORIGIN = "https://queue.fal.run";
+var queueUrlSchema = import_zod11.z.url().refine((value) => new URL(value).origin === FAL_QUEUE_ORIGIN, {
+  message: "not a fal queue URL"
+});
+var submitResponseSchema = import_zod11.z.object({
+  request_id: import_zod11.z.string().min(1),
+  status_url: queueUrlSchema,
+  response_url: queueUrlSchema,
+  cancel_url: queueUrlSchema
+});
+var statusResponseSchema = import_zod11.z.object({ status: import_zod11.z.string() });
+var falWebhookBodySchema = import_zod11.z.object({
+  request_id: import_zod11.z.string().min(1),
+  gateway_request_id: import_zod11.z.string().nullish(),
+  status: import_zod11.z.enum(["OK", "ERROR"]),
+  payload: JsonValueSchema.nullish(),
+  error: import_zod11.z.string().nullish(),
+  payload_error: JsonValueSchema.nullish()
+});
+async function queueFetch(ctx, url, method, body) {
+  const payload = body === void 0 ? void 0 : JSON.stringify(body);
+  try {
+    if (ctx.routing.fal === "cloudflare-passthrough") {
+      return await gatewayFetch(gatewayConfig(ctx), ctx.fetch, url, {
+        method,
+        ...payload !== void 0 && { body: payload }
+      });
+    }
+    const falKey = ctx.keys.fal;
+    if (!falKey) {
+      throw new ModelKitError({
+        code: "auth",
+        message: "Missing API key for fal",
+        provider: "fal",
+        model: ctx.model.id,
+        retryable: false
+      });
+    }
+    return await ctx.fetch(url, {
+      method,
+      headers: {
+        Authorization: `Key ${falKey}`,
+        ...payload !== void 0 && { "Content-Type": "application/json" }
+      },
+      ...payload !== void 0 && { body: payload },
+      ...ctx.signal !== void 0 && { signal: ctx.signal }
+    });
+  } catch (cause) {
+    if (cause instanceof ModelKitError) throw cause;
+    throw classifyThrown("fal", cause, ctx.model.id);
+  }
+}
+async function readJson(ctx, res) {
+  if (!res.ok) throw falError(res.status, await readBody(res), ctx.model.id);
+  return JsonValueSchema.parse(await res.json());
+}
+function checkedQueueUrl(ctx, url, what) {
+  if (!queueUrlSchema.safeParse(url).success) {
+    throw new ModelKitError({
+      code: "provider_rejected",
+      message: `${what} submission carries a URL outside fal's queue`,
+      provider: "fal",
+      model: ctx.model.id,
+      retryable: false
+    });
+  }
+  return url;
+}
+
+// src/catalog/video-tools-spec.ts
+var import_zod12 = require("zod");
+var RangeSchema2 = import_zod12.z.object({ min: import_zod12.z.number(), max: import_zod12.z.number() });
+var ToolSchema = import_zod12.z.object({
+  kind: import_zod12.z.enum(["upscale", "interpolate", "hdr", "bg-remove", "subtitles"]),
   upscaleFactor: RangeSchema2.optional(),
-  maxOutputLongEdge: import_zod11.z.number().positive().optional(),
-  prompt: import_zod11.z.boolean().optional(),
+  maxOutputLongEdge: import_zod12.z.number().positive().optional(),
+  prompt: import_zod12.z.boolean().optional(),
   fps: RangeSchema2.optional(),
-  outputFormats: import_zod11.z.array(import_zod11.z.enum(["h265", "prores", "exr"])).min(1).optional(),
-  maxOutputShortEdge: import_zod11.z.number().positive().optional(),
-  maxOutputFrames: import_zod11.z.number().positive().optional(),
-  minOutputFrames: import_zod11.z.number().positive().optional(),
-  maxOutputFps: import_zod11.z.number().positive().optional(),
-  presets: import_zod11.z.array(import_zod11.z.string().min(1)).min(1).optional(),
-  languages: import_zod11.z.array(import_zod11.z.string().min(1)).min(1).optional(),
-  translationLanguages: import_zod11.z.array(import_zod11.z.string().min(1)).min(1).optional(),
-  maxSecondsAbove1080p: import_zod11.z.number().positive().optional()
+  outputFormats: import_zod12.z.array(import_zod12.z.enum(["h265", "prores", "exr"])).min(1).optional(),
+  maxOutputShortEdge: import_zod12.z.number().positive().optional(),
+  maxOutputFrames: import_zod12.z.number().positive().optional(),
+  minOutputFrames: import_zod12.z.number().positive().optional(),
+  maxOutputFps: import_zod12.z.number().positive().optional(),
+  presets: import_zod12.z.array(import_zod12.z.string().min(1)).min(1).optional(),
+  languages: import_zod12.z.array(import_zod12.z.string().min(1)).min(1).optional(),
+  translationLanguages: import_zod12.z.array(import_zod12.z.string().min(1)).min(1).optional(),
+  maxSecondsAbove1080p: import_zod12.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,
@@ -8481,16 +9038,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,
@@ -8501,7 +9058,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);
@@ -8529,7 +9086,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,
@@ -8558,7 +9115,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,
@@ -8570,9 +9127,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 {
@@ -8588,7 +9145,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 };
@@ -8597,7 +9154,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 };
 }
@@ -8612,76 +9169,20 @@ function shrinkToShortEdge(width, height, limit) {
 }
 
 // src/adapters/fal-video-tools.ts
-var FAL_QUEUE_ORIGIN = "https://queue.fal.run";
-var queueUrlSchema = import_zod12.z.url().refine((value) => new URL(value).origin === FAL_QUEUE_ORIGIN, {
-  message: "not a fal queue URL"
-});
-var submitResponseSchema = import_zod12.z.object({
-  request_id: import_zod12.z.string().min(1),
-  status_url: queueUrlSchema,
-  response_url: queueUrlSchema,
-  cancel_url: queueUrlSchema
+var videoFileSchema = import_zod13.z.object({
+  url: import_zod13.z.url(),
+  content_type: import_zod13.z.string().nullish(),
+  file_size: import_zod13.z.number().nullish()
 });
-var statusResponseSchema = import_zod12.z.object({ status: import_zod12.z.string() });
-var videoFileSchema = import_zod12.z.object({
-  url: import_zod12.z.url(),
-  content_type: import_zod12.z.string().nullish(),
-  file_size: import_zod12.z.number().nullish()
+var toolOutputSchema = import_zod13.z.object({
+  video: import_zod13.z.union([videoFileSchema, import_zod13.z.array(videoFileSchema).min(1)])
 });
-var toolOutputSchema = import_zod12.z.object({
-  video: import_zod12.z.union([videoFileSchema, import_zod12.z.array(videoFileSchema).min(1)])
-});
-var exrOutputSchema = import_zod12.z.object({
+var exrOutputSchema = import_zod13.z.object({
   preview_video: videoFileSchema,
   exr_frames_url: videoFileSchema
 });
-var falWebhookBodySchema = import_zod12.z.object({
-  request_id: import_zod12.z.string().min(1),
-  gateway_request_id: import_zod12.z.string().nullish(),
-  status: import_zod12.z.enum(["OK", "ERROR"]),
-  payload: JsonValueSchema.nullish(),
-  error: import_zod12.z.string().nullish(),
-  payload_error: JsonValueSchema.nullish()
-});
-async function queueFetch(ctx, url, method, body) {
-  const payload = body === void 0 ? void 0 : JSON.stringify(body);
-  try {
-    if (ctx.routing.fal === "cloudflare-passthrough") {
-      return await gatewayFetch(gatewayConfig(ctx), ctx.fetch, url, {
-        method,
-        ...payload !== void 0 && { body: payload }
-      });
-    }
-    const falKey = ctx.keys.fal;
-    if (!falKey) {
-      throw new ModelKitError({
-        code: "auth",
-        message: "Missing API key for fal",
-        provider: "fal",
-        model: ctx.model.id,
-        retryable: false
-      });
-    }
-    return await ctx.fetch(url, {
-      method,
-      headers: {
-        Authorization: `Key ${falKey}`,
-        ...payload !== void 0 && { "Content-Type": "application/json" }
-      },
-      ...payload !== void 0 && { body: payload },
-      ...ctx.signal !== void 0 && { signal: ctx.signal }
-    });
-  } catch (cause) {
-    if (cause instanceof ModelKitError) throw cause;
-    throw classifyThrown("fal", cause, ctx.model.id);
-  }
-}
-async function readJson(ctx, res) {
-  if (!res.ok) throw falError(res.status, await readBody(res), ctx.model.id);
-  return JsonValueSchema.parse(await res.json());
-}
 function providerModelName(ctx) {
-  return import_zod12.z.string().safeParse(ctx.model.providerOptions?.["fal"]?.["model"]).data;
+  return import_zod13.z.string().safeParse(ctx.model.providerOptions?.["fal"]?.["model"]).data;
 }
 function staticInput(ctx) {
   return JsonObjectSchema.safeParse(ctx.model.providerOptions?.["fal"]?.["input"]).data ?? {};
@@ -8752,20 +9253,8 @@ async function submitFalVideoTool(req, ctx, opts) {
     output: plan3.output
   };
 }
-function checkedQueueUrl(ctx, url) {
-  if (!queueUrlSchema.safeParse(url).success) {
-    throw new ModelKitError({
-      code: "provider_rejected",
-      message: "Video-tool submission carries a URL outside fal's queue",
-      provider: "fal",
-      model: ctx.model.id,
-      retryable: false
-    });
-  }
-  return url;
-}
 async function falVideoToolStatus(sub, ctx) {
-  const res = await queueFetch(ctx, checkedQueueUrl(ctx, sub.statusUrl), "GET");
+  const res = await queueFetch(ctx, checkedQueueUrl(ctx, sub.statusUrl, "Video-tool"), "GET");
   const { status } = statusResponseSchema.parse(await readJson(ctx, res));
   if (status === "IN_QUEUE") return "queued";
   if (status === "COMPLETED") return "completed";
@@ -8862,18 +9351,18 @@ async function falVideoToolResult(sub, ctx, webhook) {
     }
     return resultOf(ctx, sub, webhook.payload);
   }
-  const res = await queueFetch(ctx, checkedQueueUrl(ctx, sub.responseUrl), "GET");
+  const res = await queueFetch(ctx, checkedQueueUrl(ctx, sub.responseUrl, "Video-tool"), "GET");
   return resultOf(ctx, sub, await readJson(ctx, res));
 }
 async function cancelFalVideoTool(sub, ctx) {
-  const res = await queueFetch(ctx, checkedQueueUrl(ctx, sub.cancelUrl), "PUT");
+  const res = await queueFetch(ctx, checkedQueueUrl(ctx, sub.cancelUrl, "Video-tool"), "PUT");
   if (res.ok) return true;
   if (res.status === 400) return false;
   throw falError(res.status, await readBody(res), ctx.model.id);
 }
 
 // src/adapters/fal-image.ts
-var import_zod13 = require("zod");
+var import_zod14 = require("zod");
 
 // src/resolve-image-rules.ts
 var WIDE_RATIOS = [
@@ -9459,9 +9948,9 @@ function planFalImage(req, providerModelId, model) {
   if (built.imageSize !== void 0) plan3.imageSize = built.imageSize;
   return plan3;
 }
-var FalFileSchema = import_zod13.z.object({ url: import_zod13.z.string(), content_type: import_zod13.z.string().nullish() });
-var ImagesPayloadSchema = import_zod13.z.object({ images: import_zod13.z.array(FalFileSchema) });
-var ImagePayloadSchema = import_zod13.z.object({ image: FalFileSchema });
+var FalFileSchema = import_zod14.z.object({ url: import_zod14.z.string(), content_type: import_zod14.z.string().nullish() });
+var ImagesPayloadSchema = import_zod14.z.object({ images: import_zod14.z.array(FalFileSchema) });
+var ImagePayloadSchema = import_zod14.z.object({ image: FalFileSchema });
 function decodeDataUri(url) {
   const comma = url.indexOf(",");
   const meta = url.slice(5, comma);
@@ -9520,15 +10009,15 @@ async function generateFalFamilyImage(req, ctx, run) {
 }
 
 // src/adapters/fal-mask.ts
-var import_zod14 = require("zod");
+var import_zod15 = require("zod");
 var SAM3_IMAGE = "fal-ai/sam-3/image";
 var MAX_MASKS = 32;
-function fail3(row, message, code) {
+function fail3(row2, message, code) {
   return new ModelKitError({
     code,
-    message: `${row.label}: ${message}`,
+    message: `${row2.label}: ${message}`,
     provider: "fal",
-    model: row.id,
+    model: row2.id,
     retryable: false
   });
 }
@@ -9538,22 +10027,22 @@ function pointPrompts(points) {
 function boxPrompts(boxes) {
   return boxes.map((b) => ({ x_min: b.xMin, y_min: b.yMin, x_max: b.xMax, y_max: b.yMax }));
 }
-function planFalMask(row, req) {
-  if (row.providerModelId !== SAM3_IMAGE) {
+function planFalMask(row2, req) {
+  if (row2.providerModelId !== SAM3_IMAGE) {
     throw fail3(
-      row,
-      `fal has no mask mapper for "${row.providerModelId}"`,
+      row2,
+      `fal has no mask mapper for "${row2.providerModelId}"`,
       "unsupported_option"
     );
   }
   const refs = req.references ?? [];
   const [image] = refs;
-  if (image === void 0) throw fail3(row, "needs one source image", "missing_input");
+  if (image === void 0) throw fail3(row2, "needs one source image", "missing_input");
   if (refs.length > 1) {
-    throw fail3(row, `takes one source image; got ${refs.length}`, "unsupported_option");
+    throw fail3(row2, `takes one source image; got ${refs.length}`, "unsupported_option");
   }
   const problem = maskProblem(req);
-  if (problem !== void 0) throw fail3(row, problem.message, problem.code);
+  if (problem !== void 0) throw fail3(row2, problem.message, problem.code);
   const input = {
     image_url: refToUrl(image),
     prompt: req.prompt.trim(),
@@ -9570,17 +10059,17 @@ function planFalMask(row, req) {
   }
   return { endpoint: SAM3_IMAGE, input };
 }
-var masksSchema = import_zod14.z.object({
-  masks: import_zod14.z.array(import_zod14.z.object({ url: import_zod14.z.string().min(1), content_type: import_zod14.z.string().nullish() }))
+var masksSchema = import_zod15.z.object({
+  masks: import_zod15.z.array(import_zod15.z.object({ url: import_zod15.z.string().min(1), content_type: import_zod15.z.string().nullish() }))
 });
-function parseFalMasks(row, payload) {
+function parseFalMasks(row2, payload) {
   const parsed = masksSchema.safeParse(payload);
   if (!parsed.success) {
     throw new ModelKitError({
       code: "provider_rejected",
       message: `fal ${SAM3_IMAGE} returned no mask list`,
       provider: "fal",
-      model: row.id,
+      model: row2.id,
       retryable: false
     });
   }
@@ -9613,7 +10102,7 @@ async function generateFalMask(req, ctx, run) {
 }
 
 // src/adapters/fal-audio-plan.ts
-var import_zod15 = require("zod");
+var import_zod16 = require("zod");
 var ELEVENLABS_MUSIC = FAL_AUDIO.elevenLabsMusic;
 var MINIMAX_MUSIC_32 = FAL_AUDIO.minimaxMusic;
 var ELEVENLABS_SFX = FAL_AUDIO.elevenLabsSfx;
@@ -9660,65 +10149,65 @@ var FAL_MEDIA_TYPES = /* @__PURE__ */ new Set([
 function isFalMediaKnown(type, providerModelId) {
   return KNOWN[type]?.has(providerModelId) ?? false;
 }
-function falMediaError(row, message, code) {
+function falMediaError(row2, message, code) {
   return new ModelKitError({
     code,
-    message: `${row.label}: ${message}`,
+    message: `${row2.label}: ${message}`,
     provider: "fal",
-    model: row.id,
+    model: row2.id,
     retryable: false
   });
 }
-function refuseMedia(row, present) {
-  const extra = Object.entries(present).find(([, set]) => set);
-  if (extra) throw falMediaError(row, `does not take ${extra[0]}`, "unsupported_option");
+function refuseMedia(row2, present2) {
+  const extra = Object.entries(present2).find(([, set]) => set);
+  if (extra) throw falMediaError(row2, `does not take ${extra[0]}`, "unsupported_option");
 }
 function setIf(input, key, value) {
   if (value !== void 0) input[key] = value;
 }
-function unmapped(row) {
+function unmapped(row2) {
   return falMediaError(
-    row,
-    `fal has no ${row.type} mapper for "${row.providerModelId}"`,
+    row2,
+    `fal has no ${row2.type} mapper for "${row2.providerModelId}"`,
     "unsupported_option"
   );
 }
-function mediaUrl(row, field, ref) {
-  if (ref === void 0) throw falMediaError(row, `needs ${field}`, "missing_input");
+function mediaUrl(row2, field, ref) {
+  if (ref === void 0) throw falMediaError(row2, `needs ${field}`, "missing_input");
   return refToUrl(ref);
 }
 function trimmed(text2) {
   const value = text2?.trim();
   return value ? value : void 0;
 }
-function requireText(row, text2, what) {
+function requireText(row2, text2, what) {
   const value = trimmed(text2);
-  if (value === void 0) throw falMediaError(row, `needs ${what}`, "missing_input");
+  if (value === void 0) throw falMediaError(row2, `needs ${what}`, "missing_input");
   return value;
 }
-function planMirelo(row, req) {
-  const id = row.providerModelId;
+function planMirelo(row2, req) {
+  const id = row2.providerModelId;
   const input = { num_samples: 1 };
   setIf(input, "duration", req.durationSeconds);
   setIf(input, "negative_prompt", req.negativePrompt);
   setIf(input, "seed", req.seed);
   setIf(input, "upload_audio_format", req.outputFormat);
   if (id === MIRELO_VIDEO) {
-    input["video_url"] = mediaUrl(row, "sourceVideo", req.sourceVideo);
+    input["video_url"] = mediaUrl(row2, "sourceVideo", req.sourceVideo);
     setIf(input, "text_prompt", trimmed(req.prompt));
     return { endpoint: id, input };
   }
   input["prompt"] = req.prompt.trim();
   return { endpoint: id, input };
 }
-function planFalAudio(row, req) {
-  if (row.type !== "audio" && row.type !== "sound-effect") {
-    throw falMediaError(row, `${row.type} rows do not generate audio`, "unsupported_option");
+function planFalAudio(row2, req) {
+  if (row2.type !== "audio" && row2.type !== "sound-effect") {
+    throw falMediaError(row2, `${row2.type} rows do not generate audio`, "unsupported_option");
   }
-  const id = row.providerModelId;
+  const id = row2.providerModelId;
   const problem = falAudioProblem(id, req);
-  if (problem !== void 0) throw falMediaError(row, problem.message, problem.code);
-  if (id === MIRELO_TEXT || id === MIRELO_VIDEO) return planMirelo(row, req);
+  if (problem !== void 0) throw falMediaError(row2, problem.message, problem.code);
+  if (id === MIRELO_TEXT || id === MIRELO_VIDEO) return planMirelo(row2, req);
   const prompt = req.prompt.trim();
   if (id === ELEVENLABS_MUSIC) {
     const input = { prompt };
@@ -9743,12 +10232,12 @@ function planFalAudio(row, req) {
     setIf(input, "output_format", req.outputFormat);
     return { endpoint: id, input };
   }
-  throw unmapped(row);
+  throw unmapped(row2);
 }
-function planFalSpeech(row, req) {
-  const id = row.providerModelId;
-  if (row.type !== "speech") throw unmapped(row);
-  const script = requireText(row, req.text, "text");
+function planFalSpeech(row2, req) {
+  const id = row2.providerModelId;
+  if (row2.type !== "speech") throw unmapped(row2);
+  const script = requireText(row2, req.text, "text");
   if (ELEVENLABS_TTS.has(id)) {
     const input = { text: script };
     setIf(input, "voice", req.voice);
@@ -9768,31 +10257,31 @@ function planFalSpeech(row, req) {
     setIf(input, "language_boost", req.language);
     return { endpoint: id, input };
   }
-  throw unmapped(row);
+  throw unmapped(row2);
 }
-function planFalVoiceChange(row, req) {
-  if (row.type !== "voice-change" || row.providerModelId !== VOICE_CHANGER) throw unmapped(row);
-  const input = { audio_url: mediaUrl(row, "sourceAudio", req.sourceAudio) };
+function planFalVoiceChange(row2, req) {
+  if (row2.type !== "voice-change" || row2.providerModelId !== VOICE_CHANGER) throw unmapped(row2);
+  const input = { audio_url: mediaUrl(row2, "sourceAudio", req.sourceAudio) };
   setIf(input, "voice", req.voice);
   setIf(input, "output_format", req.outputFormat);
   return { endpoint: VOICE_CHANGER, input };
 }
-var fileSchema = import_zod15.z.object({
-  url: import_zod15.z.string().min(1),
-  content_type: import_zod15.z.string().nullish()
+var fileSchema = import_zod16.z.object({
+  url: import_zod16.z.string().min(1),
+  content_type: import_zod16.z.string().nullish()
 });
-var audioOutputSchema = import_zod15.z.object({
-  audio: import_zod15.z.union([fileSchema, import_zod15.z.array(fileSchema).min(1)]),
-  duration: import_zod15.z.number().nullish(),
-  duration_ms: import_zod15.z.number().nullish(),
-  lyrics: import_zod15.z.string().nullish()
+var audioOutputSchema = import_zod16.z.object({
+  audio: import_zod16.z.union([fileSchema, import_zod16.z.array(fileSchema).min(1)]),
+  duration: import_zod16.z.number().nullish(),
+  duration_ms: import_zod16.z.number().nullish(),
+  lyrics: import_zod16.z.string().nullish()
 });
-function noFalOutput(row, what, endpoint) {
+function noFalOutput(row2, what, endpoint) {
   return new ModelKitError({
     code: "provider_rejected",
     message: `fal ${endpoint} returned no ${what}`,
     provider: "fal",
-    model: row.id,
+    model: row2.id,
     retryable: false
   });
 }
@@ -9800,12 +10289,12 @@ function reportedSeconds(seconds3, ms) {
   if (seconds3 != null) return seconds3;
   return ms != null ? ms / 1e3 : void 0;
 }
-function parseFalAudio(row, endpoint, payload) {
+function parseFalAudio(row2, endpoint, payload) {
   const parsed = audioOutputSchema.safeParse(payload);
-  if (!parsed.success) throw noFalOutput(row, "audio", endpoint);
+  if (!parsed.success) throw noFalOutput(row2, "audio", endpoint);
   const { audio, duration, duration_ms: durationMs, lyrics } = parsed.data;
   const file = Array.isArray(audio) ? audio[0] : audio;
-  if (file === void 0) throw noFalOutput(row, "audio", endpoint);
+  if (file === void 0) throw noFalOutput(row2, "audio", endpoint);
   const seconds3 = reportedSeconds(duration, durationMs);
   return {
     url: file.url,
@@ -9816,114 +10305,114 @@ function parseFalAudio(row, endpoint, payload) {
 }
 
 // src/adapters/fal-media-plan.ts
-var import_zod16 = require("zod");
+var import_zod17 = require("zod");
 var MINIMAX_LIPSYNC_RESOLUTIONS = {
   "480p": "480P",
   "768p": "768P",
   "1080p": "1080P",
   "2k": "2K"
 };
-function syncModelName(row) {
-  return import_zod16.z.string().safeParse(row.providerOptions?.["fal"]?.["model"]).data;
+function syncModelName(row2) {
+  return import_zod17.z.string().safeParse(row2.providerOptions?.["fal"]?.["model"]).data;
 }
-function planFalLipsync(row, req) {
-  const id = row.providerModelId;
-  if (row.type !== "lipsync") throw unmapped(row);
-  const audio = mediaUrl(row, "audio", req.audio);
+function planFalLipsync(row2, req) {
+  const id = row2.providerModelId;
+  if (row2.type !== "lipsync") throw unmapped(row2);
+  const audio = mediaUrl(row2, "audio", req.audio);
   if (id === FAL_LIPSYNC.minimax) {
-    refuseMedia(row, { sourceVideo: req.sourceVideo !== void 0 });
+    refuseMedia(row2, { sourceVideo: req.sourceVideo !== void 0 });
     const input = {
-      image_url: mediaUrl(row, "image", req.image),
+      image_url: mediaUrl(row2, "image", req.image),
       audio_url: audio
     };
     if (req.resolution !== void 0) {
       const resolution = MINIMAX_LIPSYNC_RESOLUTIONS[req.resolution];
       if (resolution === void 0) {
-        throw falMediaError(row, `does not render ${req.resolution}`, "unsupported_option");
+        throw falMediaError(row2, `does not render ${req.resolution}`, "unsupported_option");
       }
       input["resolution"] = resolution;
     }
     return { endpoint: id, input };
   }
-  refuseMedia(row, { image: req.image !== void 0 });
-  const video = mediaUrl(row, "sourceVideo", req.sourceVideo);
+  refuseMedia(row2, { image: req.image !== void 0 });
+  const video = mediaUrl(row2, "sourceVideo", req.sourceVideo);
   if (id === FAL_LIPSYNC.veed) {
     return { endpoint: id, input: { video_url: video, audio_url: audio } };
   }
   if (id === FAL_LIPSYNC.syncV2 || id === FAL_LIPSYNC.syncV3) {
     const input = { video_url: video, audio_url: audio, sync_mode: "cut_off" };
-    const model = syncModelName(row);
+    const model = syncModelName(row2);
     if (id === FAL_LIPSYNC.syncV2 && model !== void 0) input["model"] = model;
     return { endpoint: id, input };
   }
-  throw unmapped(row);
+  throw unmapped(row2);
 }
-function planFalDubbing(row, req) {
-  if (row.type !== "dubbing" || row.providerModelId !== FAL_DUBBING) throw unmapped(row);
+function planFalDubbing(row2, req) {
+  if (row2.type !== "dubbing" || row2.providerModelId !== FAL_DUBBING) throw unmapped(row2);
   if (req.sourceVideo !== void 0 && req.sourceAudio !== void 0) {
     throw falMediaError(
-      row,
+      row2,
       "takes sourceVideo or sourceAudio, not both",
       "unsupported_option"
     );
   }
   const target = req.targetLanguage.trim();
-  if (!target) throw falMediaError(row, "needs targetLanguage", "missing_input");
+  if (!target) throw falMediaError(row2, "needs targetLanguage", "missing_input");
   const input = { target_lang: target };
   if (req.sourceVideo !== void 0) input["video_url"] = refToUrl(req.sourceVideo);
-  else input["audio_url"] = mediaUrl(row, "sourceVideo or sourceAudio", req.sourceAudio);
+  else input["audio_url"] = mediaUrl(row2, "sourceVideo or sourceAudio", req.sourceAudio);
   return { endpoint: FAL_DUBBING, input };
 }
-function planFalTranscription(row, req) {
-  if (row.type !== "transcription" || row.providerModelId !== FAL_SCRIBE) throw unmapped(row);
-  const input = { audio_url: mediaUrl(row, "source", req.source) };
+function planFalTranscription(row2, req) {
+  if (row2.type !== "transcription" || row2.providerModelId !== FAL_SCRIBE) throw unmapped(row2);
+  const input = { audio_url: mediaUrl(row2, "source", req.source) };
   setIf(input, "language_code", req.language?.trim() || void 0);
   return { endpoint: FAL_SCRIBE, input };
 }
-var fileSchema2 = import_zod16.z.object({
-  url: import_zod16.z.string().min(1),
-  content_type: import_zod16.z.string().nullish()
+var fileSchema2 = import_zod17.z.object({
+  url: import_zod17.z.string().min(1),
+  content_type: import_zod17.z.string().nullish()
 });
-var videoOutputSchema = import_zod16.z.object({
+var videoOutputSchema = import_zod17.z.object({
   video: fileSchema2,
-  duration: import_zod16.z.number().nullish()
+  duration: import_zod17.z.number().nullish()
 });
-var dubbingOutputSchema = import_zod16.z.object({
+var dubbingOutputSchema = import_zod17.z.object({
   video: fileSchema2.nullish(),
   audio: fileSchema2.nullish()
 });
-var transcriptSchema = import_zod16.z.object({
-  text: import_zod16.z.string(),
-  language_code: import_zod16.z.string().nullish(),
-  words: import_zod16.z.array(
-    import_zod16.z.object({
-      text: import_zod16.z.string(),
-      type: import_zod16.z.string(),
-      start: import_zod16.z.number().nullish(),
-      end: import_zod16.z.number().nullish(),
-      speaker_id: import_zod16.z.string().nullish()
+var transcriptSchema = import_zod17.z.object({
+  text: import_zod17.z.string(),
+  language_code: import_zod17.z.string().nullish(),
+  words: import_zod17.z.array(
+    import_zod17.z.object({
+      text: import_zod17.z.string(),
+      type: import_zod17.z.string(),
+      start: import_zod17.z.number().nullish(),
+      end: import_zod17.z.number().nullish(),
+      speaker_id: import_zod17.z.string().nullish()
     })
   ).nullish()
 });
-function parseFalVideo(row, endpoint, payload) {
+function parseFalVideo(row2, endpoint, payload) {
   const parsed = videoOutputSchema.safeParse(payload);
-  if (!parsed.success) throw noFalOutput(row, "video", endpoint);
+  if (!parsed.success) throw noFalOutput(row2, "video", endpoint);
   const { video, duration } = parsed.data;
   return { url: video.url, ...duration != null && { durationSeconds: duration } };
 }
-function parseFalDubbing(row, kind, payload) {
+function parseFalDubbing(row2, kind, payload) {
   const parsed = dubbingOutputSchema.safeParse(payload);
   const file = parsed.success ? parsed.data[kind] : void 0;
-  if (file == null) throw noFalOutput(row, kind, FAL_DUBBING);
+  if (file == null) throw noFalOutput(row2, kind, FAL_DUBBING);
   return {
     kind,
     url: file.url,
     ...file.content_type != null && { mime: file.content_type }
   };
 }
-function parseFalTranscript(row, endpoint, payload) {
+function parseFalTranscript(row2, endpoint, payload) {
   const parsed = transcriptSchema.safeParse(payload);
-  if (!parsed.success) throw noFalOutput(row, "transcript", endpoint);
+  if (!parsed.success) throw noFalOutput(row2, "transcript", endpoint);
   const words = (parsed.data.words ?? []).map(
     (w) => ({
       text: w.text,
@@ -10086,8 +10575,313 @@ async function transcribeFal(req, ctx, run) {
   };
 }
 
+// src/adapters/fal-model3d.ts
+var import_zod18 = require("zod");
+var fileSchema3 = import_zod18.z.object({
+  url: import_zod18.z.url(),
+  content_type: import_zod18.z.string().nullish(),
+  file_size: import_zod18.z.number().nullish()
+});
+var resultSchema = import_zod18.z.looseObject({
+  model_glb: fileSchema3.nullish(),
+  model_mesh: fileSchema3.nullish(),
+  thumbnail: fileSchema3.nullish(),
+  rendered_image: fileSchema3.nullish()
+});
+function rejected(ctx, message) {
+  return new ModelKitError({
+    code: "provider_rejected",
+    message,
+    provider: "fal",
+    model: ctx.model.id,
+    retryable: false
+  });
+}
+function specOf(ctx) {
+  const spec = model3dConstraints(ctx.model);
+  if (spec === void 0) {
+    throw new ModelKitError({
+      code: "unsupported_option",
+      message: `${ctx.model.id} is not a 3D model`,
+      model: ctx.model.id
+    });
+  }
+  return spec;
+}
+var present = (v) => v !== void 0 && v.length > 0;
+function model3dCall(row2, spec, req) {
+  const prompt = req.prompt?.trim() || void 0;
+  const texture = model3dTexture(spec, req.texture);
+  const textured = spec.texture.length > 0 && texture !== "none";
+  const pbr = spec.pbr && textured && req.pbr === true;
+  const resolution = model3dResolution(spec, req.resolution);
+  const views = spec.views === "none" ? {} : req.views ?? {};
+  const seed = spec.seed && req.seed !== void 0 ? req.seed : void 0;
+  const endpoint = (path) => {
+    if (path === void 0) {
+      throw new ModelKitError({
+        code: "unsupported_option",
+        message: `${row2.id} has no endpoint for this request`,
+        provider: "fal",
+        model: row2.id,
+        retryable: false
+      });
+    }
+    return path;
+  };
+  const slotted = (kind) => MODEL3D_IMAGE_SLOTS[kind].map((slot) => slot === "image" ? req.image : views[slot]).filter(present).slice(0, spec.maxImages);
+  const images = slotted("unordered");
+  switch (spec.family) {
+    case "trellis":
+      return {
+        endpoint: endpoint(spec.endpoints.image),
+        input: {
+          image_url: req.image ?? "",
+          resolution: Number(resolution),
+          ...seed !== void 0 && { seed }
+        }
+      };
+    case "sam":
+      return {
+        endpoint: endpoint(spec.endpoints.image),
+        input: {
+          image_url: req.image ?? "",
+          ...prompt !== void 0 && { prompt },
+          export_textured_glb: true,
+          ...seed !== void 0 && { seed }
+        }
+      };
+    case "hunyuan": {
+      const opts = { generate_type: textured ? "Normal" : "Geometry", enable_pbr: pbr };
+      if (!present(req.image)) {
+        return {
+          endpoint: endpoint(spec.endpoints.text),
+          input: { prompt: prompt ?? "", ...opts }
+        };
+      }
+      return {
+        endpoint: endpoint(spec.endpoints.image),
+        input: {
+          input_image_url: req.image,
+          ...present(views.back) && { back_image_url: views.back },
+          ...present(views.left) && { left_image_url: views.left },
+          ...present(views.right) && { right_image_url: views.right },
+          ...opts
+        }
+      };
+    }
+    case "tripo": {
+      const opts = {
+        texture: textured,
+        pbr,
+        ...textured && {
+          texture_quality: texture === "detailed" ? "detailed" : "standard"
+        },
+        ...seed !== void 0 && { model_seed: seed }
+      };
+      if (!present(req.image)) {
+        return {
+          endpoint: endpoint(spec.endpoints.text),
+          input: { prompt: prompt ?? "", ...opts }
+        };
+      }
+      const ordered = slotted("ordered");
+      return ordered.length > 1 ? {
+        endpoint: endpoint(spec.endpoints.multiImage),
+        input: { image_urls: ordered, ...opts }
+      } : {
+        endpoint: endpoint(spec.endpoints.image),
+        input: { image_url: req.image, ...opts }
+      };
+    }
+    case "rodin": {
+      const opts = {
+        geometry_file_format: "glb",
+        material: "PBR",
+        ...seed !== void 0 && { seed }
+      };
+      if (images.length === 0) {
+        return {
+          endpoint: endpoint(spec.endpoints.text),
+          input: { prompt: prompt ?? "", ...opts }
+        };
+      }
+      return {
+        endpoint: endpoint(spec.endpoints.image),
+        input: { image_urls: images, ...prompt !== void 0 && { prompt }, ...opts }
+      };
+    }
+    case "meshy": {
+      const texturePrompt = req.texturePrompt?.trim() || void 0;
+      const opts = {
+        enable_pbr: pbr,
+        ...spec.textureRef && texturePrompt !== void 0 && { texture_prompt: texturePrompt },
+        ...spec.textureRef && present(req.textureImage) && { texture_image_url: req.textureImage }
+      };
+      if (images.length === 0) {
+        return {
+          endpoint: endpoint(spec.endpoints.text),
+          input: {
+            prompt: prompt ?? "",
+            mode: textured ? "full" : "preview",
+            ...opts,
+            ...seed !== void 0 && { seed }
+          }
+        };
+      }
+      return images.length > 1 ? {
+        endpoint: endpoint(spec.endpoints.multiImage),
+        input: { image_urls: images, should_texture: textured, ...opts }
+      } : {
+        endpoint: endpoint(spec.endpoints.image),
+        input: { image_url: req.image ?? "", should_texture: textured, ...opts }
+      };
+    }
+    case "hi3d": {
+      const opts = {
+        resolution: resolution === "master" ? "2048master" : "2048quality",
+        enable_texture: textured,
+        enable_pbr: pbr,
+        export_format: "glb"
+      };
+      const anyView = present(views.back) || present(views.left) || present(views.right);
+      return anyView ? {
+        endpoint: endpoint(spec.endpoints.multiImage),
+        input: {
+          front_image_url: req.image ?? "",
+          ...present(views.back) && { back_image_url: views.back },
+          ...present(views.left) && { left_image_url: views.left },
+          ...present(views.right) && { right_image_url: views.right },
+          ...opts
+        }
+      } : {
+        endpoint: endpoint(spec.endpoints.image),
+        input: { image_url: req.image ?? "", ...opts }
+      };
+    }
+  }
+}
+async function submitFalModel3d(req, ctx, opts) {
+  const spec = specOf(ctx);
+  const views = req.views ?? {};
+  const refusal2 = model3dInputRefusal(spec, {
+    prompt: present(req.prompt?.trim()),
+    image: present(req.image),
+    back: present(views.back),
+    left: present(views.left),
+    right: present(views.right),
+    top: present(views.top)
+  });
+  if (refusal2 !== null) {
+    throw new ModelKitError({
+      code: "unsupported_option",
+      message: `${ctx.model.id}: ${refusal2}`,
+      provider: "fal",
+      model: ctx.model.id,
+      retryable: false
+    });
+  }
+  if (spec.seed && req.seed !== void 0 && !model3dSeedFits(spec, req.seed)) {
+    throw new ModelKitError({
+      code: "unsupported_option",
+      message: `${ctx.model.id} takes a seed from 0 to ${spec.seedMax ?? Number.MAX_SAFE_INTEGER}`,
+      provider: "fal",
+      model: ctx.model.id,
+      retryable: false
+    });
+  }
+  const call = model3dCall(ctx.model, spec, req);
+  const sku = model3dPricingSku(
+    ctx.model,
+    {
+      ...req.texture !== void 0 && { texture: req.texture },
+      ...req.pbr !== void 0 && { pbr: req.pbr },
+      ...req.resolution !== void 0 && { resolution: req.resolution }
+    },
+    {
+      image: present(req.image),
+      views: spec.views !== "none" && (present(views.back) || present(views.left) || present(views.right) || spec.views === "unordered" && present(views.top))
+    }
+  );
+  const target = new URL(`${FAL_QUEUE_ORIGIN}/${call.endpoint}`);
+  if (opts.webhookUrl !== void 0) target.searchParams.set("fal_webhook", opts.webhookUrl);
+  const res = await queueFetch(ctx, target.toString(), "POST", call.input);
+  const parsed = submitResponseSchema.safeParse(await readJson(ctx, res));
+  if (!parsed.success) throw rejected(ctx, `fal ${call.endpoint} submit returned no queue URLs`);
+  return {
+    model: ctx.model.id,
+    provider: "fal",
+    endpoint: call.endpoint,
+    sku,
+    requestId: parsed.data.request_id,
+    statusUrl: parsed.data.status_url,
+    responseUrl: parsed.data.response_url,
+    cancelUrl: parsed.data.cancel_url
+  };
+}
+async function falModel3dStatus(sub, ctx) {
+  const res = await queueFetch(ctx, checkedQueueUrl(ctx, sub.statusUrl, "3D"), "GET");
+  const { status } = statusResponseSchema.parse(await readJson(ctx, res));
+  if (status === "IN_QUEUE") return "queued";
+  if (status === "COMPLETED") return "completed";
+  return "running";
+}
+function httpsUrl(ctx, sub, url, what) {
+  if (new URL(url).protocol === "https:") return url;
+  throw rejected(ctx, `fal ${sub.endpoint} returned a ${what} URL that is not https`);
+}
+function resultOf2(ctx, sub, payload) {
+  const parsed = resultSchema.safeParse(payload);
+  const glb = parsed.success ? parsed.data.model_glb ?? parsed.data.model_mesh : void 0;
+  if (!glb) throw rejected(ctx, `fal ${sub.endpoint} returned no GLB`);
+  const still = parsed.success ? parsed.data.thumbnail ?? parsed.data.rendered_image : void 0;
+  const glbUrl = httpsUrl(ctx, sub, glb.url, "GLB");
+  const stillUrl = still ? httpsUrl(ctx, sub, still.url, "thumbnail") : void 0;
+  return {
+    glb: {
+      url: glbUrl,
+      ...glb.content_type != null && { mime: glb.content_type },
+      ...glb.file_size != null && { bytes: glb.file_size }
+    },
+    ...stillUrl !== void 0 && { thumbnail: { url: stillUrl } },
+    sku: sub.sku,
+    usage: {
+      model: ctx.model.id,
+      provider: "fal",
+      // The sink has no 3D modality; IMAGE is the nearest. The unit is what bills it.
+      modality: "IMAGE",
+      unit: "requests",
+      quantity: 1
+    },
+    raw: payload
+  };
+}
+async function falModel3dResult(sub, ctx, webhook) {
+  if (webhook !== void 0) {
+    if (webhook.request_id !== sub.requestId) {
+      throw rejected(ctx, "fal webhook is for a different request");
+    }
+    if (webhook.status === "ERROR") {
+      throw falError(
+        void 0,
+        webhook.payload ?? webhook.error ?? "fal job failed",
+        ctx.model.id
+      );
+    }
+    return resultOf2(ctx, sub, webhook.payload);
+  }
+  const res = await queueFetch(ctx, checkedQueueUrl(ctx, sub.responseUrl, "3D"), "GET");
+  return resultOf2(ctx, sub, await readJson(ctx, res));
+}
+async function cancelFalModel3d(sub, ctx) {
+  const res = await queueFetch(ctx, checkedQueueUrl(ctx, sub.cancelUrl, "3D"), "PUT");
+  if (res.ok) return true;
+  if (res.status === 400) return false;
+  throw falError(res.status, await readBody(res), ctx.model.id);
+}
+
 // src/adapters/fal-video-plan.ts
-var import_zod17 = require("zod");
+var import_zod19 = require("zod");
 function refusal(ctx, message, code = "unsupported_option") {
   return new ModelKitError({
     code,
@@ -10124,9 +10918,9 @@ function wholeSeconds(req, ctx) {
   if (!Number.isInteger(duration)) throw refusal(ctx, "takes whole-second durations");
   return duration;
 }
-var lengthSchema = import_zod17.z.object({
-  duration: import_zod17.z.number().positive().optional(),
-  video: import_zod17.z.object({ duration: import_zod17.z.number().positive().nullish() }).optional()
+var lengthSchema = import_zod19.z.object({
+  duration: import_zod19.z.number().positive().optional(),
+  video: import_zod19.z.object({ duration: import_zod19.z.number().positive().nullish() }).optional()
 });
 function reportedSeconds2(payload) {
   const parsed = lengthSchema.safeParse(payload);
@@ -10639,7 +11433,7 @@ var MUSE_T2I_ENDPOINT = "meta/muse-image/text-to-image";
 var MUSE_EDIT_ENDPOINT = "meta/muse-image/edit";
 var KLING_O1_ENDPOINT = "fal-ai/kling-video/o1/video-to-video/reference";
 var PASSTHROUGH_MAX_WAIT_MS = 18e4;
-var falSubscribePayloadSchema = import_zod18.z.object({ data: JsonValueSchema });
+var falSubscribePayloadSchema = import_zod20.z.object({ data: JsonValueSchema });
 function defaultCreateFalClient(opts) {
   if (opts.maxRetries !== void 0)
     return createFalHttpClient({
@@ -10717,7 +11511,11 @@ function createFalAdapter(deps = defaultDeps) {
     submitVideoTool: submitFalVideoTool,
     videoToolStatus: falVideoToolStatus,
     videoToolResult: falVideoToolResult,
-    cancelVideoTool: cancelFalVideoTool
+    cancelVideoTool: cancelFalVideoTool,
+    submitModel3d: submitFalModel3d,
+    model3dStatus: falModel3dStatus,
+    model3dResult: falModel3dResult,
+    cancelModel3d: cancelFalModel3d
   };
 }
 function falRun(ctx, deps) {
@@ -10865,11 +11663,11 @@ async function decodeImage(ctx, url, contentType) {
   const mime = res.headers.get("content-type") ?? contentType ?? "image/png";
   return { bytes: new Uint8Array(await res.arrayBuffer()), mime };
 }
-var museImageResultSchema = import_zod18.z.object({
-  images: import_zod18.z.array(
-    import_zod18.z.object({
-      url: import_zod18.z.string().optional(),
-      content_type: import_zod18.z.string().nullable().optional()
+var museImageResultSchema = import_zod20.z.object({
+  images: import_zod20.z.array(
+    import_zod20.z.object({
+      url: import_zod20.z.string().optional(),
+      content_type: import_zod20.z.string().nullable().optional()
     })
   ).optional()
 });
@@ -11069,8 +11867,8 @@ function klingO1Input(req) {
   if (refs.length > 0) input.image_urls = refs;
   return input;
 }
-var falVideoResultSchema = import_zod18.z.object({
-  video: import_zod18.z.object({ url: import_zod18.z.string().optional() }).optional()
+var falVideoResultSchema = import_zod20.z.object({
+  video: import_zod20.z.object({ url: import_zod20.z.string().optional() }).optional()
 });
 function extractVideoUrl(result, endpoint, model) {
   const parsed = falVideoResultSchema.safeParse(result);
@@ -11162,11 +11960,11 @@ function planUsage(ctx, plan3) {
 }
 
 // src/adapters/google-genai.ts
-var import_zod20 = require("zod");
+var import_zod22 = require("zod");
 var import_genai = require("@google/genai");
 
 // src/adapters/google-files.ts
-var import_zod19 = require("zod");
+var import_zod21 = require("zod");
 var GOOGLE_FILES_BASE = "https://generativelanguage.googleapis.com";
 var GOOGLE_FILES_POLL_INTERVAL_MS = 2e3;
 var GOOGLE_FILES_POLL_TIMEOUT_MS = 5 * 60 * 1e3;
@@ -11176,17 +11974,17 @@ var GENERIC_MEDIA_TYPES = /* @__PURE__ */ new Set([
   "binary/octet-stream",
   "application/binary"
 ]);
-var uploadedFileSchema = import_zod19.z.object({
-  file: import_zod19.z.object({
-    uri: import_zod19.z.string().optional(),
-    name: import_zod19.z.string().optional(),
-    state: import_zod19.z.string().optional(),
-    mimeType: import_zod19.z.string().optional()
+var uploadedFileSchema = import_zod21.z.object({
+  file: import_zod21.z.object({
+    uri: import_zod21.z.string().optional(),
+    name: import_zod21.z.string().optional(),
+    state: import_zod21.z.string().optional(),
+    mimeType: import_zod21.z.string().optional()
   }).optional()
 });
-var fileStateSchema = import_zod19.z.object({
-  state: import_zod19.z.string().optional(),
-  error: import_zod19.z.object({ message: import_zod19.z.string().optional() }).optional()
+var fileStateSchema = import_zod21.z.object({
+  state: import_zod21.z.string().optional(),
+  error: import_zod21.z.object({ message: import_zod21.z.string().optional() }).optional()
 });
 function resolveMime(declared, fallback) {
   const clean = declared?.split(";")[0]?.trim().toLowerCase();
@@ -11407,7 +12205,7 @@ var OMNI_POLL_INTERVAL_MS = 1e4;
 var RESULT_TIMEOUT_MS3 = 15 * 60 * 1e3;
 var OMNI_INLINE_LIMIT_BYTES = 4 * 1024 * 1024;
 var MEDIA_PART_INLINE_LIMIT_BYTES = 20 * 1024 * 1024;
-var errorTextSchema = import_zod20.z.string();
+var errorTextSchema = import_zod22.z.string();
 function isGoogleGenaiVideoKnown(providerModelId) {
   return providerModelId.startsWith("veo-") || providerModelId.startsWith("gemini-omni");
 }
@@ -12071,15 +12869,15 @@ async function prepareGoogleMediaPart(ref, mediaType, ctx) {
 // src/adapters/google-image.ts
 var import_google2 = require("@ai-sdk/google");
 var import_ai2 = require("ai");
-var import_zod21 = require("zod");
+var import_zod23 = require("zod");
 var GEMINI_IMAGE_TIMEOUT_MS = 6e5;
 var defaultGoogleImageDeps = {
   createGoogleClient: (opts) => (0, import_google2.createGoogleGenerativeAI)(opts),
   runTextGeneration: (opts) => (0, import_ai2.generateText)(opts)
 };
-var causeChainNodeSchema = import_zod21.z.object({
-  message: import_zod21.z.string().optional(),
-  cause: import_zod21.z.unknown().optional()
+var causeChainNodeSchema = import_zod23.z.object({
+  message: import_zod23.z.string().optional(),
+  cause: import_zod23.z.unknown().optional()
 });
 function extractBlockReason(cause) {
   let current = cause;
@@ -12199,7 +12997,7 @@ function createGoogleImageAdapter(deps = defaultGoogleImageDeps) {
 var googleImageAdapter = createGoogleImageAdapter();
 
 // src/adapters/higgsfield.ts
-var import_zod22 = require("zod");
+var import_zod24 = require("zod");
 
 // src/adapters/higgsfield-motions.ts
 var MOTION_MAP = {
@@ -12418,14 +13216,14 @@ function klingEndpointFields(providerModelId) {
   const path = (providerModelId.startsWith("/") ? providerModelId.slice(1) : providerModelId).toLowerCase();
   return KLING_ENDPOINT_FIELDS.get(path) ?? UNLISTED_KLING_FIELDS;
 }
-var klingCreateSchema = import_zod22.z.object({ status_url: import_zod22.z.string() });
-var klingStatusSchema = import_zod22.z.object({
-  status: import_zod22.z.string().optional(),
-  video: import_zod22.z.object({ url: import_zod22.z.string().optional() }).optional(),
+var klingCreateSchema = import_zod24.z.object({ status_url: import_zod24.z.string() });
+var klingStatusSchema = import_zod24.z.object({
+  status: import_zod24.z.string().optional(),
+  video: import_zod24.z.object({ url: import_zod24.z.string().optional() }).optional(),
   error: JsonValueSchema.optional()
 });
-var errorMessageSchema = import_zod22.z.object({ message: import_zod22.z.string().optional() });
-var textValueSchema = import_zod22.z.string();
+var errorMessageSchema = import_zod24.z.object({ message: import_zod24.z.string().optional() });
+var textValueSchema = import_zod24.z.string();
 function klingErrorDetail(error) {
   if (error === void 0) return "unknown_error";
   const asText = textValueSchema.safeParse(error);
@@ -12581,8 +13379,8 @@ async function generateKlingVideo(req, ctx) {
     }
   };
 }
-var dopMotionOptionsSchema = import_zod22.z.object({
-  modelkit: import_zod22.z.object({ motion: import_zod22.z.string().optional() }).optional()
+var dopMotionOptionsSchema = import_zod24.z.object({
+  modelkit: import_zod24.z.object({ motion: import_zod24.z.string().optional() }).optional()
 });
 function dopMotionId(ctx) {
   const parsed = dopMotionOptionsSchema.safeParse(ctx.model.providerOptions);
@@ -12598,7 +13396,7 @@ function dopMotionId(ctx) {
     });
   return id;
 }
-var jsonRecordSchema = import_zod22.z.record(import_zod22.z.string(), JsonValueSchema);
+var jsonRecordSchema = import_zod24.z.record(import_zod24.z.string(), JsonValueSchema);
 var DOP_URL_KEYS = ["url", "video_url", "output_url", "result_url", "download_url"];
 var DOP_NESTED_KEYS = ["video", "result", "results"];
 function dopUrl(body) {
@@ -12626,8 +13424,8 @@ function dopUrl(body) {
   }
   return void 0;
 }
-var dopCreateSchema = import_zod22.z.object({ id: import_zod22.z.string() });
-var dopStatusSchema = import_zod22.z.object({ status: import_zod22.z.string().optional() });
+var dopCreateSchema = import_zod24.z.object({ id: import_zod24.z.string() });
+var dopStatusSchema = import_zod24.z.object({ status: import_zod24.z.string().optional() });
 async function generateDopVideo(req, ctx) {
   const firstFrame = req.firstFrame ? refToUrl(req.firstFrame) : void 0;
   if (!firstFrame) {
@@ -12755,7 +13553,7 @@ var higgsfieldAdapter = {
 
 // src/adapters/openai-image.ts
 var import_openai2 = __toESM(require("openai"), 1);
-var import_zod23 = require("zod");
+var import_zod25 = require("zod");
 var MAX_EDIT_REFERENCES = 16;
 function aspectRatioToSize(ratio, tier) {
   const TIER_LONG_EDGE = {
@@ -12838,9 +13636,9 @@ function toProviderError2(cause, ctx) {
     ctx.model.id
   );
 }
-var openaiUsageSchema = import_zod23.z.object({
-  input_tokens: import_zod23.z.number().optional(),
-  output_tokens: import_zod23.z.number().optional()
+var openaiUsageSchema = import_zod25.z.object({
+  input_tokens: import_zod25.z.number().optional(),
+  output_tokens: import_zod25.z.number().optional()
 });
 var openaiImageAdapter = {
   id: "openai-image",
@@ -13252,13 +14050,13 @@ var prodiaAdapter = {
 var import_replicate = __toESM(require("replicate"), 1);
 
 // src/adapters/replicate-http.ts
-var import_zod24 = require("zod");
-var predictionSchema = import_zod24.z.object({
-  id: import_zod24.z.string(),
-  status: import_zod24.z.string(),
+var import_zod26 = require("zod");
+var predictionSchema = import_zod26.z.object({
+  id: import_zod26.z.string(),
+  status: import_zod26.z.string(),
   output: JsonValueSchema.optional(),
   error: JsonValueSchema.optional(),
-  metrics: import_zod24.z.object({ predict_time: import_zod24.z.number().optional() }).optional()
+  metrics: import_zod26.z.object({ predict_time: import_zod26.z.number().optional() }).optional()
 });
 function createReplicateHttpClient(opts) {
   async function request(path, body, signal) {
@@ -13309,7 +14107,7 @@ function createReplicateHttpClient(opts) {
 }
 
 // src/adapters/replicate.ts
-var import_zod25 = require("zod");
+var import_zod27 = require("zod");
 var POLL_INTERVAL_MS = 1e3;
 var POLL_TIMEOUT_MS = 15 * 6e4;
 var defaultReplicateDeps = {
@@ -13349,8 +14147,8 @@ function route(providerModelId) {
   if (!providerModelId.includes("/")) return { version: providerModelId };
   return { model: providerModelId };
 }
-var replicateResponseStatusSchema = import_zod25.z.object({
-  response: import_zod25.z.object({ status: import_zod25.z.number() }).partial()
+var replicateResponseStatusSchema = import_zod27.z.object({
+  response: import_zod27.z.object({ status: import_zod27.z.number() }).partial()
 });
 function replicateError(cause, ctx) {
   if (isModelKitError(cause)) return cause;
@@ -13377,7 +14175,7 @@ function isUrlFn(value) {
 function extractOutputUrl(output) {
   const root = Array.isArray(output) ? output[0] : output;
   if (root === void 0) throw noOutput();
-  const asString = import_zod25.z.string().safeParse(root);
+  const asString = import_zod27.z.string().safeParse(root);
   if (asString.success && asString.data) return asString.data;
   if (root instanceof URL) return root.href;
   if (isObjectOutput(root)) {
@@ -13386,15 +14184,15 @@ function extractOutputUrl(output) {
       if (urlValue !== void 0 && isUrlFn(urlValue)) {
         const called = urlValue();
         if (called instanceof URL) return called.href;
-        const calledString = import_zod25.z.string().safeParse(called);
+        const calledString = import_zod27.z.string().safeParse(called);
         if (calledString.success && calledString.data) return calledString.data;
       } else {
-        const direct = import_zod25.z.string().safeParse(urlValue);
+        const direct = import_zod27.z.string().safeParse(urlValue);
         if (direct.success && direct.data) return direct.data;
       }
     }
     if ("default" in root) {
-      const fallback = import_zod25.z.string().safeParse(root.default);
+      const fallback = import_zod27.z.string().safeParse(root.default);
       if (fallback.success && fallback.data) return fallback.data;
     }
   }
@@ -13455,7 +14253,7 @@ async function runPrediction(ctx, input, deps) {
     }
     return void 0;
   }, pollOpts);
-  const predictTime = import_zod25.z.number().safeParse(done.metrics?.predict_time);
+  const predictTime = import_zod27.z.number().safeParse(done.metrics?.predict_time);
   if (done.output === void 0) throw noOutput();
   return {
     url: extractOutputUrl(done.output),
@@ -13826,7 +14624,7 @@ async function generateReplicateVideo(req, ctx, deps) {
       throw replicateError(cause, ctx);
     }
     if (current.status === "succeeded") {
-      const predictTime = import_zod25.z.number().safeParse(current.metrics?.predict_time);
+      const predictTime = import_zod27.z.number().safeParse(current.metrics?.predict_time);
       if (current.output === void 0) throw noOutput();
       return {
         url: extractOutputUrl(current.output),
@@ -13968,7 +14766,7 @@ async function generateReplicateAudio(req, ctx, deps) {
 // src/adapters/xai-video.ts
 var import_ai3 = require("ai");
 var import_xai2 = require("@ai-sdk/xai");
-var import_zod26 = require("zod");
+var import_zod28 = require("zod");
 var POLL_INTERVAL_MS2 = 1e4;
 var POLL_TIMEOUT_MS2 = 15 * 6e4;
 var defaultXaiDeps = {
@@ -13981,8 +14779,8 @@ function createXaiVideoAdapter(deps = defaultXaiDeps) {
   };
 }
 var xaiVideoAdapter = createXaiVideoAdapter();
-var xaiResponseStatusSchema = import_zod26.z.object({
-  response: import_zod26.z.object({ status: import_zod26.z.number() }).partial()
+var xaiResponseStatusSchema = import_zod28.z.object({
+  response: import_zod28.z.object({ status: import_zod28.z.number() }).partial()
 });
 function xaiError(cause, ctx) {
   const info = describeThrown(cause);
@@ -13990,12 +14788,12 @@ function xaiError(cause, ctx) {
   const status = info.status ?? (nested.success ? nested.data.response?.status : void 0);
   return classifyThrown("xai-video", cause, ctx.model.id, { status, body: info.body });
 }
-var xaiMetaSchema = import_zod26.z.object({
+var xaiMetaSchema = import_zod28.z.object({
   videoUrl: JsonValueSchema.optional(),
   costInUsdTicks: JsonValueSchema.optional(),
   duration: JsonValueSchema.optional()
 });
-var xaiProviderMetadataSchema = import_zod26.z.object({ xai: xaiMetaSchema });
+var xaiProviderMetadataSchema = import_zod28.z.object({ xai: xaiMetaSchema });
 function metaOf(result) {
   const parsed = xaiProviderMetadataSchema.partial().safeParse(result.providerMetadata);
   if (!parsed.success) return {};
@@ -14111,7 +14909,7 @@ async function mapResult(ctx, req, result) {
     };
   }
   const meta = metaOf(result);
-  const videoUrl = import_zod26.z.string().safeParse(meta.videoUrl);
+  const videoUrl = import_zod28.z.string().safeParse(meta.videoUrl);
   if (videoUrl.success && videoUrl.data) {
     const res = await ctx.fetch(videoUrl.data);
     if (!res.ok) {
@@ -14134,7 +14932,7 @@ async function mapResult(ctx, req, result) {
   });
 }
 function usage2(ctx, req, meta) {
-  const costTicks = import_zod26.z.number().safeParse(meta.costInUsdTicks);
+  const costTicks = import_zod28.z.number().safeParse(meta.costInUsdTicks);
   const cost = costTicks.success ? costTicks.data / 1e10 : void 0;
   const event = {
     model: ctx.model.id,
@@ -14186,10 +14984,10 @@ var DEFAULT_ADAPTERS = {
 };
 
 // src/catalog/data-only.ts
-function hasValidInputSpec(row) {
-  const raw = row.providerOptions?.["modelkit"]?.["inputSpec"];
+function hasValidInputSpec(row2) {
+  const raw = row2.providerOptions?.["modelkit"]?.["inputSpec"];
   if (raw === void 0) return false;
-  return validateInputSpec(raw, row).ok;
+  return validateInputSpec(raw, row2).ok;
 }
 function assertNever(value) {
   throw new Error(`Unhandled adapter: ${String(value)}`);
@@ -14207,6 +15005,7 @@ function adapterServesType(adapter, type) {
   if (type === "lipsync") return adapter.lipsync !== void 0;
   if (type === "transcription") return adapter.transcribe !== void 0;
   if (type === "video-tool") return adapter.submitVideoTool !== void 0;
+  if (type === "model3d") return adapter.submitModel3d !== void 0;
   return adapter.languageModel !== void 0;
 }
 var FAL_NODE_TYPES = /* @__PURE__ */ new Set([
@@ -14218,18 +15017,18 @@ var FAL_NODE_TYPES = /* @__PURE__ */ new Set([
   "transcription",
   "mask"
 ]);
-function dataOnlyCapable(row) {
-  const adapter = DEFAULT_ADAPTERS[row.adapter];
-  if (!adapterServesType(adapter, row.type)) {
-    return { ok: false, reason: `${row.adapter} cannot serve ${row.type} rows` };
+function dataOnlyCapable(row2) {
+  const adapter = DEFAULT_ADAPTERS[row2.adapter];
+  if (!adapterServesType(adapter, row2.type)) {
+    return { ok: false, reason: `${row2.adapter} cannot serve ${row2.type} rows` };
   }
-  if (FAL_NODE_TYPES.has(row.type) && row.adapter !== "fal") {
-    return { ok: false, reason: `only fal serves ${row.type} rows` };
+  if (FAL_NODE_TYPES.has(row2.type) && row2.adapter !== "fal") {
+    return { ok: false, reason: `only fal serves ${row2.type} rows` };
   }
-  switch (row.adapter) {
+  switch (row2.adapter) {
     case "ai-sdk-text": {
       try {
-        textProviderOf(row);
+        textProviderOf(row2);
         return { ok: true };
       } catch {
         return {
@@ -14247,14 +15046,14 @@ function dataOnlyCapable(row) {
       return { ok: true };
     }
     case "google-genai": {
-      if (row.type === "video") {
-        return isGoogleGenaiVideoKnown(row.providerModelId) ? { ok: true } : { ok: false, reason: "google-genai video needs a veo- or gemini-omni id" };
+      if (row2.type === "video") {
+        return isGoogleGenaiVideoKnown(row2.providerModelId) ? { ok: true } : { ok: false, reason: "google-genai video needs a veo- or gemini-omni id" };
       }
-      return isGoogleGenaiAudioKnown(row.providerModelId) ? { ok: true } : { ok: false, reason: "google-genai audio needs a lyria- id" };
+      return isGoogleGenaiAudioKnown(row2.providerModelId) ? { ok: true } : { ok: false, reason: "google-genai audio needs a lyria- id" };
     }
     case "replicate": {
-      if (row.type === "video") {
-        if (isReplicateVideoKnown(row.providerModelId) || hasValidInputSpec(row)) {
+      if (row2.type === "video") {
+        if (isReplicateVideoKnown(row2.providerModelId) || hasValidInputSpec(row2)) {
           return { ok: true };
         }
         return {
@@ -14262,8 +15061,8 @@ function dataOnlyCapable(row) {
           reason: "replicate video needs a known kind or a valid inputSpec"
         };
       }
-      if (row.type === "audio") {
-        if (isReplicateAudioKnown(row.providerModelId) || hasValidInputSpec(row)) {
+      if (row2.type === "audio") {
+        if (isReplicateAudioKnown(row2.providerModelId) || hasValidInputSpec(row2)) {
           return { ok: true };
         }
         return {
@@ -14274,31 +15073,31 @@ function dataOnlyCapable(row) {
       return { ok: true };
     }
     case "fal": {
-      if (row.type === "video") {
-        return isFalVideoKnown(row.providerModelId) ? { ok: true } : { ok: false, reason: "fal video needs an id from a fal video family" };
+      if (row2.type === "video") {
+        return isFalVideoKnown(row2.providerModelId) ? { ok: true } : { ok: false, reason: "fal video needs an id from a fal video family" };
       }
-      if (row.type === "mask") {
-        return row.providerModelId === SAM3_IMAGE ? { ok: true } : { ok: false, reason: `fal maps mask rows only to ${SAM3_IMAGE}` };
+      if (row2.type === "mask") {
+        return row2.providerModelId === SAM3_IMAGE ? { ok: true } : { ok: false, reason: `fal maps mask rows only to ${SAM3_IMAGE}` };
       }
-      if (row.type === "video-tool" && row.constraints.tool?.kind === "subtitles") {
-        return row.providerModelId === VEED_SUBTITLES2 ? { ok: true } : { ok: false, reason: `fal maps subtitles only to ${VEED_SUBTITLES2}` };
+      if (row2.type === "video-tool" && row2.constraints.tool?.kind === "subtitles") {
+        return row2.providerModelId === VEED_SUBTITLES2 ? { ok: true } : { ok: false, reason: `fal maps subtitles only to ${VEED_SUBTITLES2}` };
       }
-      if (FAL_MEDIA_TYPES.has(row.type)) {
-        return isFalMediaKnown(row.type, row.providerModelId) ? { ok: true } : { ok: false, reason: `fal has no ${row.type} mapping for this id` };
+      if (FAL_MEDIA_TYPES.has(row2.type)) {
+        return isFalMediaKnown(row2.type, row2.providerModelId) ? { ok: true } : { ok: false, reason: `fal has no ${row2.type} mapping for this id` };
       }
       return { ok: true };
     }
     case "prodia": {
-      return isProdiaCapable(row.providerModelId) ? { ok: true } : { ok: false, reason: "prodia has no job mapping for this id" };
+      return isProdiaCapable(row2.providerModelId) ? { ok: true } : { ok: false, reason: "prodia has no job mapping for this id" };
     }
     case "higgsfield": {
-      return isHiggsfieldCapable(row.providerModelId) ? { ok: true } : {
+      return isHiggsfieldCapable(row2.providerModelId) ? { ok: true } : {
         ok: false,
         reason: "higgsfield providerModelId must be a platform path, not a URL"
       };
     }
     default: {
-      return assertNever(row.adapter);
+      return assertNever(row2.adapter);
     }
   }
 }
@@ -14316,22 +15115,22 @@ var liveState = store[KEY] ??= {
 var liveCatalog = liveState.catalog;
 
 // src/catalog/load.ts
-var import_zod27 = require("zod");
+var import_zod29 = 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_zod27.z.object({
-  rows: import_zod27.z.array(JsonValueSchema),
-  revision: import_zod27.z.string().optional()
+var EnvelopeSchema = import_zod29.z.object({
+  rows: import_zod29.z.array(JsonValueSchema),
+  revision: import_zod29.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_zod27.z.object({ id: import_zod27.z.string().min(1) }).loose().safeParse(raw);
+  const parsed = import_zod29.z.object({ id: import_zod29.z.string().min(1) }).loose().safeParse(raw);
   if (!parsed.success) return "?";
   return parsed.data.id;
 }
@@ -14347,22 +15146,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);
@@ -14376,10 +15175,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());
@@ -15079,16 +15878,16 @@ function resolveVideoOptions(model, request, onUnsupported = "error") {
 }
 function checkVideoRequired(model, req) {
   const c = model.constraints;
-  const present = (input) => input === "references" ? compact(req.referenceImages).length + compact(req.referenceVideos).length + compact(req.referenceAudios).length > 0 : input !== "sourceAudio" && req[input] !== void 0;
+  const present2 = (input) => input === "references" ? compact(req.referenceImages).length + compact(req.referenceVideos).length + compact(req.referenceAudios).length > 0 : input !== "sourceAudio" && req[input] !== void 0;
   for (const input of c.requires ?? []) {
-    if (!present(input))
+    if (!present2(input))
       throw new ModelKitError({
         code: "missing_input",
         message: `${model.id} requires ${input}`,
         model: model.id
       });
   }
-  if (c.requiresOneOf && !c.requiresOneOf.some(present)) {
+  if (c.requiresOneOf && !c.requiresOneOf.some(present2)) {
     throw new ModelKitError({
       code: "missing_input",
       message: `${model.id} requires one of: ${c.requiresOneOf.join(", ")}`,
@@ -15136,8 +15935,8 @@ function resolveAudioOptions(model, request, onUnsupported = "error") {
   if (references.length > 0) merged.references = references;
   else delete merged.references;
   for (const input of c.requires ?? []) {
-    const present = input === "references" ? references.length > 0 : input === "sourceVideo" && merged.sourceVideo !== void 0;
-    if (!present)
+    const present2 = input === "references" ? references.length > 0 : input === "sourceVideo" && merged.sourceVideo !== void 0;
+    if (!present2)
       throw new ModelKitError({
         code: "missing_input",
         message: `${model.id} requires ${input}`,
@@ -15191,12 +15990,12 @@ function unsupported3(model, message) {
     model: model.id
   });
 }
-function checkRequired(model, present) {
+function checkRequired(model, present2) {
   for (const input of model.constraints.requires ?? []) {
-    if (present[input] !== true) throw missing2(model, input);
+    if (present2[input] !== true) throw missing2(model, input);
   }
   const oneOf = model.constraints.requiresOneOf;
-  if (oneOf !== void 0 && !oneOf.some((input) => present[input] === true)) {
+  if (oneOf !== void 0 && !oneOf.some((input) => present2[input] === true)) {
     throw missing2(model, `one of ${oneOf.join(", ")}`);
   }
 }
@@ -15458,7 +16257,7 @@ function keysFromEnv(env, prefix = "") {
 
 // src/text.ts
 var import_ai4 = require("ai");
-var import_zod28 = require("zod");
+var import_zod30 = require("zod");
 function mergeTextProviderOptions(catalog, caller) {
   const merged = {};
   const catalogOptions = catalog.providerOptions ?? {};
@@ -15497,8 +16296,8 @@ function passthroughTextModel(model) {
     pricingKind: "token"
   };
 }
-var perplexityCostSchema = import_zod28.z.object({
-  perplexity: import_zod28.z.object({ cost: import_zod28.z.object({ totalCost: import_zod28.z.number().finite().nonnegative() }) })
+var perplexityCostSchema = import_zod30.z.object({
+  perplexity: import_zod30.z.object({ cost: import_zod30.z.object({ totalCost: import_zod30.z.number().finite().nonnegative() }) })
 });
 function reportedCostUsd(metadata) {
   const parsed = perplexityCostSchema.safeParse(metadata);
@@ -15571,7 +16370,7 @@ function createTextSteps(initial, resolve, callerProviderOptions) {
 
 // src/client.ts
 var import_ai5 = require("ai");
-var import_zod29 = require("zod");
+var import_zod31 = require("zod");
 
 // src/generated-image.ts
 function toGeneratedImage(image) {
@@ -15598,8 +16397,8 @@ function isAnthropicTransport(value) {
   return ANTHROPIC_TRANSPORTS.some((transport) => transport === value);
 }
 function preferredAnthropicTransport(model, routing) {
-  const row = model.providerOptions?.["modelkit"]?.["transport"];
-  if (isAnthropicTransport(row)) return row;
+  const row2 = model.providerOptions?.["modelkit"]?.["transport"];
+  if (isAnthropicTransport(row2)) return row2;
   return routing.anthropic ?? "direct";
 }
 function resolveAnthropicTransport(model, config, tier, warn) {
@@ -15626,6 +16425,85 @@ function textUsageProvider(model, transport) {
   return transport === "bedrock" ? BEDROCK_USAGE_PROVIDER : textProviderOf(model);
 }
 
+// src/provider-job.ts
+var VIDEO_TOOL_JOB = {
+  type: "video-tool",
+  noun: "a video tool",
+  plural: "video tools",
+  methods: (a) => ({
+    submit: a.submitVideoTool?.bind(a),
+    status: a.videoToolStatus?.bind(a),
+    result: a.videoToolResult?.bind(a),
+    cancel: a.cancelVideoTool?.bind(a)
+  })
+};
+var MODEL3D_JOB = {
+  type: "model3d",
+  noun: "a 3D model",
+  plural: "3D models",
+  methods: (a) => ({
+    submit: a.submitModel3d?.bind(a),
+    status: a.model3dStatus?.bind(a),
+    result: a.model3dResult?.bind(a),
+    cancel: a.cancelModel3d?.bind(a)
+  })
+};
+function providerJobMethods(kind, deps) {
+  function target(modelId, call) {
+    mediaRetryOptions(call);
+    const model = deps.catalog.require(modelId);
+    if (model.type !== kind.type)
+      throw new ModelKitError({
+        code: "unsupported_option",
+        message: `${model.id} is not ${kind.noun}`,
+        model: model.id
+      });
+    const { adapter, ctx } = deps.context(model, call);
+    return { methods: kind.methods(adapter), adapter, ctx };
+  }
+  function missing3(adapter, model) {
+    return new ModelKitError({
+      code: "unsupported_option",
+      message: `${adapter.id} has no ${kind.plural}`,
+      model: model.id
+    });
+  }
+  return {
+    async submit(req, call = {}) {
+      const { webhookUrl, ...rest } = call;
+      const { methods, adapter, ctx } = target(req.model, rest);
+      if (!methods.submit) throw missing3(adapter, ctx.model);
+      const submittedAt = Date.now();
+      const submission = await methods.submit(
+        req,
+        ctx,
+        webhookUrl !== void 0 ? { webhookUrl } : {}
+      );
+      return { ...submission, submittedAt };
+    },
+    async status(sub, call = {}) {
+      const { methods, adapter, ctx } = target(sub.model, call);
+      if (!methods.status) throw missing3(adapter, ctx.model);
+      return methods.status(sub, ctx);
+    },
+    async result(sub, call = {}) {
+      const { webhook, ...rest } = call;
+      const { methods, adapter, ctx } = target(sub.model, rest);
+      if (!methods.result) throw missing3(adapter, ctx.model);
+      const result = await methods.result(sub, ctx, webhook);
+      const base = { ...result.usage, model: ctx.model.id, unit: ctx.model.usage.unit };
+      const usage3 = sub.submittedAt === void 0 ? base : deps.timed(base, sub.submittedAt);
+      await deps.emit(usage3);
+      return { ...result, usage: usage3 };
+    },
+    async cancel(sub, call = {}) {
+      const { methods, adapter, ctx } = target(sub.model, call);
+      if (!methods.cancel) throw missing3(adapter, ctx.model);
+      return methods.cancel(sub, ctx);
+    }
+  };
+}
+
 // src/resolve-call.ts
 var MEDIA_METHODS = {
   text: [],
@@ -15641,7 +16519,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",
@@ -15838,10 +16719,10 @@ function textAbortOptions(sdk, context) {
   if (abortSignal) return { abortSignal };
   return {};
 }
-var catalogId = import_zod29.z.string();
-var exactSize = import_zod29.z.templateLiteral([import_zod29.z.number(), "x", import_zod29.z.number()]);
-var sdkRatio = import_zod29.z.templateLiteral([import_zod29.z.number(), ":", import_zod29.z.number()]);
-var sizeTier = import_zod29.z.enum(["512", "1K", "2K", "4K"]);
+var catalogId = import_zod31.z.string();
+var exactSize = import_zod31.z.templateLiteral([import_zod31.z.number(), "x", import_zod31.z.number()]);
+var sdkRatio = import_zod31.z.templateLiteral([import_zod31.z.number(), ":", import_zod31.z.number()]);
+var sizeTier = import_zod31.z.enum(["512", "1K", "2K", "4K"]);
 function isCatalogId(model) {
   return catalogId.safeParse(model).success;
 }
@@ -15951,19 +16832,14 @@ function createModelKit(config, adapters) {
     if (call.signal) ctx.signal = call.signal;
     return { adapter, ctx };
   }
-  function videoToolTarget(modelId, call) {
-    mediaRetryOptions(call);
-    const model = catalog.require(modelId);
-    assertMethod(model, "submitVideoTool");
-    return context(model, call, []);
-  }
-  function noVideoTools(adapter, model) {
-    return new ModelKitError({
-      code: "unsupported_option",
-      message: `${adapter.id} has no video tools`,
-      model: model.id
-    });
-  }
+  const jobDeps = {
+    catalog,
+    context: (model, call) => context(model, call, []),
+    timed,
+    emit
+  };
+  const videoToolJobs = providerJobMethods(VIDEO_TOOL_JOB, jobDeps);
+  const model3dJobs = providerJobMethods(MODEL3D_JOB, jobDeps);
   function timed(event, startedAt) {
     if (event.latencyMs !== void 0) return event;
     return { ...event, latencyMs: Math.max(0, Date.now() - startedAt) };
@@ -15979,8 +16855,8 @@ function createModelKit(config, adapters) {
     }
   }
   function withRowUnit(event) {
-    const row = catalog.get(event.model);
-    return row ? { ...event, unit: row.usage.unit } : event;
+    const row2 = catalog.get(event.model);
+    return row2 ? { ...event, unit: row2.usage.unit } : event;
   }
   function textTarget(model, call) {
     if (!isCatalogId(model)) {
@@ -16394,38 +17270,14 @@ function createModelKit(config, adapters) {
         usageProvider: provider
       };
     },
-    async submitVideoTool(req, call = {}) {
-      const { webhookUrl, ...rest } = call;
-      const { adapter, ctx } = videoToolTarget(req.model, rest);
-      if (!adapter.submitVideoTool) throw noVideoTools(adapter, ctx.model);
-      const submittedAt = Date.now();
-      const submission = await adapter.submitVideoTool(
-        req,
-        ctx,
-        webhookUrl !== void 0 ? { webhookUrl } : {}
-      );
-      return { ...submission, submittedAt };
-    },
-    async videoToolStatus(sub, call = {}) {
-      const { adapter, ctx } = videoToolTarget(sub.model, call);
-      if (!adapter.videoToolStatus) throw noVideoTools(adapter, ctx.model);
-      return adapter.videoToolStatus(sub, ctx);
-    },
-    async videoToolResult(sub, call = {}) {
-      const { webhook, ...rest } = call;
-      const { adapter, ctx } = videoToolTarget(sub.model, rest);
-      if (!adapter.videoToolResult) throw noVideoTools(adapter, ctx.model);
-      const result = await adapter.videoToolResult(sub, ctx, webhook);
-      const base = { ...result.usage, model: ctx.model.id, unit: ctx.model.usage.unit };
-      const usage3 = sub.submittedAt === void 0 ? base : timed(base, sub.submittedAt);
-      await emit(usage3);
-      return { ...result, usage: usage3 };
-    },
-    async cancelVideoTool(sub, call = {}) {
-      const { adapter, ctx } = videoToolTarget(sub.model, call);
-      if (!adapter.cancelVideoTool) throw noVideoTools(adapter, ctx.model);
-      return adapter.cancelVideoTool(sub, ctx);
-    },
+    submitVideoTool: videoToolJobs.submit,
+    videoToolStatus: videoToolJobs.status,
+    videoToolResult: videoToolJobs.result,
+    cancelVideoTool: videoToolJobs.cancel,
+    submitModel3d: model3dJobs.submit,
+    model3dStatus: model3dJobs.status,
+    model3dResult: model3dJobs.result,
+    cancelModel3d: model3dJobs.cancel,
     usageProvider(modelId, call = {}) {
       const entry = catalog.require(modelId);
       if (entry.type !== "text") return entry.adapter;
@@ -16573,6 +17425,8 @@ var describe = (modelId) => createDefaultModelKit().describe(modelId);
   InputSpecSchema,
   JsonObjectSchema,
   JsonValueSchema,
+  MODEL3D_IMAGE_SLOTS,
+  MODEL3D_MODELS,
   MODELS,
   ModelKitError,
   SURFACES,
@@ -16615,6 +17469,14 @@ var describe = (modelId) => createDefaultModelKit().describe(modelId);
   liveState,
   mergeTextProviderOptions,
   missingTierKeys,
+  model3dCall,
+  model3dConstraints,
+  model3dInputRefusal,
+  model3dPricingSku,
+  model3dResolution,
+  model3dSeedFits,
+  model3dSkus,
+  model3dTexture,
   nearestAspectRatio,
   normalizeExposure,
   openaiImageAdapter,