@howells/motif-sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2747 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ASPECT_RATIOS: () => ASPECT_RATIOS,
+  FAL_TOOLS: () => FAL_TOOLS,
+  FAL_TOOLS_CHECKED_AT: () => FAL_TOOLS_CHECKED_AT,
+  FAL_TOOL_IDS: () => FAL_TOOL_IDS,
+  FORMAT_PRESETS: () => FORMAT_PRESETS,
+  GENERATION_MODELS: () => GENERATION_MODELS,
+  IDEOGRAM_STYLES: () => IDEOGRAM_STYLES,
+  IMAGE_EDITING_TOP_20: () => IMAGE_EDITING_TOP_20,
+  IMAGE_TEXT_TO_IMAGE_TOP_20: () => IMAGE_TEXT_TO_IMAGE_TOP_20,
+  MODELS: () => MODELS,
+  MotifError: () => MotifError,
+  MotifServer: () => MotifServer,
+  RECRAFT_STYLES: () => RECRAFT_STYLES,
+  RESOLUTIONS: () => RESOLUTIONS,
+  UTILITY_MODELS: () => UTILITY_MODELS,
+  VIDEO_IMAGE_TO_VIDEO_TOP_15: () => VIDEO_IMAGE_TO_VIDEO_TOP_15,
+  VIDEO_MODELS: () => VIDEO_MODELS,
+  VIDEO_TEXT_TO_VIDEO_TOP_15: () => VIDEO_TEXT_TO_VIDEO_TOP_15,
+  aspectToFalImageSize: () => aspectToFalImageSize,
+  aspectToGptSize: () => aspectToGptSize,
+  buildFalToolRequest: () => buildFalToolRequest,
+  buildGenerateBody: () => buildGenerateBody,
+  err: () => import_neverthrow2.err,
+  estimateCost: () => estimateCost,
+  estimateVideoCost: () => estimateVideoCost,
+  getFalKeyFromEnv: () => getFalKeyFromEnv,
+  isFalToolId: () => isFalToolId,
+  motifEnvSchema: () => motifEnvSchema,
+  ok: () => import_neverthrow2.ok,
+  parseMotifEnv: () => parseMotifEnv
+});
+module.exports = __toCommonJS(index_exports);
+var import_neverthrow2 = require("neverthrow");
+
+// src/aspects.ts
+var ASPECT_RATIOS = [
+  "auto",
+  "1:1",
+  "4:3",
+  "3:4",
+  "16:9",
+  "9:16",
+  "3:2",
+  "2:3",
+  "4:5",
+  "5:4",
+  "21:9",
+  "4:1",
+  "1:4",
+  "8:1",
+  "1:8"
+];
+var RESOLUTIONS = ["0.5K", "1K", "2K", "4K"];
+function aspectToGptSize(aspect) {
+  switch (aspect) {
+    case "auto":
+      return "auto";
+    case "9:16":
+    case "1:8":
+    case "1:4":
+    case "2:3":
+    case "4:5":
+    case "3:4":
+      return "1024x1536";
+    case "16:9":
+    case "8:1":
+    case "4:1":
+    case "3:2":
+    case "5:4":
+    case "4:3":
+    case "21:9":
+      return "1536x1024";
+    default:
+      return "1024x1024";
+  }
+}
+function aspectToFalImageSize(aspect) {
+  switch (aspect) {
+    case "auto":
+      return "auto";
+    case "16:9":
+    case "21:9":
+    case "4:1":
+    case "8:1":
+      return "landscape_16_9";
+    case "3:2":
+    case "5:4":
+      return "landscape_4_3";
+    case "4:3":
+      return "landscape_4_3";
+    case "9:16":
+    case "1:4":
+    case "1:8":
+      return "portrait_16_9";
+    case "2:3":
+    case "4:5":
+      return "portrait_4_3";
+    case "3:4":
+      return "portrait_4_3";
+    default:
+      return "square_hd";
+  }
+}
+var FORMAT_PRESETS = {
+  cover: { label: "Cover", aspect: "2:3", resolution: "2K" },
+  square: { label: "Square", aspect: "1:1" },
+  landscape: { label: "Landscape", aspect: "16:9" },
+  portrait: { label: "Portrait", aspect: "2:3" },
+  story: { label: "Story", aspect: "9:16" },
+  og: { label: "OG Image", aspect: "16:9" },
+  wide: { label: "Wide", aspect: "21:9" }
+};
+
+// src/models.ts
+var AA_IMAGE_LEADERBOARD_SNAPSHOT = "2026-05-12";
+var AA_IMAGE_SOURCES = [
+  "https://artificialanalysis.ai/image/leaderboard/text-to-image",
+  "https://artificialanalysis.ai/image/leaderboard/editing"
+];
+var FAL_PRICING_CHECKED_AT = "2026-05-12";
+var MODELS = {
+  // ─── Generation Models ────────────────────────────────────────
+  gpt2: {
+    name: "GPT Image 2",
+    endpoint: "openai/gpt-image-2",
+    editEndpoint: "openai/gpt-image-2/image-to-image",
+    type: "generation",
+    pricing: "$0.211",
+    pricePerImageUsd: 0.211,
+    falPricing: {
+      endpointId: "openai/gpt-image-2",
+      unitPrice: 1,
+      unit: "units",
+      currency: "USD",
+      estimatedCostPerImageUsd: 0.211,
+      source: "fal-pricing-api",
+      checkedAt: FAL_PRICING_CHECKED_AT
+    },
+    benchmark: {
+      useCase: "Highest-ranked text-to-image quality and transparent PNGs",
+      tiers: { quality: "frontier", speed: "very_slow", price: "ultra" },
+      speed: {
+        medianSeconds: 200.7,
+        p95Seconds: 232.6,
+        source: "artificial-analysis-models"
+      },
+      artificialAnalysis: {
+        snapshotDate: AA_IMAGE_LEADERBOARD_SNAPSHOT,
+        sourceUrls: AA_IMAGE_SOURCES,
+        textToImage: { rank: 1, elo: 1337, winRate: 0.8, pricePer1k: 211 },
+        editing: { rank: 3, elo: 1249, winRate: 0.66, pricePer1k: 211 }
+      }
+    },
+    sizeMode: "image_size_enum",
+    supportsAspect: true,
+    supportsResolution: false,
+    supportsEdit: true,
+    supportsNumImages: true,
+    supportsOutputFormat: true,
+    supportsQuality: true,
+    supportsMaskImage: true,
+    supportsSyncMode: true,
+    maxReferenceImages: 4,
+    useQueue: true
+  },
+  gpt: {
+    name: "GPT Image 1.5",
+    endpoint: "fal-ai/gpt-image-1.5",
+    editEndpoint: "fal-ai/gpt-image-1.5/edit",
+    type: "generation",
+    pricing: "$0.133",
+    pricePerImageUsd: 0.133,
+    falPricing: {
+      endpointId: "fal-ai/gpt-image-1.5",
+      unitPrice: 1,
+      unit: "units",
+      currency: "USD",
+      estimatedCostPerImageUsd: 0.133,
+      source: "fal-pricing-api",
+      checkedAt: FAL_PRICING_CHECKED_AT
+    },
+    benchmark: {
+      useCase: "Best OpenAI edit quality with transparent PNG support",
+      tiers: { quality: "frontier", speed: "slow", price: "ultra" },
+      speed: {
+        medianSeconds: 34.6,
+        p95Seconds: 38.3,
+        source: "artificial-analysis-models"
+      },
+      artificialAnalysis: {
+        snapshotDate: AA_IMAGE_LEADERBOARD_SNAPSHOT,
+        sourceUrls: AA_IMAGE_SOURCES,
+        textToImage: { rank: 2, elo: 1268, winRate: 0.73, pricePer1k: 133 },
+        editing: { rank: 2, elo: 1262, winRate: 0.69, pricePer1k: 133 }
+      }
+    },
+    sizeMode: "gpt_size",
+    supportsAspect: false,
+    supportsBackground: true,
+    supportsResolution: false,
+    supportsEdit: true,
+    supportsNumImages: true,
+    supportsOutputFormat: true,
+    supportsQuality: true,
+    supportsMaskImage: true,
+    supportsSyncMode: true,
+    maxReferenceImages: 4
+  },
+  banana2: {
+    name: "Nano Banana 2",
+    endpoint: "fal-ai/nano-banana-2",
+    editEndpoint: "fal-ai/nano-banana-2/edit",
+    type: "generation",
+    pricing: "$0.08",
+    pricePerImageUsd: 0.08,
+    falPricing: {
+      endpointId: "fal-ai/nano-banana-2",
+      unitPrice: 0.08,
+      unit: "images",
+      currency: "USD",
+      estimatedCostPerImageUsd: 0.08,
+      source: "fal-pricing-api",
+      checkedAt: FAL_PRICING_CHECKED_AT
+    },
+    benchmark: {
+      useCase: "Best balance of quality, edit support, web search, and cost",
+      tiers: { quality: "frontier", speed: "unknown", price: "premium" },
+      artificialAnalysis: {
+        snapshotDate: AA_IMAGE_LEADERBOARD_SNAPSHOT,
+        sourceUrls: AA_IMAGE_SOURCES,
+        textToImage: { rank: 3, elo: 1263, winRate: 0.71, pricePer1k: 67 },
+        editing: { rank: 5, elo: 1231, winRate: 0.63, pricePer1k: 67 }
+      }
+    },
+    sizeMode: "aspect_ratio",
+    supportsAspect: true,
+    supportsResolution: true,
+    supportsEdit: true,
+    supportsNumImages: true,
+    supportsOutputFormat: true,
+    supportsSafetyTolerance: true,
+    supportsSeed: true,
+    supportsWebSearch: true,
+    supportsGoogleSearch: true,
+    supportsLimitGenerations: true,
+    supportsSyncMode: true,
+    supportsThinkingLevel: true,
+    maxReferenceImages: 4
+  },
+  banana: {
+    name: "Nano Banana Pro",
+    endpoint: "fal-ai/nano-banana-pro",
+    editEndpoint: "fal-ai/nano-banana-pro/edit",
+    type: "generation",
+    pricing: "$0.15",
+    pricePerImageUsd: 0.15,
+    falPricing: {
+      endpointId: "fal-ai/nano-banana-pro",
+      unitPrice: 0.15,
+      unit: "images",
+      currency: "USD",
+      estimatedCostPerImageUsd: 0.15,
+      source: "fal-pricing-api",
+      checkedAt: FAL_PRICING_CHECKED_AT
+    },
+    benchmark: {
+      useCase: "Premium Gemini image generation and multi-reference edits",
+      tiers: { quality: "frontier", speed: "balanced", price: "ultra" },
+      speed: {
+        medianSeconds: 19.2,
+        p95Seconds: 30.3,
+        source: "artificial-analysis-models"
+      },
+      artificialAnalysis: {
+        snapshotDate: AA_IMAGE_LEADERBOARD_SNAPSHOT,
+        sourceUrls: AA_IMAGE_SOURCES,
+        textToImage: { rank: 5, elo: 1220, winRate: 0.66, pricePer1k: 134 },
+        editing: { rank: 4, elo: 1241, winRate: 0.65, pricePer1k: 134 }
+      }
+    },
+    sizeMode: "aspect_ratio",
+    supportsAspect: true,
+    supportsResolution: true,
+    supportsEdit: true,
+    supportsNumImages: true,
+    supportsOutputFormat: true,
+    supportsSafetyTolerance: true,
+    supportsSeed: true,
+    supportsWebSearch: true,
+    supportsGoogleSearch: true,
+    supportsLimitGenerations: true,
+    supportsSyncMode: true,
+    maxReferenceImages: 14
+  },
+  gemini: {
+    name: "Gemini 2.5 Flash",
+    endpoint: "fal-ai/gemini-25-flash-image",
+    editEndpoint: "fal-ai/gemini-25-flash-image/edit",
+    type: "generation",
+    pricing: "$0.04",
+    pricePerImageUsd: 0.0398,
+    falPricing: {
+      endpointId: "fal-ai/gemini-25-flash-image",
+      unitPrice: 0.0398,
+      unit: "images",
+      currency: "USD",
+      estimatedCostPerImageUsd: 0.0398,
+      source: "fal-pricing-api",
+      checkedAt: FAL_PRICING_CHECKED_AT
+    },
+    sizeMode: "aspect_ratio",
+    supportsAspect: true,
+    supportsResolution: false,
+    supportsEdit: true,
+    supportsNumImages: true,
+    supportsOutputFormat: true,
+    supportsSafetyTolerance: true,
+    supportsSeed: true,
+    supportsSyncMode: true,
+    maxReferenceImages: 4
+  },
+  gemini3: {
+    name: "Gemini 3 Pro",
+    endpoint: "fal-ai/gemini-3-pro-image-preview",
+    editEndpoint: "fal-ai/gemini-3-pro-image-preview/edit",
+    type: "generation",
+    pricing: "$0.15",
+    pricePerImageUsd: 0.15,
+    falPricing: {
+      endpointId: "fal-ai/gemini-3-pro-image-preview",
+      unitPrice: 0.15,
+      unit: "images",
+      currency: "USD",
+      estimatedCostPerImageUsd: 0.15,
+      source: "fal-pricing-api",
+      checkedAt: FAL_PRICING_CHECKED_AT
+    },
+    sizeMode: "aspect_ratio",
+    supportsAspect: true,
+    supportsResolution: true,
+    supportsEdit: true,
+    supportsNumImages: true,
+    supportsOutputFormat: true,
+    supportsSafetyTolerance: true,
+    supportsSeed: true,
+    supportsWebSearch: true,
+    supportsSyncMode: true,
+    maxReferenceImages: 4
+  },
+  seedream4: {
+    name: "Seedream 4.0",
+    endpoint: "fal-ai/bytedance/seedream/v4/text-to-image",
+    editEndpoint: "fal-ai/bytedance/seedream/v4/edit",
+    type: "generation",
+    pricing: "$0.03",
+    pricePerImageUsd: 0.03,
+    falPricing: {
+      endpointId: "fal-ai/bytedance/seedream/v4/text-to-image",
+      unitPrice: 0.03,
+      unit: "images",
+      currency: "USD",
+      estimatedCostPerImageUsd: 0.03,
+      source: "fal-pricing-api",
+      checkedAt: FAL_PRICING_CHECKED_AT
+    },
+    benchmark: {
+      useCase: "High-ranked budget generation and large multi-reference edits",
+      tiers: { quality: "best", speed: "balanced", price: "budget" },
+      speed: {
+        medianSeconds: 14.3,
+        p95Seconds: 21,
+        source: "artificial-analysis-models"
+      },
+      artificialAnalysis: {
+        snapshotDate: AA_IMAGE_LEADERBOARD_SNAPSHOT,
+        sourceUrls: AA_IMAGE_SOURCES,
+        textToImage: { rank: 6, elo: 1198, winRate: 0.59, pricePer1k: 30 },
+        editing: { rank: 16, elo: 1184, winRate: 0.61, pricePer1k: 30 }
+      }
+    },
+    sizeMode: "image_size_enum",
+    supportsAspect: true,
+    supportsResolution: false,
+    supportsEdit: true,
+    supportsNumImages: true,
+    supportsSeed: true,
+    supportsSyncMode: true,
+    maxReferenceImages: 10
+  },
+  seedream45: {
+    name: "Seedream 4.5",
+    endpoint: "fal-ai/bytedance/seedream/v4.5/text-to-image",
+    editEndpoint: "fal-ai/bytedance/seedream/v4.5/edit",
+    type: "generation",
+    pricing: "$0.04",
+    pricePerImageUsd: 0.04,
+    falPricing: {
+      endpointId: "fal-ai/bytedance/seedream/v4.5/text-to-image",
+      unitPrice: 0.04,
+      unit: "images",
+      currency: "USD",
+      estimatedCostPerImageUsd: 0.04,
+      source: "fal-pricing-api",
+      checkedAt: FAL_PRICING_CHECKED_AT
+    },
+    benchmark: {
+      useCase: "Cheap current Seedream model with good animation/art scores",
+      tiers: { quality: "better", speed: "balanced", price: "standard" },
+      speed: {
+        medianSeconds: 18.2,
+        p95Seconds: 43.3,
+        source: "artificial-analysis-models"
+      },
+      artificialAnalysis: {
+        snapshotDate: AA_IMAGE_LEADERBOARD_SNAPSHOT,
+        sourceUrls: AA_IMAGE_SOURCES,
+        textToImage: { rank: 17, elo: 1167, winRate: 0.63, pricePer1k: 40 },
+        editing: { rank: 17, elo: 1184, winRate: 0.58, pricePer1k: 40 }
+      }
+    },
+    sizeMode: "image_size_enum",
+    supportsAspect: true,
+    supportsResolution: false,
+    supportsEdit: true,
+    supportsNumImages: true,
+    supportsSeed: true,
+    supportsSyncMode: true,
+    maxReferenceImages: 10
+  },
+  "flux2-max": {
+    name: "FLUX.2 Max",
+    endpoint: "fal-ai/flux-2-max",
+    editEndpoint: "fal-ai/flux-2-max/edit",
+    type: "generation",
+    pricing: "$0.07/MP",
+    pricePerImageUsd: 0.07,
+    falPricing: {
+      endpointId: "fal-ai/flux-2-max",
+      unitPrice: 0.07,
+      unit: "megapixels",
+      currency: "USD",
+      estimatedCostPerImageUsd: 0.07,
+      source: "fal-pricing-api",
+      checkedAt: FAL_PRICING_CHECKED_AT
+    },
+    benchmark: {
+      useCase: "Best FLUX quality and high-end editing",
+      tiers: { quality: "best", speed: "slow", price: "premium" },
+      speed: {
+        medianSeconds: 31.6,
+        p95Seconds: 41,
+        source: "artificial-analysis-models"
+      },
+      artificialAnalysis: {
+        snapshotDate: AA_IMAGE_LEADERBOARD_SNAPSHOT,
+        sourceUrls: AA_IMAGE_SOURCES,
+        textToImage: { rank: 8, elo: 1197, winRate: 0.67, pricePer1k: 70 },
+        editing: { rank: 10, elo: 1206, winRate: 0.6, pricePer1k: 140 }
+      }
+    },
+    sizeMode: "image_size_enum",
+    supportsAspect: true,
+    supportsResolution: false,
+    supportsEdit: true,
+    supportsNumImages: false,
+    supportsOutputFormat: true,
+    supportsSafetyTolerance: true,
+    supportsSafetyChecker: true,
+    supportsSeed: true,
+    supportsSyncMode: true,
+    maxReferenceImages: 10
+  },
+  "flux2-pro": {
+    name: "FLUX.2 Pro",
+    endpoint: "fal-ai/flux-2-pro",
+    editEndpoint: "fal-ai/flux-2-pro/edit",
+    type: "generation",
+    pricing: "$0.03/MP",
+    pricePerImageUsd: 0.03,
+    falPricing: {
+      endpointId: "fal-ai/flux-2-pro",
+      unitPrice: 0.03,
+      unit: "processed megapixels",
+      currency: "USD",
+      estimatedCostPerImageUsd: 0.03,
+      source: "fal-pricing-api",
+      checkedAt: FAL_PRICING_CHECKED_AT
+    },
+    benchmark: {
+      useCase: "Production FLUX quality at a low per-megapixel price",
+      tiers: { quality: "best", speed: "balanced", price: "budget" },
+      speed: {
+        medianSeconds: 16.1,
+        p95Seconds: 23.9,
+        source: "artificial-analysis-models"
+      },
+      artificialAnalysis: {
+        snapshotDate: AA_IMAGE_LEADERBOARD_SNAPSHOT,
+        sourceUrls: AA_IMAGE_SOURCES,
+        textToImage: { rank: 10, elo: 1186, winRate: 0.62, pricePer1k: 30 },
+        editing: { rank: 21, elo: 1170, pricePer1k: 30 }
+      }
+    },
+    sizeMode: "image_size_enum",
+    supportsAspect: true,
+    supportsResolution: false,
+    supportsEdit: true,
+    supportsNumImages: false,
+    supportsOutputFormat: true,
+    supportsSafetyTolerance: true,
+    supportsSafetyChecker: true,
+    supportsSeed: true,
+    supportsSyncMode: true,
+    maxReferenceImages: 10
+  },
+  "flux2-flex": {
+    name: "FLUX.2 Flex",
+    endpoint: "fal-ai/flux-2-flex",
+    editEndpoint: "fal-ai/flux-2-flex/edit",
+    type: "generation",
+    pricing: "$0.05/MP",
+    pricePerImageUsd: 0.05,
+    falPricing: {
+      endpointId: "fal-ai/flux-2-flex",
+      unitPrice: 0.05,
+      unit: "processed megapixels",
+      currency: "USD",
+      estimatedCostPerImageUsd: 0.05,
+      source: "fal-pricing-api",
+      checkedAt: FAL_PRICING_CHECKED_AT
+    },
+    benchmark: {
+      useCase: "FLUX quality with guidance and step controls",
+      tiers: { quality: "best", speed: "balanced", price: "standard" },
+      speed: {
+        medianSeconds: 15.3,
+        p95Seconds: 22.2,
+        source: "artificial-analysis-models"
+      },
+      artificialAnalysis: {
+        snapshotDate: AA_IMAGE_LEADERBOARD_SNAPSHOT,
+        sourceUrls: AA_IMAGE_SOURCES,
+        textToImage: { rank: 13, elo: 1182, winRate: 0.61, pricePer1k: 60 },
+        editing: { rank: 22, elo: 1161, pricePer1k: 60 }
+      }
+    },
+    sizeMode: "image_size_enum",
+    supportsAspect: true,
+    supportsResolution: false,
+    supportsEdit: true,
+    supportsNumImages: false,
+    supportsOutputFormat: true,
+    supportedOutputFormats: ["jpeg", "png"],
+    supportsSafetyTolerance: true,
+    supportsSafetyChecker: true,
+    supportsSeed: true,
+    supportsGuidanceScale: true,
+    supportsInferenceSteps: true,
+    supportsSyncMode: true,
+    maxReferenceImages: 10
+  },
+  "flux2-dev": {
+    name: "FLUX.2 Dev",
+    endpoint: "fal-ai/flux-2",
+    editEndpoint: "fal-ai/flux-2/edit",
+    type: "generation",
+    pricing: "$0.00167/sec",
+    pricePerImageUsd: 0.012,
+    falPricing: {
+      endpointId: "fal-ai/flux-2",
+      unitPrice: 167e-5,
+      unit: "compute seconds",
+      currency: "USD",
+      estimatedCostPerImageUsd: 0.012,
+      source: "fal-pricing-api",
+      checkedAt: FAL_PRICING_CHECKED_AT
+    },
+    benchmark: {
+      useCase: "Open FLUX.2 quality with low average cost",
+      tiers: { quality: "better", speed: "fast", price: "variable" },
+      speed: {
+        medianSeconds: 4.6,
+        p95Seconds: 69.6,
+        source: "artificial-analysis-models"
+      },
+      artificialAnalysis: {
+        snapshotDate: AA_IMAGE_LEADERBOARD_SNAPSHOT,
+        sourceUrls: AA_IMAGE_SOURCES,
+        textToImage: { rank: 19, elo: 1160, winRate: 0.57, pricePer1k: 12 }
+      }
+    },
+    sizeMode: "image_size_enum",
+    supportsAspect: true,
+    supportsResolution: false,
+    supportsEdit: true,
+    supportsNumImages: true,
+    supportsOutputFormat: true,
+    supportsSafetyTolerance: true,
+    supportsSafetyChecker: true,
+    supportsSeed: true,
+    supportsGuidanceScale: true,
+    supportsInferenceSteps: true,
+    supportsSyncMode: true,
+    maxReferenceImages: 10
+  },
+  flux: {
+    name: "FLUX Pro Ultra",
+    endpoint: "fal-ai/flux-pro/v1.1-ultra",
+    type: "generation",
+    pricing: "$0.06",
+    pricePerImageUsd: 0.06,
+    falPricing: {
+      endpointId: "fal-ai/flux-pro/v1.1-ultra",
+      unitPrice: 0.06,
+      unit: "images",
+      currency: "USD",
+      estimatedCostPerImageUsd: 0.06,
+      source: "fal-pricing-api",
+      checkedAt: FAL_PRICING_CHECKED_AT
+    },
+    sizeMode: "aspect_ratio",
+    supportsAspect: true,
+    supportsResolution: false,
+    supportsEdit: true,
+    supportsNumImages: true,
+    supportsOutputFormat: true,
+    supportsRaw: true,
+    supportsEnhancePrompt: true,
+    supportsSafetyTolerance: true,
+    supportsSeed: true,
+    supportsImagePromptStrength: true,
+    supportsSyncMode: true,
+    maxReferenceImages: 1
+  },
+  "flux-fast": {
+    name: "FLUX Schnell",
+    endpoint: "fal-ai/flux/schnell",
+    type: "generation",
+    pricing: "$0.003",
+    pricePerImageUsd: 3e-3,
+    falPricing: {
+      endpointId: "fal-ai/flux/schnell",
+      unitPrice: 3e-3,
+      unit: "megapixels",
+      currency: "USD",
+      estimatedCostPerImageUsd: 3e-3,
+      source: "fal-pricing-api",
+      checkedAt: FAL_PRICING_CHECKED_AT
+    },
+    sizeMode: "image_size_enum",
+    supportsAspect: true,
+    supportsResolution: false,
+    supportsEdit: false,
+    supportsNumImages: true,
+    supportsOutputFormat: true,
+    supportsGuidanceScale: true,
+    supportsInferenceSteps: true,
+    supportsSeed: true,
+    supportsSyncMode: true
+  },
+  recraft: {
+    name: "Recraft V3",
+    endpoint: "fal-ai/recraft-v3",
+    type: "generation",
+    pricing: "$0.04",
+    pricePerImageUsd: 0.04,
+    falPricing: {
+      endpointId: "fal-ai/recraft-v3",
+      unitPrice: 0.04,
+      unit: "images",
+      currency: "USD",
+      estimatedCostPerImageUsd: 0.04,
+      source: "fal-pricing-api",
+      checkedAt: FAL_PRICING_CHECKED_AT
+    },
+    sizeMode: "image_size_enum",
+    supportsAspect: true,
+    supportsResolution: false,
+    supportsEdit: false,
+    supportsNumImages: false,
+    supportsStyle: true,
+    supportsSyncMode: true
+  },
+  ideogram: {
+    name: "Ideogram V3",
+    endpoint: "fal-ai/ideogram/v3",
+    type: "generation",
+    pricing: "$0.03",
+    pricePerImageUsd: 0.03,
+    falPricing: {
+      endpointId: "fal-ai/ideogram/v3",
+      unitPrice: 0.03,
+      unit: "images",
+      currency: "USD",
+      estimatedCostPerImageUsd: 0.03,
+      source: "fal-pricing-api",
+      checkedAt: FAL_PRICING_CHECKED_AT
+    },
+    sizeMode: "image_size_enum",
+    supportsAspect: true,
+    supportsResolution: false,
+    supportsEdit: false,
+    supportsNumImages: true,
+    supportsExpandPrompt: true,
+    supportsNegativePrompt: true,
+    supportsRenderingSpeed: true,
+    supportsSeed: true,
+    supportsStyle: true,
+    supportsSyncMode: true
+  },
+  "grok-image": {
+    name: "Grok Imagine Image",
+    endpoint: "xai/grok-imagine-image",
+    editEndpoint: "xai/grok-imagine-image/edit",
+    type: "generation",
+    pricing: "$0.02",
+    pricePerImageUsd: 0.02,
+    falPricing: {
+      endpointId: "xai/grok-imagine-image",
+      unitPrice: 0.02,
+      unit: "images",
+      currency: "USD",
+      estimatedCostPerImageUsd: 0.02,
+      source: "fal-pricing-api",
+      checkedAt: FAL_PRICING_CHECKED_AT
+    },
+    benchmark: {
+      useCase: "Very fast, cheap generation and edits",
+      tiers: { quality: "best", speed: "fast", price: "budget" },
+      speed: {
+        medianSeconds: 5.1,
+        p95Seconds: 6.5,
+        source: "artificial-analysis-models"
+      },
+      artificialAnalysis: {
+        snapshotDate: AA_IMAGE_LEADERBOARD_SNAPSHOT,
+        sourceUrls: AA_IMAGE_SOURCES,
+        textToImage: { rank: 12, elo: 1182, winRate: 0.6, pricePer1k: 20 },
+        editing: { rank: 7, elo: 1213, winRate: 0.6, pricePer1k: 20 }
+      }
+    },
+    sizeMode: "aspect_ratio",
+    supportsAspect: true,
+    supportsResolution: true,
+    supportsEdit: true,
+    supportsNumImages: true,
+    supportsOutputFormat: true,
+    supportsSyncMode: true,
+    maxReferenceImages: 4
+  },
+  qwen: {
+    name: "Qwen Image",
+    endpoint: "fal-ai/qwen-image",
+    type: "generation",
+    pricing: "$0.02/MP",
+    pricePerImageUsd: 0.02,
+    falPricing: {
+      endpointId: "fal-ai/qwen-image",
+      unitPrice: 0.02,
+      unit: "megapixels",
+      currency: "USD",
+      estimatedCostPerImageUsd: 0.02,
+      source: "fal-pricing-api",
+      checkedAt: FAL_PRICING_CHECKED_AT
+    },
+    benchmark: {
+      useCase: "Low-cost open-weight text and design generation",
+      tiers: { quality: "better", speed: "slow", price: "budget" },
+      speed: {
+        medianSeconds: 23.3,
+        p95Seconds: 491,
+        source: "artificial-analysis-models"
+      },
+      artificialAnalysis: {
+        snapshotDate: AA_IMAGE_LEADERBOARD_SNAPSHOT,
+        sourceUrls: AA_IMAGE_SOURCES,
+        textToImage: { rank: 20, elo: 1158, winRate: 0.6, pricePer1k: 20 }
+      }
+    },
+    sizeMode: "image_size_enum",
+    supportsAspect: true,
+    supportsResolution: false,
+    supportsEdit: false,
+    supportsNumImages: true,
+    supportsOutputFormat: true,
+    supportsSeed: true,
+    supportsSyncMode: true
+  },
+  // ─── Video Models ─────────────────────────────────────────────
+  kling: {
+    name: "Kling v3 Pro",
+    endpoint: "fal-ai/kling-video/v3/pro/image-to-video",
+    type: "video",
+    pricing: "$0.11/sec",
+    sizeMode: "none",
+    supportsAspect: false,
+    supportsResolution: false,
+    supportsEdit: false,
+    supportsNumImages: false
+  },
+  // ─── Utility Models ───────────────────────────────────────────
+  clarity: {
+    name: "Clarity Upscaler",
+    endpoint: "fal-ai/clarity-upscaler",
+    type: "utility",
+    pricing: "$0.02",
+    supportsAspect: false,
+    supportsResolution: false,
+    supportsEdit: false,
+    supportsNumImages: false
+  },
+  crystal: {
+    name: "Crystal Upscaler",
+    endpoint: "clarityai/crystal-upscaler",
+    type: "utility",
+    pricing: "$0.02",
+    supportsAspect: false,
+    supportsResolution: false,
+    supportsEdit: false,
+    supportsNumImages: false
+  },
+  rmbg: {
+    name: "BiRefNet (Background Removal)",
+    endpoint: "fal-ai/birefnet",
+    type: "utility",
+    pricing: "$0.02",
+    supportsAspect: false,
+    supportsResolution: false,
+    supportsEdit: false,
+    supportsNumImages: false
+  },
+  bria: {
+    name: "Bria RMBG 2.0",
+    endpoint: "fal-ai/bria/background/remove",
+    type: "utility",
+    pricing: "$0.02",
+    supportsAspect: false,
+    supportsResolution: false,
+    supportsEdit: false,
+    supportsNumImages: false
+  }
+};
+var GENERATION_MODELS = [
+  "gpt2",
+  "gpt",
+  "banana2",
+  "banana",
+  "gemini",
+  "gemini3",
+  "seedream4",
+  "seedream45",
+  "flux2-max",
+  "flux2-pro",
+  "flux2-flex",
+  "flux2-dev",
+  "flux",
+  "flux-fast",
+  "recraft",
+  "ideogram",
+  "grok-image",
+  "qwen"
+];
+var UTILITY_MODELS = ["clarity", "crystal", "rmbg", "bria"];
+var VIDEO_MODELS = ["kling"];
+var RECRAFT_STYLES = [
+  // Realistic
+  "realistic_image",
+  "realistic_image/b_and_w",
+  "realistic_image/enterprise",
+  "realistic_image/hard_flash",
+  "realistic_image/hdr",
+  "realistic_image/motion_blur",
+  "realistic_image/natural_light",
+  "realistic_image/studio_portrait",
+  "realistic_image/long_exposure",
+  // Digital illustration
+  "digital_illustration",
+  "digital_illustration/2d_art_poster",
+  "digital_illustration/2d_art_poster_2",
+  "digital_illustration/engraving_color",
+  "digital_illustration/grain",
+  "digital_illustration/hand_drawn",
+  "digital_illustration/hand_drawn_outline",
+  "digital_illustration/handmade_3d",
+  "digital_illustration/infantile_sketch",
+  "digital_illustration/pixel_art",
+  "digital_illustration/psychedelic",
+  "digital_illustration/seamless",
+  "digital_illustration/voxel",
+  "digital_illustration/watercolor",
+  // Vector illustration
+  "vector_illustration",
+  "vector_illustration/cartoon",
+  "vector_illustration/doodle_line_art",
+  "vector_illustration/engraving",
+  "vector_illustration/flat_2",
+  "vector_illustration/kawaii",
+  "vector_illustration/line_art",
+  "vector_illustration/line_circuit",
+  "vector_illustration/linocut",
+  "vector_illustration/zentangle"
+];
+var IDEOGRAM_STYLES = [
+  "AUTO",
+  "GENERAL",
+  "REALISTIC",
+  "DESIGN"
+];
+
+// src/cost.ts
+function estimateCost(model, resolution, numImages = 1) {
+  const configuredPrice = MODELS[model]?.pricePerImageUsd;
+  if (configuredPrice !== void 0) {
+    if ((model === "banana" || model === "gemini3") && resolution === "4K") {
+      return configuredPrice * 2 * numImages;
+    }
+    return configuredPrice * numImages;
+  }
+  switch (model) {
+    case "gpt2":
+      return 0.211 * numImages;
+    case "gpt":
+      return 0.133 * numImages;
+    case "banana":
+    case "gemini3":
+      return (resolution === "4K" ? 0.3 : 0.15) * numImages;
+    case "gemini":
+      return 0.039 * numImages;
+    case "flux":
+    case "ideogram":
+      return 0.06 * numImages;
+    case "recraft":
+      return 0.04 * numImages;
+    case "flux-fast":
+      return 3e-3 * numImages;
+    case "clarity":
+    case "crystal":
+    case "rmbg":
+    case "bria":
+      return 0.02 * numImages;
+    default:
+      return 0.1 * numImages;
+  }
+}
+function estimateVideoCost(durationSeconds = 5, generateAudio = true) {
+  const perSecond = generateAudio ? 0.168 : 0.112;
+  return perSecond * durationSeconds;
+}
+
+// src/env.ts
+var import_envy = require("@howells/envy");
+var import_zod = require("zod");
+var motifEnvSchema = (0, import_envy.defineEnv)({
+  optional: {
+    FAL_KEY: import_zod.z.string().min(1)
+  }
+});
+function parseMotifEnv(input = process.env) {
+  return motifEnvSchema.parse(input);
+}
+function getFalKeyFromEnv(input = process.env) {
+  return parseMotifEnv(input).FAL_KEY;
+}
+
+// src/generate.ts
+var GPT_IMAGE_SIZES = ["auto", "1024x1024", "1536x1024", "1024x1536"];
+var FAL_IMAGE_SIZE_PRESETS = [
+  "auto",
+  "square_hd",
+  "square",
+  "portrait_4_3",
+  "portrait_16_9",
+  "landscape_4_3",
+  "landscape_16_9"
+];
+function normalizeImageSize(imageSize, sizeMode) {
+  if (imageSize === void 0) {
+    return void 0;
+  }
+  if (typeof imageSize !== "string") {
+    if (sizeMode === "gpt_size") {
+      throw new Error("GPT Image 1.5 image_size must be auto or a fixed size");
+    }
+    return imageSize;
+  }
+  if (sizeMode === "gpt_size") {
+    if (!GPT_IMAGE_SIZES.includes(imageSize)) {
+      throw new Error(
+        `GPT Image 1.5 image_size must be one of ${GPT_IMAGE_SIZES.join(", ")}`
+      );
+    }
+    return imageSize;
+  }
+  if (FAL_IMAGE_SIZE_PRESETS.includes(imageSize)) {
+    return imageSize;
+  }
+  const match = imageSize.match(/^(\d+)x(\d+)$/);
+  if (match) {
+    const width = Number(match[1]);
+    const height = Number(match[2]);
+    return { width, height };
+  }
+  throw new Error(
+    `fal image_size must be one of ${FAL_IMAGE_SIZE_PRESETS.join(", ")} or WIDTHxHEIGHT`
+  );
+}
+function unsupported(config, option) {
+  throw new Error(`${config.name} does not support ${option}`);
+}
+function validateGenerateOptions(options, config, sizeMode, hasEditImages) {
+  if (options.editImageUrls?.length && config.maxReferenceImages !== void 0 && options.editImageUrls.length > config.maxReferenceImages) {
+    throw new Error(
+      `${config.name} supports at most ${config.maxReferenceImages} reference images`
+    );
+  }
+  if (options.editImageUrls?.length && !config.supportsEdit) {
+    unsupported(config, "image editing");
+  }
+  if (options.aspect !== void 0 && sizeMode === "none") {
+    unsupported(config, "aspect");
+  }
+  if (options.resolution !== void 0 && options.resolution !== "2K" && !config.supportsResolution) {
+    unsupported(config, "resolution");
+  }
+  if (options.numImages !== void 0 && options.numImages !== 1 && !config.supportsNumImages) {
+    unsupported(config, "numImages");
+  }
+  if (options.background !== void 0 && !config.supportsBackground) {
+    unsupported(config, "background");
+  }
+  if (options.transparent && !(config.supportsBackground || config.supportsOutputFormat)) {
+    unsupported(config, "transparent output");
+  }
+  if (options.inputFidelity !== void 0) {
+    if (!hasEditImages) {
+      throw new Error("inputFidelity requires editImageUrls");
+    }
+    if (config.sizeMode !== "gpt_size" && config.name !== "GPT Image 2") {
+      unsupported(config, "inputFidelity");
+    }
+  }
+  if (options.imageSize !== void 0 && sizeMode !== "gpt_size" && sizeMode !== "image_size_enum") {
+    unsupported(config, "imageSize");
+  }
+  if (options.imagePromptStrength !== void 0 && !config.supportsImagePromptStrength) {
+    unsupported(config, "imagePromptStrength");
+  }
+  if (options.imagePromptStrength !== void 0 && !hasEditImages) {
+    throw new Error("imagePromptStrength requires editImageUrls");
+  }
+  if (options.maskImageUrl !== void 0 && !config.supportsMaskImage) {
+    unsupported(config, "maskImageUrl");
+  }
+  if (options.maskImageUrl !== void 0 && !hasEditImages) {
+    throw new Error("maskImageUrl requires editImageUrls");
+  }
+  if (options.seed !== void 0 && !config.supportsSeed) {
+    unsupported(config, "seed");
+  }
+  if (options.outputFormat !== void 0 && !config.supportsOutputFormat) {
+    unsupported(config, "outputFormat");
+  }
+  if (options.quality !== void 0 && !config.supportsQuality) {
+    unsupported(config, "quality");
+  }
+  if (options.negativePrompt !== void 0 && !config.supportsNegativePrompt) {
+    unsupported(config, "negativePrompt");
+  }
+  if (options.style !== void 0 && !config.supportsStyle) {
+    unsupported(config, "style");
+  }
+  if (options.syncMode !== void 0 && !config.supportsSyncMode) {
+    unsupported(config, "syncMode");
+  }
+  if (options.renderingSpeed !== void 0 && !config.supportsRenderingSpeed) {
+    unsupported(config, "renderingSpeed");
+  }
+  if (options.guidanceScale !== void 0 && !config.supportsGuidanceScale) {
+    unsupported(config, "guidanceScale");
+  }
+  if (options.numInferenceSteps !== void 0 && !config.supportsInferenceSteps) {
+    unsupported(config, "numInferenceSteps");
+  }
+  if (options.raw !== void 0 && !config.supportsRaw) {
+    unsupported(config, "raw");
+  }
+  if (options.enhancePrompt !== void 0 && !config.supportsEnhancePrompt) {
+    unsupported(config, "enhancePrompt");
+  }
+  if (options.safetyTolerance !== void 0 && !config.supportsSafetyTolerance) {
+    unsupported(config, "safetyTolerance");
+  }
+  if (options.enableWebSearch !== void 0 && !config.supportsWebSearch) {
+    unsupported(config, "enableWebSearch");
+  }
+  if (options.enableGoogleSearch !== void 0 && !config.supportsGoogleSearch) {
+    unsupported(config, "enableGoogleSearch");
+  }
+  if (options.enableSafetyChecker !== void 0 && !config.supportsSafetyChecker) {
+    unsupported(config, "enableSafetyChecker");
+  }
+  if (options.limitGenerations !== void 0 && !config.supportsLimitGenerations) {
+    unsupported(config, "limitGenerations");
+  }
+  if (options.thinkingLevel !== void 0 && !config.supportsThinkingLevel) {
+    unsupported(config, "thinkingLevel");
+  }
+  if (options.expandPrompt !== void 0 && !config.supportsExpandPrompt) {
+    unsupported(config, "expandPrompt");
+  }
+}
+function buildGenerateBody(options) {
+  const {
+    prompt,
+    model,
+    aspect = "1:1",
+    resolution = "2K",
+    numImages = 1,
+    background,
+    editImageUrls,
+    enableGoogleSearch,
+    enableSafetyChecker,
+    transparent,
+    inputFidelity,
+    imageSize,
+    imagePromptStrength,
+    limitGenerations,
+    maskImageUrl,
+    seed,
+    outputFormat,
+    quality,
+    negativePrompt,
+    style,
+    syncMode,
+    thinkingLevel,
+    renderingSpeed,
+    guidanceScale,
+    numInferenceSteps,
+    raw,
+    enhancePrompt,
+    safetyTolerance,
+    enableWebSearch,
+    expandPrompt
+  } = options;
+  const config = MODELS[model];
+  if (!config) {
+    throw new Error(`Unknown model: ${model}`);
+  }
+  let endpoint = config.endpoint;
+  const body = { prompt };
+  const hasEditImages = Boolean(editImageUrls?.length);
+  const editImages = editImageUrls ?? [];
+  const explicitAspect = options.aspect !== void 0;
+  const sizeMode = config.sizeMode ?? "aspect_ratio";
+  validateGenerateOptions(options, config, sizeMode, hasEditImages);
+  const normalizedImageSize = normalizeImageSize(imageSize, sizeMode);
+  switch (sizeMode) {
+    case "gpt_size":
+      body.image_size = normalizedImageSize ?? (hasEditImages && !explicitAspect ? "auto" : aspectToGptSize(aspect));
+      break;
+    case "image_size_enum":
+      body.image_size = normalizedImageSize ?? aspectToFalImageSize(aspect);
+      break;
+    case "aspect_ratio":
+      if (config.supportsAspect) {
+        body.aspect_ratio = aspect;
+      }
+      if (config.supportsResolution) {
+        body.resolution = model === "grok-image" ? resolution.toLowerCase() : resolution;
+      }
+      break;
+  }
+  if (config.supportsQuality) {
+    body.quality = quality ?? "high";
+  }
+  if (config.supportsBackground && background) {
+    body.background = background;
+  }
+  if (config.supportsBackground && transparent) {
+    body.background = "transparent";
+  }
+  if (transparent && config.supportsOutputFormat) {
+    body.output_format = "png";
+  }
+  if (syncMode !== void 0 && config.supportsSyncMode) {
+    body.sync_mode = syncMode;
+  }
+  if (seed !== void 0 && config.supportsSeed) {
+    body.seed = seed;
+  }
+  if (outputFormat && config.supportsOutputFormat && !transparent) {
+    if (config.supportedOutputFormats && !config.supportedOutputFormats.includes(outputFormat)) {
+      throw new Error(
+        `${config.name} supports output formats: ${config.supportedOutputFormats.join(", ")}`
+      );
+    }
+    body.output_format = outputFormat;
+  }
+  if (config.supportsRaw && raw !== void 0) {
+    body.raw = raw;
+  }
+  if (config.supportsEnhancePrompt && enhancePrompt !== void 0) {
+    body.enhance_prompt = enhancePrompt;
+  }
+  if (config.supportsImagePromptStrength && imagePromptStrength !== void 0) {
+    body.image_prompt_strength = imagePromptStrength;
+  }
+  if (model === "flux") {
+    if (safetyTolerance) body.safety_tolerance = safetyTolerance;
+  }
+  if (config.supportsGuidanceScale && guidanceScale !== void 0) {
+    body.guidance_scale = guidanceScale;
+  }
+  if (config.supportsInferenceSteps && numInferenceSteps !== void 0) {
+    body.num_inference_steps = numInferenceSteps;
+  }
+  if (config.supportsSafetyTolerance) {
+    if (safetyTolerance) body.safety_tolerance = safetyTolerance;
+  }
+  if (config.supportsWebSearch) {
+    if (enableWebSearch !== void 0) body.enable_web_search = enableWebSearch;
+  }
+  if (config.supportsGoogleSearch) {
+    if (enableGoogleSearch !== void 0) {
+      body.enable_google_search = enableGoogleSearch;
+    }
+  }
+  if (config.supportsSafetyChecker) {
+    if (enableSafetyChecker !== void 0) {
+      body.enable_safety_checker = enableSafetyChecker;
+    }
+  }
+  if (config.supportsLimitGenerations) {
+    if (limitGenerations !== void 0) {
+      body.limit_generations = limitGenerations;
+    }
+  }
+  if (config.supportsThinkingLevel) {
+    if (thinkingLevel) body.thinking_level = thinkingLevel;
+  }
+  if (config.supportsStyle && style) {
+    body.style = style;
+  }
+  if (config.supportsNegativePrompt) {
+    if (negativePrompt) body.negative_prompt = negativePrompt;
+  }
+  if (model === "ideogram") {
+    if (style) body.style = style;
+  }
+  if (config.supportsRenderingSpeed) {
+    if (renderingSpeed) body.rendering_speed = renderingSpeed;
+  }
+  if (config.supportsExpandPrompt) {
+    if (expandPrompt !== void 0) body.expand_prompt = expandPrompt;
+  }
+  if (model === "flux" && hasEditImages) {
+    body.image_url = editImages[0];
+    body.image_prompt_strength = imagePromptStrength ?? 0.5;
+  }
+  if (config.supportsNumImages) {
+    body.num_images = numImages;
+  }
+  if (hasEditImages && sizeMode !== "gpt_size" && model !== "flux") {
+    if (!config.supportsEdit) {
+      throw new Error(`Model ${model} does not support image editing`);
+    }
+    endpoint = config.editEndpoint ?? `${endpoint}/edit`;
+    const editImagesField = config.editImagesField ?? "image_urls";
+    body[editImagesField] = editImagesField === "image_url" ? editImages[0] : editImages;
+    if (model === "gpt2" && inputFidelity) {
+      body.input_fidelity = inputFidelity;
+    }
+  }
+  if (hasEditImages && sizeMode === "gpt_size") {
+    endpoint = config.editEndpoint ?? `${endpoint}/edit`;
+    body.image_urls = editImages;
+    if (inputFidelity) {
+      body.input_fidelity = inputFidelity;
+    }
+  }
+  if (maskImageUrl && config.supportsMaskImage) {
+    body.mask_image_url = maskImageUrl;
+  }
+  return { endpoint, body };
+}
+
+// src/leaderboards.ts
+var IMAGE_TEXT_TO_IMAGE_TOP_20 = {
+  capturedAt: "2026-05-12",
+  source: "https://artificialanalysis.ai/image/leaderboard/text-to-image",
+  entries: [
+    {
+      rank: 1,
+      creator: "OpenAI",
+      model: "GPT Image 2 (high)",
+      elo: 1337,
+      apiPricing: "$211/1k images",
+      isCurrent: true,
+      routableModelId: "gpt2"
+    },
+    {
+      rank: 2,
+      creator: "OpenAI",
+      model: "GPT Image 1.5 (high)",
+      elo: 1268,
+      apiPricing: "$133/1k images",
+      isCurrent: true,
+      routableModelId: "gpt"
+    },
+    {
+      rank: 3,
+      creator: "Google",
+      model: "Nano Banana 2 (Gemini 3.1 Flash Image Preview)",
+      elo: 1263,
+      apiPricing: "$67/1k images",
+      isCurrent: true,
+      routableModelId: "banana2"
+    },
+    {
+      rank: 4,
+      creator: "Sourceful",
+      model: "Riverflow 2.0",
+      elo: 1256,
+      apiPricing: "$150/1k images",
+      isCurrent: true
+    },
+    {
+      rank: 5,
+      creator: "Google",
+      model: "Nano Banana Pro (Gemini 3 Pro Image)",
+      elo: 1220,
+      apiPricing: "$134/1k images",
+      isCurrent: true,
+      routableModelId: "banana"
+    },
+    {
+      rank: 6,
+      creator: "ByteDance Seed",
+      model: "Seedream 4.0",
+      elo: 1198,
+      apiPricing: "$30/1k images",
+      isCurrent: true,
+      routableModelId: "seedream4"
+    },
+    {
+      rank: 7,
+      creator: "Microsoft",
+      model: "MAI-Image-2",
+      elo: 1198,
+      apiPricing: "$50/1k images",
+      isCurrent: true
+    },
+    {
+      rank: 8,
+      creator: "Black Forest Labs",
+      model: "FLUX.2 [max]",
+      elo: 1197,
+      apiPricing: "$70/1k images",
+      isCurrent: true,
+      routableModelId: "flux2-max"
+    },
+    {
+      rank: 9,
+      creator: "Peanut",
+      model: "Peanut (Open Weights Coming Soon)",
+      elo: 1187,
+      apiPricing: "Unavailable",
+      isCurrent: true
+    },
+    {
+      rank: 10,
+      creator: "Black Forest Labs",
+      model: "FLUX.2 [pro]",
+      elo: 1186,
+      apiPricing: "$30/1k images",
+      isCurrent: true,
+      routableModelId: "flux2-pro"
+    },
+    {
+      rank: 11,
+      creator: "Google",
+      model: "Imagen 4 Ultra Preview 0606",
+      elo: 1184,
+      apiPricing: "$60/1k images",
+      isCurrent: false
+    },
+    {
+      rank: 12,
+      creator: "xAI",
+      model: "grok-imagine-image",
+      elo: 1182,
+      apiPricing: "$20/1k images",
+      isCurrent: true,
+      routableModelId: "grok-image"
+    },
+    {
+      rank: 13,
+      creator: "Black Forest Labs",
+      model: "FLUX.2 [flex]",
+      elo: 1182,
+      apiPricing: "$60/1k images",
+      isCurrent: true,
+      routableModelId: "flux2-flex"
+    },
+    {
+      rank: 14,
+      creator: "ImagineArt",
+      model: "ImagineArt 2.0",
+      elo: 1181,
+      apiPricing: "$30/1k images",
+      isCurrent: true
+    },
+    {
+      rank: 15,
+      creator: "Google",
+      model: "Imagen 4 Ultra",
+      elo: 1171,
+      apiPricing: "$60/1k images",
+      isCurrent: true
+    },
+    {
+      rank: 16,
+      creator: "Google",
+      model: "Imagen 4 Preview 0606",
+      elo: 1169,
+      apiPricing: "$40/1k images",
+      isCurrent: false
+    },
+    {
+      rank: 17,
+      creator: "ByteDance Seed",
+      model: "Seedream 4.5",
+      elo: 1167,
+      apiPricing: "$40/1k images",
+      isCurrent: true,
+      routableModelId: "seedream45"
+    },
+    {
+      rank: 18,
+      creator: "Fal",
+      model: "FLUX.2 [dev] Turbo",
+      elo: 1161,
+      apiPricing: "$8/1k images",
+      isCurrent: true
+    },
+    {
+      rank: 19,
+      creator: "Black Forest Labs",
+      model: "FLUX.2 [dev]",
+      elo: 1160,
+      apiPricing: "$12/1k images",
+      isCurrent: true,
+      routableModelId: "flux2-dev"
+    },
+    {
+      rank: 20,
+      creator: "Alibaba",
+      model: "Qwen Image Max 2512",
+      elo: 1158,
+      apiPricing: "$20/1k images",
+      isCurrent: true,
+      routableModelId: "qwen"
+    }
+  ]
+};
+var IMAGE_EDITING_TOP_20 = {
+  capturedAt: "2026-05-12",
+  source: "https://artificialanalysis.ai/image/leaderboard/editing",
+  entries: [
+    {
+      rank: 1,
+      creator: "Sourceful",
+      model: "Riverflow 2.0",
+      elo: 1286,
+      apiPricing: "$150/1k images",
+      isCurrent: true
+    },
+    {
+      rank: 2,
+      creator: "OpenAI",
+      model: "GPT Image 1.5 (high)",
+      elo: 1262,
+      apiPricing: "$133/1k images",
+      isCurrent: true,
+      routableModelId: "gpt"
+    },
+    {
+      rank: 3,
+      creator: "OpenAI",
+      model: "GPT Image 2 (high)",
+      elo: 1249,
+      apiPricing: "$211/1k images",
+      isCurrent: true,
+      routableModelId: "gpt2"
+    },
+    {
+      rank: 4,
+      creator: "Google",
+      model: "Nano Banana Pro (Gemini 3 Pro Image)",
+      elo: 1241,
+      apiPricing: "$134/1k images",
+      isCurrent: true,
+      routableModelId: "banana"
+    },
+    {
+      rank: 5,
+      creator: "Google",
+      model: "Nano Banana 2 (Gemini 3.1 Flash Image Preview)",
+      elo: 1231,
+      apiPricing: "$67/1k images",
+      isCurrent: true,
+      routableModelId: "banana2"
+    },
+    {
+      rank: 6,
+      creator: "Tencent",
+      model: "HunyuanImage 3.0 Instruct (Fal)",
+      elo: 1222,
+      apiPricing: "$90/1k images",
+      isCurrent: true
+    },
+    {
+      rank: 7,
+      creator: "xAI",
+      model: "grok-imagine-image",
+      elo: 1213,
+      apiPricing: "$20/1k images",
+      isCurrent: true,
+      routableModelId: "grok-image"
+    },
+    {
+      rank: 8,
+      creator: "xAI",
+      model: "grok-imagine-image-pro",
+      elo: 1212,
+      apiPricing: "$70/1k images",
+      isCurrent: true
+    },
+    {
+      rank: 9,
+      creator: "KlingAI",
+      model: "Kling Image 3.0 Omni",
+      elo: 1207,
+      apiPricing: "Unavailable",
+      isCurrent: true
+    },
+    {
+      rank: 10,
+      creator: "Black Forest Labs",
+      model: "FLUX.2 [max]",
+      elo: 1206,
+      apiPricing: "$140/1k images",
+      isCurrent: true,
+      routableModelId: "flux2-max"
+    },
+    {
+      rank: 11,
+      creator: "Alibaba",
+      model: "Wan 2.7 Pro",
+      elo: 1200,
+      apiPricing: "Unavailable",
+      isCurrent: true
+    },
+    {
+      rank: 12,
+      creator: "KlingAI",
+      model: "Kling Image 3.0",
+      elo: 1196,
+      apiPricing: "$28/1k images",
+      isCurrent: true
+    },
+    {
+      rank: 13,
+      creator: "KlingAI",
+      model: "Kling Image O1",
+      elo: 1193,
+      apiPricing: "$28/1k images",
+      isCurrent: true
+    },
+    {
+      rank: 14,
+      creator: "Alibaba",
+      model: "Wan 2.6 Image",
+      elo: 1188,
+      apiPricing: "$30/1k images",
+      isCurrent: true
+    },
+    {
+      rank: 15,
+      creator: "Sourceful",
+      model: "Riverflow 1",
+      elo: 1184,
+      apiPricing: "$66/1k images",
+      isCurrent: true
+    },
+    {
+      rank: 16,
+      creator: "ByteDance Seed",
+      model: "Seedream 4.0",
+      elo: 1184,
+      apiPricing: "$30/1k images",
+      isCurrent: true,
+      routableModelId: "seedream4"
+    },
+    {
+      rank: 17,
+      creator: "ByteDance Seed",
+      model: "Seedream 4.5",
+      elo: 1184,
+      apiPricing: "$40/1k images",
+      isCurrent: true,
+      routableModelId: "seedream45"
+    },
+    {
+      rank: 18,
+      creator: "Alibaba",
+      model: "Wan 2.7",
+      elo: 1181,
+      apiPricing: "$26/1k images",
+      isCurrent: true
+    },
+    {
+      rank: 19,
+      creator: "Google",
+      model: "Nano Banana (Gemini 2.5 Flash Image)",
+      elo: 1173,
+      apiPricing: "$39/1k images",
+      isCurrent: true,
+      routableModelId: "gemini"
+    },
+    {
+      rank: 20,
+      creator: "Reve",
+      model: "Reve V1 (December)",
+      elo: 1172,
+      apiPricing: "$40/1k images",
+      isCurrent: true
+    }
+  ]
+};
+var VIDEO_TEXT_TO_VIDEO_TOP_15 = {
+  capturedAt: "2026-05-12",
+  source: "https://artificialanalysis.ai/video/leaderboard/text-to-video",
+  entries: [
+    {
+      rank: 1,
+      creator: "Alibaba-ATH",
+      model: "HappyHorse-1.0",
+      elo: 1354,
+      apiPricing: "$14.40/min"
+    },
+    {
+      rank: 2,
+      creator: "ByteDance Seed",
+      model: "Dreamina Seedance 2.0 720p",
+      elo: 1273,
+      apiPricing: "No API available"
+    },
+    {
+      rank: 3,
+      creator: "KlingAI",
+      model: "Kling 3.0 1080p (Pro)",
+      elo: 1249,
+      apiPricing: "$13.44/min"
+    },
+    {
+      rank: 4,
+      creator: "KlingAI",
+      model: "Kling 3.0 Omni 1080p (Pro)",
+      elo: 1233,
+      apiPricing: "$13.44/min"
+    },
+    {
+      rank: 5,
+      creator: "xAI",
+      model: "grok-imagine-video",
+      elo: 1233,
+      apiPricing: "$4.20/min"
+    },
+    {
+      rank: 6,
+      creator: "Vidu",
+      model: "Vidu Q3 Pro",
+      elo: 1225,
+      apiPricing: "$9.60/min"
+    },
+    {
+      rank: 7,
+      creator: "Video Rebirth",
+      model: "Bach-1.0 Preview",
+      elo: 1224,
+      apiPricing: "$3.00/min"
+    },
+    {
+      rank: 8,
+      creator: "KlingAI",
+      model: "Kling 3.0 Omni 720p (Standard)",
+      elo: 1224,
+      apiPricing: "$10.08/min"
+    },
+    {
+      rank: 9,
+      creator: "PixVerse",
+      model: "PixVerse V6",
+      elo: 1222,
+      apiPricing: "$5.40/min"
+    },
+    {
+      rank: 10,
+      creator: "PixVerse",
+      model: "PixVerse V5.6",
+      elo: 1221,
+      apiPricing: "$9.00/min"
+    },
+    {
+      rank: 11,
+      creator: "Runway",
+      model: "Runway Gen-4.5",
+      elo: 1220,
+      apiPricing: "No API available"
+    },
+    {
+      rank: 12,
+      creator: "Google",
+      model: "Veo 3",
+      elo: 1218,
+      apiPricing: "$12.00/min"
+    },
+    {
+      rank: 13,
+      creator: "KlingAI",
+      model: "Kling 3.0 720p (Standard)",
+      elo: 1215,
+      apiPricing: "$10.08/min"
+    },
+    {
+      rank: 14,
+      creator: "Google",
+      model: "Veo 3.1 Lite",
+      elo: 1214,
+      apiPricing: "$3.00/min"
+    },
+    {
+      rank: 15,
+      creator: "KlingAI",
+      model: "Kling O1 Pro (January)",
+      elo: 1209,
+      apiPricing: "$10.08/min"
+    }
+  ]
+};
+var VIDEO_IMAGE_TO_VIDEO_TOP_15 = {
+  capturedAt: "2026-05-12",
+  source: "https://artificialanalysis.ai/video/leaderboard/image-to-video",
+  entries: [
+    {
+      rank: 1,
+      creator: "Alibaba-ATH",
+      model: "HappyHorse-1.0",
+      elo: 1395,
+      apiPricing: "Coming soon"
+    },
+    {
+      rank: 2,
+      creator: "ByteDance Seed",
+      model: "Dreamina Seedance 2.0 720p",
+      elo: 1348,
+      apiPricing: "No API available"
+    },
+    {
+      rank: 3,
+      creator: "xAI",
+      model: "grok-imagine-video",
+      elo: 1326,
+      apiPricing: "$4.20/min"
+    },
+    {
+      rank: 4,
+      creator: "PixVerse",
+      model: "PixVerse V6",
+      elo: 1322,
+      apiPricing: "$5.40/min"
+    },
+    {
+      rank: 5,
+      creator: "Vidu",
+      model: "Vidu Q3 Pro",
+      elo: 1287,
+      apiPricing: "$9.60/min"
+    },
+    {
+      rank: 6,
+      creator: "KlingAI",
+      model: "Kling 2.5 Turbo 1080p",
+      elo: 1283,
+      apiPricing: "$4.20/min"
+    },
+    {
+      rank: 7,
+      creator: "KlingAI",
+      model: "Kling 3.0 1080p (Pro)",
+      elo: 1280,
+      apiPricing: "$13.44/min"
+    },
+    {
+      rank: 8,
+      creator: "PixVerse",
+      model: "PixVerse V5.6",
+      elo: 1279,
+      apiPricing: "$9.00/min"
+    },
+    {
+      rank: 9,
+      creator: "KlingAI",
+      model: "Kling 3.0 Omni 1080p (Pro)",
+      elo: 1277,
+      apiPricing: "$13.44/min"
+    },
+    {
+      rank: 10,
+      creator: "KlingAI",
+      model: "Kling 2.6 Standard (January)",
+      elo: 1271,
+      apiPricing: "Coming soon"
+    },
+    {
+      rank: 11,
+      creator: "PixVerse",
+      model: "PixVerse V5.5",
+      elo: 1271,
+      apiPricing: "$6.40/min"
+    },
+    {
+      rank: 12,
+      creator: "Google",
+      model: "Veo 3.1 Fast",
+      elo: 1268,
+      apiPricing: "$6.00/min"
+    },
+    {
+      rank: 13,
+      creator: "Runway",
+      model: "Runway Gen-4.5",
+      elo: 1263,
+      apiPricing: "No API available"
+    },
+    {
+      rank: 14,
+      creator: "KlingAI",
+      model: "Kling 3.0 Omni 720p (Standard)",
+      elo: 1263,
+      apiPricing: "$10.08/min"
+    },
+    {
+      rank: 15,
+      creator: "KlingAI",
+      model: "Kling 3.0 720p (Standard)",
+      elo: 1263,
+      apiPricing: "$10.08/min"
+    }
+  ]
+};
+
+// src/server.ts
+var import_neverthrow = require("neverthrow");
+
+// src/tools.ts
+var FAL_EXPLORE_CHECKED_AT = "2026-05-12";
+var FAL_TOOLS = {
+  nsfw: {
+    name: "NSFW Checker",
+    endpoint: "fal-ai/x-ailab/nsfw",
+    task: "vision moderation",
+    category: "moderation",
+    description: "Predict whether one or more images contain NSFW concepts.",
+    inputKind: "images",
+    inputField: "image_urls",
+    outputKeys: ["has_nsfw_concepts"],
+    pricing: "$0.001/image",
+    sourceUrl: "https://fal.ai/models/fal-ai/x-ailab/nsfw"
+  },
+  "topaz-image": {
+    name: "Topaz Image Upscale",
+    endpoint: "fal-ai/topaz/upscale/image",
+    task: "image enhancement",
+    category: "upscale",
+    description: "Professional Topaz image enhancement and upscaling.",
+    inputKind: "image",
+    inputField: "image_url",
+    outputKeys: ["image"],
+    pricing: "$0.08+ by output megapixels",
+    sourceUrl: "https://fal.ai/models/fal-ai/topaz/upscale/image",
+    defaultOptions: {
+      model: "Standard V2",
+      output_format: "jpeg",
+      upscale_factor: 2
+    }
+  },
+  "topaz-video": {
+    name: "Topaz Video Upscale",
+    endpoint: "fal-ai/topaz/upscale/video",
+    task: "video enhancement",
+    category: "upscale",
+    description: "Professional Topaz video enhancement and upscaling.",
+    inputKind: "video",
+    inputField: "video_url",
+    outputKeys: ["video"],
+    pricing: "$0.01-$0.08/sec by output resolution",
+    sourceUrl: "https://fal.ai/models/fal-ai/topaz/upscale/video",
+    defaultOptions: {
+      model: "Proteus",
+      upscale_factor: 2
+    }
+  },
+  "bria-rmbg": {
+    name: "Bria RMBG 2.0",
+    endpoint: "fal-ai/bria/background/remove",
+    task: "image background removal",
+    category: "background",
+    description: "Commercial-safe background removal for images.",
+    inputKind: "image",
+    inputField: "image_url",
+    outputKeys: ["image"],
+    pricing: "$0.02/image",
+    sourceUrl: "https://fal.ai/models/fal-ai/bria/background/remove"
+  },
+  birefnet: {
+    name: "BirefNet Background Removal",
+    endpoint: "fal-ai/birefnet/v2",
+    task: "image background removal",
+    category: "background",
+    description: "High-resolution dichotomous image segmentation and background removal.",
+    inputKind: "image",
+    inputField: "image_url",
+    outputKeys: ["image", "mask_image"],
+    pricing: "$0/compute-second listed by fal",
+    sourceUrl: "https://fal.ai/models/fal-ai/birefnet/v2",
+    defaultOptions: {
+      model: "General Use (Light)",
+      operating_resolution: "1024x1024",
+      output_format: "png",
+      refine_foreground: true
+    }
+  },
+  rembg: {
+    name: "Remove Background",
+    endpoint: "fal-ai/imageutils/rembg",
+    task: "image background removal",
+    category: "background",
+    description: "Generic image background removal utility.",
+    inputKind: "image",
+    inputField: "image_url",
+    outputKeys: ["image"],
+    pricing: "$0/compute-second listed by fal",
+    sourceUrl: "https://fal.ai/models/fal-ai/imageutils/rembg",
+    defaultOptions: {
+      crop_to_bbox: false
+    }
+  },
+  "bria-video-rmbg": {
+    name: "Bria Video Background Removal",
+    endpoint: "bria/video/background-removal",
+    task: "video background removal",
+    category: "background",
+    description: "Remove video backgrounds with configurable output container.",
+    inputKind: "video",
+    inputField: "video_url",
+    outputKeys: ["video"],
+    pricing: "$0.14/sec",
+    sourceUrl: "https://fal.ai/models/bria/video/background-removal",
+    defaultOptions: {
+      background_color: "Black",
+      output_container_and_codec: "webm_vp9",
+      preserve_audio: true
+    }
+  },
+  lineart: {
+    name: "Line Art Preprocessor",
+    endpoint: "fal-ai/image-preprocessors/lineart",
+    task: "image preprocessing",
+    category: "preprocess",
+    description: "Generate line art/control-style edges from an input image.",
+    inputKind: "image",
+    inputField: "image_url",
+    outputKeys: ["image"],
+    pricing: "$0/compute-second listed by fal",
+    sourceUrl: "https://fal.ai/models/fal-ai/image-preprocessors/lineart",
+    defaultOptions: {
+      coarse: false
+    }
+  },
+  "sam-preprocessor": {
+    name: "SAM Preprocessor",
+    endpoint: "fal-ai/image-preprocessors/sam",
+    task: "segmentation preprocessing",
+    category: "preprocess",
+    description: "Generate a SAM segmentation map for ControlNet-style workflows.",
+    inputKind: "image",
+    inputField: "image_url",
+    outputKeys: ["image"],
+    pricing: "$0/compute-second listed by fal",
+    sourceUrl: "https://fal.ai/models/fal-ai/image-preprocessors/sam"
+  },
+  "midas-depth": {
+    name: "MiDaS Depth Estimation",
+    endpoint: "fal-ai/imageutils/depth",
+    task: "depth map",
+    category: "depth",
+    description: "Create MiDaS depth maps from input images.",
+    inputKind: "image",
+    inputField: "image_url",
+    outputKeys: ["image"],
+    pricing: "$0/compute-second listed by fal",
+    sourceUrl: "https://fal.ai/models/fal-ai/imageutils/depth",
+    defaultOptions: {
+      a: Math.PI * 2,
+      bg_th: 0.1
+    }
+  },
+  "midas-preprocessor": {
+    name: "MiDaS Preprocessor",
+    endpoint: "fal-ai/image-preprocessors/midas",
+    task: "depth and normal preprocessing",
+    category: "preprocess",
+    description: "Generate MiDaS depth and normal maps for image workflows.",
+    inputKind: "image",
+    inputField: "image_url",
+    outputKeys: ["depth_map", "normal_map"],
+    pricing: "$0/compute-second listed by fal",
+    sourceUrl: "https://fal.ai/models/fal-ai/image-preprocessors/midas"
+  },
+  "marigold-depth": {
+    name: "Marigold Depth Estimation",
+    endpoint: "fal-ai/imageutils/marigold-depth",
+    task: "depth map",
+    category: "depth",
+    description: "Create depth maps using Marigold depth estimation.",
+    inputKind: "image",
+    inputField: "image_url",
+    outputKeys: ["image"],
+    pricing: "$0/compute-second listed by fal",
+    sourceUrl: "https://fal.ai/models/fal-ai/imageutils/marigold-depth",
+    defaultOptions: {
+      ensemble_size: 10,
+      num_inference_steps: 10
+    }
+  },
+  "depth-anything": {
+    name: "Depth Anything v2 Preprocessor",
+    endpoint: "fal-ai/image-preprocessors/depth-anything/v2",
+    task: "depth preprocessing",
+    category: "preprocess",
+    description: "Generate Depth Anything v2 depth maps from input images.",
+    inputKind: "image",
+    inputField: "image_url",
+    outputKeys: ["image"],
+    pricing: "$0/compute-second listed by fal",
+    sourceUrl: "https://fal.ai/models/fal-ai/image-preprocessors/depth-anything/v2"
+  },
+  "sam2-auto": {
+    name: "SAM 2 Auto Segment",
+    endpoint: "fal-ai/sam2/auto-segment",
+    task: "automatic image segmentation",
+    category: "segmentation",
+    description: "Automatically segment an image into combined and individual masks.",
+    inputKind: "image",
+    inputField: "image_url",
+    outputKeys: ["combined_mask", "individual_masks"],
+    pricing: "$0/compute-second listed by fal",
+    sourceUrl: "https://fal.ai/models/fal-ai/sam2/auto-segment",
+    defaultOptions: {
+      min_mask_region_area: 100,
+      output_format: "png",
+      points_per_side: 32,
+      pred_iou_thresh: 0.88,
+      stability_score_thresh: 0.95
+    }
+  },
+  "sam3-image": {
+    name: "SAM 3 Image",
+    endpoint: "fal-ai/sam-3/image",
+    task: "promptable image segmentation",
+    category: "segmentation",
+    description: "Segment image objects with text, point, or box prompts.",
+    inputKind: "image",
+    inputField: "image_url",
+    outputKeys: ["image", "masks", "metadata", "scores", "boxes"],
+    pricing: "$0.005/request",
+    sourceUrl: "https://fal.ai/models/fal-ai/sam-3/image",
+    defaultOptions: {
+      apply_mask: true,
+      max_masks: 3,
+      output_format: "png"
+    }
+  },
+  "sam3-image-rle": {
+    name: "SAM 3 Image RLE",
+    endpoint: "fal-ai/sam-3/image-rle",
+    task: "promptable image segmentation to RLE",
+    category: "segmentation",
+    description: "Segment image objects and return run-length encoded masks.",
+    inputKind: "image",
+    inputField: "image_url",
+    outputKeys: ["rle_masks", "metadata", "scores", "boxes"],
+    pricing: "$0.005/request",
+    sourceUrl: "https://fal.ai/models/fal-ai/sam-3/image-rle",
+    defaultOptions: {
+      apply_mask: true,
+      max_masks: 3
+    }
+  },
+  "sam3-video": {
+    name: "SAM 3 Video",
+    endpoint: "fal-ai/sam-3/video",
+    task: "promptable video segmentation",
+    category: "segmentation",
+    description: "Segment and track prompted objects across video frames.",
+    inputKind: "video",
+    inputField: "video_url",
+    outputKeys: ["video", "boundingbox_frames_zip"],
+    pricing: "$0.005/16 frames",
+    sourceUrl: "https://fal.ai/models/fal-ai/sam-3/video",
+    defaultOptions: {
+      apply_mask: true,
+      detection_threshold: 0.5,
+      prompt: "person",
+      video_output_type: "X264 (.mp4)"
+    }
+  },
+  "sam3-video-rle": {
+    name: "SAM 3 Video RLE",
+    endpoint: "fal-ai/sam-3/video-rle",
+    task: "promptable video segmentation to RLE",
+    category: "segmentation",
+    description: "Track prompted video objects and return RLE mask data.",
+    inputKind: "video",
+    inputField: "video_url",
+    outputKeys: ["rle_masks", "metadata"],
+    pricing: "$0.005/16 frames",
+    sourceUrl: "https://fal.ai/models/fal-ai/sam-3/video-rle",
+    defaultOptions: {
+      apply_mask: true,
+      detection_threshold: 0.5,
+      prompt: "person"
+    }
+  },
+  "sam3-1-video": {
+    name: "SAM 3.1 Video",
+    endpoint: "fal-ai/sam-3-1/video",
+    task: "multi-object video segmentation",
+    category: "segmentation",
+    description: "SAM 3.1 video segmentation with Object Multiplex tracking for multiple objects.",
+    inputKind: "video",
+    inputField: "video_url",
+    outputKeys: ["video", "boundingbox_frames_zip"],
+    pricing: "fal pricing varies by frame count",
+    sourceUrl: "https://fal.ai/models/fal-ai/sam-3-1/video",
+    defaultOptions: {
+      apply_mask: true,
+      prompt: "person"
+    }
+  },
+  "sam3-3d-objects": {
+    name: "SAM 3D Objects",
+    endpoint: "fal-ai/sam-3/3d-objects",
+    task: "single-image 3D object reconstruction",
+    category: "3d",
+    description: "Reconstruct one or more 3D objects from an image and prompts.",
+    inputKind: "image",
+    inputField: "image_url",
+    outputKeys: [
+      "gaussian_splat",
+      "model_glb",
+      "metadata",
+      "individual_splats",
+      "individual_glbs",
+      "artifacts_zip"
+    ],
+    pricing: "$0.02/generation",
+    sourceUrl: "https://fal.ai/models/fal-ai/sam-3/3d-objects",
+    defaultOptions: {
+      prompt: "car"
+    }
+  },
+  "sam3-3d-body": {
+    name: "SAM 3D Body",
+    endpoint: "fal-ai/sam-3/3d-body",
+    task: "single-image 3D body reconstruction",
+    category: "3d",
+    description: "Reconstruct human body meshes and keypoints from a single image.",
+    inputKind: "image",
+    inputField: "image_url",
+    outputKeys: ["model_glb", "visualization", "meshes", "metadata"],
+    pricing: "$0.015/inference",
+    sourceUrl: "https://fal.ai/models/fal-ai/sam-3/3d-body",
+    defaultOptions: {
+      export_meshes: true,
+      include_3d_keypoints: true,
+      include_mhr_params: true
+    }
+  },
+  "sam3-3d-align": {
+    name: "SAM 3D Align",
+    endpoint: "fal-ai/sam-3/3d-align",
+    task: "3D scene alignment",
+    category: "3d",
+    description: "Align SAM 3D objects and bodies into a shared scene.",
+    inputKind: "image",
+    inputField: "image_url",
+    outputKeys: ["scene_glb", "metadata", "artifacts_zip"],
+    pricing: "fal pricing varies by scene",
+    sourceUrl: "https://fal.ai/models/fal-ai/sam-3/3d-align"
+  }
+};
+var FAL_TOOLS_CHECKED_AT = FAL_EXPLORE_CHECKED_AT;
+var FAL_TOOL_IDS = Object.keys(FAL_TOOLS);
+function isFalToolId(tool) {
+  return Object.hasOwn(FAL_TOOLS, tool);
+}
+function buildFalToolRequest(options) {
+  if (!isFalToolId(options.tool)) {
+    throw new Error(`Unknown fal tool: ${options.tool}`);
+  }
+  const tool = FAL_TOOLS[options.tool];
+  const values = options.inputs ?? (options.input ? [options.input] : []);
+  if (values.length === 0) {
+    throw new Error(`${options.tool} requires input media`);
+  }
+  const mediaValue = tool.inputKind === "images" ? values : values[0];
+  const defaultOptions = "defaultOptions" in tool ? tool.defaultOptions : void 0;
+  const body = {
+    ...defaultOptions,
+    ...options.options,
+    [tool.inputField]: mediaValue
+  };
+  return { endpoint: tool.endpoint, body, tool };
+}
+
+// src/server.ts
+var FAL_BASE_URL = "https://fal.run";
+var FAL_QUEUE_URL = "https://queue.fal.run";
+var FAL_REST_URL = "https://rest.alpha.fal.ai";
+function endpointFromQueueUrl(url, fallback) {
+  if (!url) return fallback;
+  try {
+    const parsed = new URL(url);
+    const match = parsed.pathname.match(/^\/(.+)\/requests\//);
+    return match?.[1] ?? fallback;
+  } catch {
+    return fallback;
+  }
+}
+var MotifServer = class {
+  apiKey;
+  timeout;
+  retries;
+  constructor(config) {
+    if (typeof config === "string") {
+      this.apiKey = config;
+      this.timeout = 12e4;
+      this.retries = 3;
+    } else {
+      this.apiKey = config.apiKey;
+      this.timeout = config.timeout ?? 12e4;
+      this.retries = config.retries ?? 3;
+    }
+    if (!this.apiKey) {
+      throw new MotifError("API key is required", 0);
+    }
+  }
+  /** ─── Synchronous Generation ──────────────────────────────── */
+  /** Generate images synchronously (blocks until fal.ai returns). */
+  async generate(options) {
+    const config = MODELS[options.model];
+    if (config?.useQueue) {
+      return this.generateQueued(options);
+    }
+    const { endpoint, body } = buildGenerateBody(options);
+    const response = await this.request(`${FAL_BASE_URL}/${endpoint}`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+    if (response.isErr()) {
+      return (0, import_neverthrow.err)(response.error);
+    }
+    const data = await response.value.json();
+    return this.normalizeResponse(data);
+  }
+  async generateQueued(options) {
+    const job = await this.submitGeneration(options);
+    if (job.isErr()) {
+      return (0, import_neverthrow.err)(job.error);
+    }
+    const pollIntervalMs = 3e3;
+    const maxAttempts = 160;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const status = await this.getJobStatus(
+        job.value.endpoint,
+        job.value.requestId
+      );
+      if (status.isErr()) {
+        return (0, import_neverthrow.err)(status.error);
+      }
+      if (status.value.status === "completed") {
+        return this.getJobResult(job.value.endpoint, job.value.requestId);
+      }
+      if (status.value.status === "failed") {
+        return (0, import_neverthrow.err)(
+          new MotifError(status.value.error ?? "Queued generation failed", 0)
+        );
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+    return (0, import_neverthrow.err)(new MotifError("Queued generation timed out", 0));
+  }
+  /** ─── Queue-Based Generation ──────────────────────────────── */
+  /** Submit a generation to the fal.ai queue (returns immediately). */
+  async submitGeneration(options) {
+    const { endpoint, body } = buildGenerateBody(options);
+    const response = await this.request(`${FAL_QUEUE_URL}/${endpoint}`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+    if (response.isErr()) {
+      return (0, import_neverthrow.err)(response.error);
+    }
+    const data = await response.value.json();
+    return (0, import_neverthrow.ok)({
+      requestId: data.request_id,
+      endpoint: endpointFromQueueUrl(data.response_url, endpoint),
+      estimatedCost: estimateCost(
+        options.model,
+        options.resolution,
+        options.numImages
+      )
+    });
+  }
+  /** Check the status of a queued generation. */
+  async getJobStatus(endpoint, requestId) {
+    const url = `${FAL_QUEUE_URL}/${endpoint}/requests/${requestId}/status?logs=1`;
+    const response = await this.request(url);
+    if (response.isErr()) {
+      return (0, import_neverthrow.err)(response.error);
+    }
+    const data = await response.value.json();
+    let status;
+    if (data.status === "IN_QUEUE") {
+      status = "queued";
+    } else if (data.status === "IN_PROGRESS") {
+      status = "processing";
+    } else if (data.status === "COMPLETED") {
+      status = "completed";
+    } else if (data.status === "FAILED" || data.status === "ERROR" || data.status === "CANCELED") {
+      status = "failed";
+    } else {
+      return (0, import_neverthrow.err)(new MotifError(`Unknown job status: ${data.status}`, 0));
+    }
+    return (0, import_neverthrow.ok)({
+      status,
+      error: data.error ?? data.detail,
+      queuePosition: data.queue_position,
+      logs: data.logs
+    });
+  }
+  /** Fetch the completed result from the queue. */
+  async getJobResult(endpoint, requestId) {
+    const url = `${FAL_QUEUE_URL}/${endpoint}/requests/${requestId}`;
+    const response = await this.request(url);
+    if (response.isErr()) {
+      return (0, import_neverthrow.err)(response.error);
+    }
+    const data = await response.value.json();
+    return this.normalizeResponse(data);
+  }
+  /** ─── Processing ──────────────────────────────────────────── */
+  /** Upscale an image using clarity or crystal upscaler. */
+  async upscale(options) {
+    const {
+      imageUrl,
+      model = "clarity",
+      scaleFactor,
+      creativity,
+      resemblance,
+      prompt: upscalePrompt,
+      negativePrompt,
+      numInferenceSteps,
+      guidanceScale
+    } = options;
+    const config = MODELS[model];
+    if (!config || config.type !== "utility") {
+      return (0, import_neverthrow.err)(new MotifError(`Invalid upscale model: ${model}`, 0));
+    }
+    const body = { image_url: imageUrl };
+    if (model === "crystal") {
+      if (scaleFactor !== void 0) body.scale_factor = scaleFactor;
+      if (creativity !== void 0) body.creativity = creativity;
+    } else {
+      if (scaleFactor !== void 0) body.upscale_factor = scaleFactor;
+      if (creativity !== void 0) body.creativity = creativity;
+      if (resemblance !== void 0) body.resemblance = resemblance;
+      if (upscalePrompt) body.prompt = upscalePrompt;
+      if (negativePrompt) body.negative_prompt = negativePrompt;
+      if (numInferenceSteps !== void 0)
+        body.num_inference_steps = numInferenceSteps;
+      if (guidanceScale !== void 0) body.guidance_scale = guidanceScale;
+    }
+    const response = await this.request(`${FAL_BASE_URL}/${config.endpoint}`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+    if (response.isErr()) {
+      return (0, import_neverthrow.err)(response.error);
+    }
+    const data = await response.value.json();
+    return this.normalizeResponse(data);
+  }
+  /** Remove the background from an image. */
+  async removeBackground(options) {
+    const {
+      imageUrl,
+      model = "rmbg",
+      variant,
+      operatingResolution,
+      outputFormat,
+      refineForeground,
+      outputMask
+    } = options;
+    const config = MODELS[model];
+    if (!config) {
+      return (0, import_neverthrow.err)(
+        new MotifError(`Invalid background removal model: ${model}`, 0)
+      );
+    }
+    const rbBody = { image_url: imageUrl };
+    if (model === "rmbg") {
+      if (variant) rbBody.model = variant;
+      if (operatingResolution)
+        rbBody.operating_resolution = operatingResolution;
+      if (outputFormat) rbBody.output_format = outputFormat;
+      if (refineForeground !== void 0)
+        rbBody.refine_foreground = refineForeground;
+      if (outputMask !== void 0) rbBody.output_mask = outputMask;
+    }
+    const response = await this.request(`${FAL_BASE_URL}/${config.endpoint}`, {
+      method: "POST",
+      body: JSON.stringify(rbBody)
+    });
+    if (response.isErr()) {
+      return (0, import_neverthrow.err)(response.error);
+    }
+    const data = await response.value.json();
+    return this.normalizeResponse(data);
+  }
+  /** ─── Video Generation ───────────────────────────────────── */
+  /**
+   * Generate a video from an image using Kling v3 Pro.
+   * This uses the queue API since video generation takes 30-120s.
+   * Returns immediately with a job — poll with getJobStatus/getVideoResult.
+   */
+  async submitVideo(options) {
+    const {
+      imageUrl,
+      prompt,
+      duration = 5,
+      generateAudio = true,
+      endImageUrl,
+      negativePrompt,
+      cfgScale
+    } = options;
+    const config = MODELS.kling;
+    if (!config) {
+      return (0, import_neverthrow.err)(new MotifError("Kling video model not found", 0));
+    }
+    const body = {
+      start_image_url: imageUrl,
+      prompt,
+      duration: String(duration),
+      generate_audio: generateAudio
+    };
+    if (endImageUrl) {
+      body.end_image_url = endImageUrl;
+    }
+    if (negativePrompt) body.negative_prompt = negativePrompt;
+    if (cfgScale !== void 0) body.cfg_scale = cfgScale;
+    const response = await this.request(`${FAL_QUEUE_URL}/${config.endpoint}`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+    if (response.isErr()) {
+      return (0, import_neverthrow.err)(response.error);
+    }
+    const data = await response.value.json();
+    return (0, import_neverthrow.ok)({
+      requestId: data.request_id,
+      endpoint: endpointFromQueueUrl(data.response_url, config.endpoint),
+      estimatedCost: estimateVideoCost(duration, generateAudio)
+    });
+  }
+  /** Fetch the completed video result from the queue. */
+  async getVideoResult(endpoint, requestId) {
+    const url = `${FAL_QUEUE_URL}/${endpoint}/requests/${requestId}`;
+    const response = await this.request(url);
+    if (response.isErr()) {
+      return (0, import_neverthrow.err)(response.error);
+    }
+    const data = await response.value.json();
+    if (!data.video) {
+      return (0, import_neverthrow.err)(new MotifError("No video in response", 0));
+    }
+    return (0, import_neverthrow.ok)({
+      url: data.video.url,
+      contentType: data.video.content_type,
+      fileName: data.video.file_name,
+      fileSize: data.video.file_size
+    });
+  }
+  /** ─── File Upload ─────────────────────────────────────────── */
+  /**
+   * Upload a file to fal.ai CDN storage and return the public URL.
+   * Uses the two-step initiate + PUT flow.
+   */
+  async uploadToFalCdn(file, options) {
+    const initiateResponse = await this.request(
+      `${FAL_REST_URL}/storage/upload/initiate?storage_type=fal-cdn-v3`,
+      {
+        method: "POST",
+        body: JSON.stringify({
+          content_type: options.contentType,
+          file_name: options.fileName
+        })
+      }
+    );
+    if (initiateResponse.isErr()) {
+      return (0, import_neverthrow.err)(initiateResponse.error);
+    }
+    const { file_url, upload_url } = await initiateResponse.value.json();
+    let putResponse;
+    try {
+      const body = Buffer.from(
+        file instanceof Uint8Array ? file : new Uint8Array(file)
+      );
+      putResponse = await fetch(upload_url, {
+        method: "PUT",
+        headers: { "Content-Type": options.contentType },
+        body
+      });
+    } catch (error) {
+      return (0, import_neverthrow.err)(
+        new MotifError(
+          `Upload PUT failed: ${error instanceof Error ? error.message : String(error)}`,
+          0
+        )
+      );
+    }
+    if (!putResponse.ok) {
+      return (0, import_neverthrow.err)(
+        new MotifError(
+          `Upload PUT failed: ${putResponse.status}`,
+          putResponse.status
+        )
+      );
+    }
+    return (0, import_neverthrow.ok)(file_url);
+  }
+  /** ─── Utilities ───────────────────────────────────────────── */
+  /** Run a registered fal utility/tool endpoint. */
+  async runTool(options) {
+    let request;
+    try {
+      request = buildFalToolRequest(options);
+    } catch (error) {
+      return (0, import_neverthrow.err)(
+        new MotifError(
+          error instanceof Error ? error.message : String(error),
+          0
+        )
+      );
+    }
+    const response = await this.request(`${FAL_BASE_URL}/${request.endpoint}`, {
+      method: "POST",
+      body: JSON.stringify(request.body)
+    });
+    if (response.isErr()) {
+      return (0, import_neverthrow.err)(response.error);
+    }
+    return (0, import_neverthrow.ok)(await response.value.json());
+  }
+  /** Estimate cost for a generation (no API call). */
+  estimateCost(model, resolution, numImages) {
+    return estimateCost(model, resolution, numImages);
+  }
+  /** Build the fal.ai request body without sending it. */
+  buildRequestBody(options) {
+    return buildGenerateBody(options);
+  }
+  /** Model registry. */
+  get models() {
+    return MODELS;
+  }
+  /** Generation model keys. */
+  get generationModels() {
+    return GENERATION_MODELS;
+  }
+  /** Utility model keys. */
+  get utilityModels() {
+    return UTILITY_MODELS;
+  }
+  /** Registered fal utility/tool endpoints. */
+  get tools() {
+    return FAL_TOOLS;
+  }
+  /** ─── Private ─────────────────────────────────────────────── */
+  /** Authenticated fetch to fal.ai APIs with retry logic. */
+  async request(url, options = {}) {
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.retries; attempt++) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      try {
+        const response = await fetch(url, {
+          ...options,
+          signal: controller.signal,
+          headers: {
+            Authorization: `Key ${this.apiKey}`,
+            "Content-Type": "application/json",
+            ...options.headers
+          }
+        });
+        clearTimeout(timeoutId);
+        if ((response.status === 429 || response.status >= 500) && attempt < this.retries) {
+          const delay = 1e3 * 2 ** attempt;
+          await new Promise((r) => setTimeout(r, delay));
+          continue;
+        }
+        if (!response.ok) {
+          const text = await response.text();
+          return (0, import_neverthrow.err)(
+            new MotifError(
+              `Request failed: ${response.status} ${text}`,
+              response.status
+            )
+          );
+        }
+        return (0, import_neverthrow.ok)(response);
+      } catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof MotifError) {
+          return (0, import_neverthrow.err)(error);
+        }
+        lastError = new MotifError(
+          error instanceof Error ? error.message : String(error),
+          0
+        );
+        if (attempt < this.retries) {
+          const delay = 1e3 * 2 ** attempt;
+          await new Promise((r) => setTimeout(r, delay));
+        }
+      }
+    }
+    return (0, import_neverthrow.err)(lastError ?? new MotifError("Request failed after retries", 0));
+  }
+  /**
+   * Normalize fal.ai responses.
+   * Some APIs return `{ image: {...} }` instead of `{ images: [...] }`.
+   */
+  normalizeResponse(data) {
+    const obj = data;
+    if ("detail" in obj) {
+      return (0, import_neverthrow.err)(
+        new MotifError(obj.detail, 0, "FAL_ERROR")
+      );
+    }
+    if ("image" in obj && !("images" in obj)) {
+      return (0, import_neverthrow.ok)({
+        images: [obj.image],
+        seed: obj.seed,
+        prompt: obj.prompt
+      });
+    }
+    return (0, import_neverthrow.ok)(obj);
+  }
+};
+var MotifError = class extends Error {
+  status;
+  code;
+  constructor(message, status, code) {
+    super(message);
+    this.name = "MotifError";
+    this.status = status;
+    this.code = code;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ASPECT_RATIOS,
+  FAL_TOOLS,
+  FAL_TOOLS_CHECKED_AT,
+  FAL_TOOL_IDS,
+  FORMAT_PRESETS,
+  GENERATION_MODELS,
+  IDEOGRAM_STYLES,
+  IMAGE_EDITING_TOP_20,
+  IMAGE_TEXT_TO_IMAGE_TOP_20,
+  MODELS,
+  MotifError,
+  MotifServer,
+  RECRAFT_STYLES,
+  RESOLUTIONS,
+  UTILITY_MODELS,
+  VIDEO_IMAGE_TO_VIDEO_TOP_15,
+  VIDEO_MODELS,
+  VIDEO_TEXT_TO_VIDEO_TOP_15,
+  aspectToFalImageSize,
+  aspectToGptSize,
+  buildFalToolRequest,
+  buildGenerateBody,
+  err,
+  estimateCost,
+  estimateVideoCost,
+  getFalKeyFromEnv,
+  isFalToolId,
+  motifEnvSchema,
+  ok,
+  parseMotifEnv
+});