@shop-os/modelkit 0.1.11 → 0.2.2

package/dist/catalog.cjs

@@ -20,7 +20,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/catalog-entry.ts
 var catalog_entry_exports = {};
 __export(catalog_entry_exports, {
+  ADAPTER_IDS: () => ADAPTER_IDS,
   Catalog: () => Catalog,
+  CatalogModelSchema: () => CatalogModelSchema,
+  CatalogSchema: () => CatalogSchema,
   IMAGE_MODELS: () => IMAGE_MODELS,
   MODELS: () => MODELS,
   ModelKitError: () => ModelKitError,
@@ -28,7 +31,11 @@ __export(catalog_entry_exports, {
   TEXT_MODELS: () => TEXT_MODELS,
   VIDEO_MODELS: () => VIDEO_MODELS,
   isModelKitError: () => isModelKitError,
+  liveCatalog: () => liveCatalog,
+  liveState: () => liveState,
   nearestAspectRatio: () => nearestAspectRatio,
+  primeCatalog: () => primeCatalog,
+  resetLiveCatalog: () => resetLiveCatalog,
   resolveAudioOptions: () => resolveAudioOptions,
   resolveImageOptions: () => resolveImageOptions,
   resolveOptions: () => resolveOptions,
@@ -131,6 +138,14 @@ var Catalog = class _Catalog {
       ...rows
     ]);
   }
+  /** Atomically swap every row. Builds the maps first so a bad batch throws before anything changes. */
+  replace(rows) {
+    const next = new _Catalog(rows);
+    this.byId.clear();
+    this.byAlias.clear();
+    for (const [id, model] of next.byId) this.byId.set(id, model);
+    for (const [alias, id] of next.byAlias) this.byAlias.set(alias, id);
+  }
 };
 
 // src/catalog/image.ts
@@ -148,7 +163,7 @@ var GEMINI_RATIOS = [
   "5:4",
   "adaptive"
 ];
-function geminiImage(id, label, aliases, sizes, display, exposure) {
+function geminiImage(id, label, aliases, sizes, display, exposure, references) {
   const model = {
     id,
     aliases,
@@ -161,7 +176,8 @@ function geminiImage(id, label, aliases, sizes, display, exposure) {
     constraints: {
       aspectRatios: [...GEMINI_RATIOS],
       sizes,
-      supports: ["safetySettings", "temperature"]
+      supports: ["safetySettings", "temperature"],
+      ...references ? { references } : {}
     },
     defaults: { size: "1K", aspectRatio: "1:1" },
     usage: { ...IMAGE_USAGE, slug: "gemini" },
@@ -181,7 +197,8 @@ var IMAGE_MODELS = [
       description: "Create stunning, production-quality visuals with exceptional realism, detail, and typography. Best for campaigns, e-commerce, product photography, and hero creatives.",
       logo: "https://d31vvfpk2ppdyq.cloudfront.net/assets/image/192485d2-a76a-4657-9c06-930b2c70badd_compressed.png"
     },
-    "catalog"
+    "catalog",
+    { images: 14 }
   ),
   geminiImage(
     "gemini-3.1-flash-image-preview",
@@ -194,7 +211,8 @@ var IMAGE_MODELS = [
       description: "Generate high-quality images at speed. Perfect for brainstorming, moodboards, concept testing, creative exploration, and large batch workflows.",
       logo: "https://d31vvfpk2ppdyq.cloudfront.net/assets/image/192485d2-a76a-4657-9c06-930b2c70badd_compressed.png"
     },
-    "catalog"
+    "catalog",
+    { images: 14 }
   ),
   geminiImage(
     "gemini-3.1-flash-lite-image",
@@ -206,14 +224,15 @@ var IMAGE_MODELS = [
       description: "The fastest and most affordable image model. Ideal for rapid drafts, bulk exploration, and iterative concept testing at 1K resolution.",
       logo: "https://d31vvfpk2ppdyq.cloudfront.net/assets/image/192485d2-a76a-4657-9c06-930b2c70badd_compressed.png"
     },
-    "catalog"
+    "catalog",
+    { images: 14 }
   ),
   // trigger-workflows validates 1K only; pricing seeds 2K/4K rows so allow all three.
   geminiImage(
     "gemini-2.5-flash-image",
     "Gemini 2.5 Flash Image",
     [],
-    ["1K", "2K", "4K"],
+    ["1K"],
     {
       provider: "google",
       description: "Nano Banana (legacy Gemini 2.5 Flash Image) native image generation and editing model for high-volume, low-latency creative workflows."
@@ -244,7 +263,7 @@ var IMAGE_MODELS = [
       sizes: ["1K", "2K", "4K"],
       qualityOptions: ["auto", "low", "medium", "high"],
       references: { images: 16 },
-      supports: ["quality", "count"]
+      supports: ["quality", "count", "outputFormat"]
     },
     defaults: { size: "1K", aspectRatio: "adaptive", quality: "auto" },
     usage: { ...IMAGE_USAGE, slug: "gpt" },
@@ -264,7 +283,7 @@ var IMAGE_MODELS = [
     adapter: "openai-image",
     providerModelId: "gpt-image-2.5-sunburst",
     lifecycle: "active",
-    exposure: "internal",
+    exposure: "catalog",
     constraints: {
       exactSizes: {
         "1:1": "1024x1024",
@@ -277,9 +296,9 @@ var IMAGE_MODELS = [
       },
       aspectRatios: ["1:1", "3:2", "2:3", "16:9", "9:16", "4:5", "5:4", "adaptive"],
       sizes: ["1K", "2K", "4K"],
-      qualityOptions: ["auto", "low", "medium", "high"],
+      qualityOptions: ["auto", "low", "medium", "high", "xhigh", "max"],
       references: { images: 16 },
-      supports: ["quality", "count"]
+      supports: ["quality", "count", "outputFormat"]
     },
     defaults: { size: "1K", aspectRatio: "adaptive", quality: "auto" },
     usage: { ...IMAGE_USAGE },
@@ -298,7 +317,7 @@ var IMAGE_MODELS = [
     adapter: "openai-image",
     providerModelId: "gpt-image-2.5-flare",
     lifecycle: "active",
-    exposure: "internal",
+    exposure: "catalog",
     constraints: {
       exactSizes: {
         "1:1": "1024x1024",
@@ -311,9 +330,9 @@ var IMAGE_MODELS = [
       },
       aspectRatios: ["1:1", "3:2", "2:3", "16:9", "9:16", "4:5", "5:4", "adaptive"],
       sizes: ["1K", "2K", "4K"],
-      qualityOptions: ["auto", "low", "medium", "high"],
+      qualityOptions: ["auto", "low", "medium", "high", "xhigh", "max"],
       references: { images: 16 },
-      supports: ["quality", "count"]
+      supports: ["quality", "count", "outputFormat"]
     },
     defaults: { size: "1K", aspectRatio: "adaptive", quality: "auto" },
     usage: { ...IMAGE_USAGE },
@@ -343,8 +362,6 @@ var IMAGE_MODELS = [
         "2:3",
         "3:4",
         "9:16",
-        "4:5",
-        "5:4",
         "9:21",
         "adaptive"
       ],
@@ -376,7 +393,7 @@ var IMAGE_MODELS = [
       references: { images: 10 },
       // Ark's Images API has no output-format, quality or count field; only
       // the seed is forwarded, so anything else must warn, not vanish.
-      supports: ["seed"]
+      supports: ["seed", "outputFormat"]
     },
     defaults: { size: "1K", aspectRatio: "1:1" },
     usage: { ...IMAGE_USAGE },
@@ -412,7 +429,7 @@ var IMAGE_MODELS = [
         "21:9",
         "9:21"
       ],
-      sizes: ["1K", "2K", "4K"],
+      sizes: ["2K", "4K"],
       references: { images: 10 },
       supports: ["seed"]
     },
@@ -464,7 +481,7 @@ var IMAGE_MODELS = [
       aspectRatios: ["1:1", "2:3", "3:2", "4:3", "3:4", "4:5", "5:4", "9:16", "16:9", "21:9"],
       sizes: ["1K", "2K", "4K"],
       requires: ["references"],
-      supports: ["seed"]
+      supports: []
     },
     defaults: { size: "1K", aspectRatio: "1:1" },
     usage: { ...IMAGE_USAGE },
@@ -489,7 +506,7 @@ var IMAGE_MODELS = [
       aspectRatios: ["1:1", "2:3", "3:4", "4:3", "9:16", "16:9", "21:9"],
       sizes: ["1K"],
       requires: ["references"],
-      supports: ["seed"]
+      supports: []
     },
     defaults: { size: "1K", aspectRatio: "1:1" },
     usage: { ...IMAGE_USAGE },
@@ -541,7 +558,6 @@ var IMAGE_MODELS = [
       aspectRatios: ["1:1", "16:9", "9:16", "4:3", "3:4", "3:2", "2:3"],
       sizes: [],
       references: { images: 1 },
-      requires: ["references"],
       supports: []
     },
     defaults: { aspectRatio: "1:1" },
@@ -1260,7 +1276,7 @@ var VIDEO_MODELS = [
       resolutions: ["720p", "1080p", "4k"],
       durations: [8],
       references: { images: 3 },
-      supports: ["lastFrame"]
+      supports: ["lastFrame", "seed"]
     },
     defaults: { durationSeconds: 8, resolution: "720p", aspectRatio: "16:9" },
     usage: { ...VIDEO_USAGE, slug: "veo" },
@@ -1288,9 +1304,9 @@ var VIDEO_MODELS = [
     constraints: {
       aspectRatios: [...OMNI_RATIOS],
       resolutions: ["720p", "1080p", "4k"],
-      durations: [4, 8],
+      durations: [4, 6, 8],
       references: { images: 3 },
-      supports: ["lastFrame"]
+      supports: ["lastFrame", "seed"]
     },
     defaults: { durationSeconds: 8, resolution: "720p", aspectRatio: "16:9" },
     usage: { ...VIDEO_USAGE },
@@ -1317,9 +1333,8 @@ var VIDEO_MODELS = [
     constraints: {
       aspectRatios: [...OMNI_RATIOS],
       resolutions: ["720p", "1080p"],
-      durations: [4, 8],
-      references: { images: 3 },
-      supports: ["lastFrame"]
+      durations: [4, 6, 8],
+      supports: ["lastFrame", "seed"]
     },
     defaults: { durationSeconds: 8, resolution: "720p", aspectRatio: "16:9" },
     usage: { ...VIDEO_USAGE },
@@ -1351,7 +1366,7 @@ var VIDEO_MODELS = [
       // reference clip keeps its own framing.
       aspectRatios: [...OMNI_RATIOS],
       durations: [3, 4, 5, 6, 7, 8, 9, 10],
-      references: { images: 6, videos: 1 },
+      references: { images: 6, videos: 3 },
       supports: []
     },
     defaults: {},
@@ -1377,7 +1392,7 @@ var VIDEO_MODELS = [
       aspectRatios: [...OMNI_RATIOS],
       resolutions: ["360p", "720p", "1080p", "4k"],
       durations: [3, 4, 5, 6, 7, 8, 9, 10],
-      references: { images: 6, videos: 1 },
+      references: { images: 6, videos: 3 },
       supports: []
     },
     defaults: {},
@@ -1406,7 +1421,7 @@ var VIDEO_MODELS = [
       durations: { min: 4, max: 15 },
       durationPresets: [4, 6, 8, 10, 12, 15],
       references: { images: 9, videos: 3, audios: 3, audioOnly: false },
-      ratioIgnoredWith: ["firstFrame"],
+      ratioIgnoredWith: ["firstFrame", "sourceVideo"],
       supports: ["generateAudio", "seed", "lastFrame", "watermark"]
     },
     defaults: {
@@ -1438,7 +1453,7 @@ var VIDEO_MODELS = [
       resolutions: ["480p", "720p"],
       durations: { min: 4, max: 15 },
       references: { images: 9, videos: 3, audios: 3, audioOnly: false },
-      ratioIgnoredWith: ["firstFrame"],
+      ratioIgnoredWith: ["firstFrame", "sourceVideo"],
       supports: ["generateAudio", "seed", "lastFrame", "watermark"]
     },
     defaults: {
@@ -1471,7 +1486,7 @@ var VIDEO_MODELS = [
       resolutions: ["480p", "720p", "1080p"],
       durations: { min: 4, max: 30 },
       references: { images: 30, videos: 10, audios: 10 },
-      ratioIgnoredWith: ["firstFrame"],
+      ratioIgnoredWith: ["firstFrame", "sourceVideo"],
       supports: ["generateAudio", "seed", "lastFrame", "watermark"]
     },
     defaults: {
@@ -1590,18 +1605,7 @@ var VIDEO_MODELS = [
     lifecycle: "active",
     exposure: "catalog",
     constraints: {
-      aspectRatios: [
-        "1:1",
-        "16:9",
-        "9:16",
-        "4:3",
-        "3:4",
-        "3:2",
-        "2:3",
-        "21:9",
-        "4:5",
-        "adaptive"
-      ],
+      aspectRatios: [...KLING_RATIOS],
       resolutions: ["720p", "1080p"],
       durations: { min: 3, max: 15 },
       references: { images: 7 },
@@ -1821,6 +1825,397 @@ var MODELS = [
   ...OTHER_MODELS
 ];
 
+// src/catalog/schema.ts
+var import_zod = require("zod");
+var ADAPTER_IDS = [
+  "ai-sdk-text",
+  "google-image",
+  "openai-image",
+  "google-genai",
+  "ark",
+  "fal",
+  "replicate",
+  "prodia",
+  "higgsfield",
+  "xai-video"
+];
+var ModelTypeSchema = import_zod.z.enum(["text", "image", "video", "audio", "upscale", "bg-remove"]);
+var LifecycleSchema = import_zod.z.enum(["active", "deprecated", "retired"]);
+var AdapterSchema = import_zod.z.enum(ADAPTER_IDS);
+var AspectRatioSchema = import_zod.z.enum([
+  "1:1",
+  "16:9",
+  "9:16",
+  "4:3",
+  "3:4",
+  "3:2",
+  "2:3",
+  "4:5",
+  "5:4",
+  "21:9",
+  "9:21",
+  "97:30",
+  "adaptive"
+]);
+var ImageSizeSchema = import_zod.z.enum(["512", "1K", "2K", "4K"]);
+var VideoResolutionSchema = import_zod.z.enum(["360p", "480p", "720p", "768p", "1080p", "2k", "4k"]);
+var ImageQualitySchema = import_zod.z.enum(["auto", "low", "medium", "high", "xhigh", "max"]);
+var OutputFormatSchema = import_zod.z.enum(["png", "jpeg", "webp"]);
+var RequiredInputSchema = import_zod.z.enum(["firstFrame", "sourceVideo", "references"]);
+var SupportedOptionSchema = import_zod.z.enum([
+  "seed",
+  "quality",
+  "negativePrompt",
+  "cfgScale",
+  "generateAudio",
+  "promptExpansion",
+  "lastFrame",
+  "count",
+  "outputFormat",
+  "scaleFactor",
+  "safetySettings",
+  "temperature",
+  "upscale",
+  "watermark",
+  "safetyChecker",
+  "instrumental"
+]);
+var UsageUnitSchema = import_zod.z.enum([
+  "tokens",
+  "images",
+  "seconds",
+  "reported_cost_usd",
+  "compute_seconds"
+]);
+var PricingKindSchema = import_zod.z.enum(["token", "image_size", "video_per_second", "flat"]);
+var ProviderOptionValueSchema = import_zod.z.lazy(
+  () => import_zod.z.union([
+    import_zod.z.string(),
+    import_zod.z.number(),
+    import_zod.z.boolean(),
+    import_zod.z.array(ProviderOptionValueSchema),
+    import_zod.z.record(import_zod.z.string(), ProviderOptionValueSchema)
+  ])
+);
+var ProviderOptionsSchema = import_zod.z.record(import_zod.z.string(), import_zod.z.record(import_zod.z.string(), ProviderOptionValueSchema));
+var ReferenceLimitsSchema = import_zod.z.looseObject({
+  images: import_zod.z.number().optional(),
+  videos: import_zod.z.number().optional(),
+  audios: import_zod.z.number().optional(),
+  total: import_zod.z.number().optional(),
+  audioOnly: import_zod.z.boolean().optional()
+});
+var ModelConstraintsSchema = import_zod.z.looseObject({
+  aspectRatios: import_zod.z.array(AspectRatioSchema).optional(),
+  sizes: import_zod.z.array(ImageSizeSchema).optional(),
+  resolutions: import_zod.z.array(VideoResolutionSchema).optional(),
+  durations: import_zod.z.union([import_zod.z.looseObject({ min: import_zod.z.number(), max: import_zod.z.number() }), import_zod.z.array(import_zod.z.number())]).optional(),
+  durationPresets: import_zod.z.array(import_zod.z.number()).optional(),
+  qualityOptions: import_zod.z.array(import_zod.z.string()).optional(),
+  exactSizes: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional(),
+  references: ReferenceLimitsSchema.optional(),
+  requires: import_zod.z.array(RequiredInputSchema).optional(),
+  supports: import_zod.z.array(SupportedOptionSchema).optional(),
+  ratioIgnoredWith: import_zod.z.array(import_zod.z.enum(["firstFrame", "sourceVideo"])).optional()
+});
+var MediaRefSchema = import_zod.z.union([
+  import_zod.z.looseObject({ url: import_zod.z.string(), label: import_zod.z.string().optional() }),
+  import_zod.z.looseObject({
+    bytes: import_zod.z.instanceof(Uint8Array),
+    mime: import_zod.z.string(),
+    label: import_zod.z.string().optional()
+  })
+]);
+var ImageSafetySettingSchema = import_zod.z.looseObject({ category: import_zod.z.string(), threshold: import_zod.z.string() });
+var UpscaleOptionsSchema = import_zod.z.looseObject({
+  enhanceModel: import_zod.z.string().optional(),
+  subjectDetection: import_zod.z.string().optional(),
+  faceEnhancement: import_zod.z.boolean().optional(),
+  faceEnhancementCreativity: import_zod.z.number().optional(),
+  faceEnhancementStrength: import_zod.z.number().optional()
+});
+var DefaultsSchema = import_zod.z.looseObject({
+  references: import_zod.z.array(MediaRefSchema).optional(),
+  aspectRatio: AspectRatioSchema.optional(),
+  size: ImageSizeSchema.optional(),
+  exactSize: import_zod.z.string().optional(),
+  quality: ImageQualitySchema.optional(),
+  seed: import_zod.z.number().optional(),
+  count: import_zod.z.number().optional(),
+  outputFormat: OutputFormatSchema.optional(),
+  scaleFactor: import_zod.z.number().optional(),
+  safetySettings: import_zod.z.array(ImageSafetySettingSchema).optional(),
+  temperature: import_zod.z.number().optional(),
+  upscale: UpscaleOptionsSchema.optional(),
+  firstFrame: MediaRefSchema.optional(),
+  lastFrame: MediaRefSchema.optional(),
+  sourceVideo: MediaRefSchema.optional(),
+  referenceImages: import_zod.z.array(MediaRefSchema).optional(),
+  referenceVideos: import_zod.z.array(MediaRefSchema).optional(),
+  referenceAudios: import_zod.z.array(MediaRefSchema).optional(),
+  resolution: VideoResolutionSchema.optional(),
+  durationSeconds: import_zod.z.number().optional(),
+  generateAudio: import_zod.z.boolean().optional(),
+  negativePrompt: import_zod.z.string().optional(),
+  cfgScale: import_zod.z.number().optional(),
+  promptExpansion: import_zod.z.enum(["fast", "balanced", "quality"]).optional(),
+  watermark: import_zod.z.boolean().optional(),
+  safetyChecker: import_zod.z.boolean().optional(),
+  mode: import_zod.z.enum(["standard", "pro"]).optional(),
+  instrumental: import_zod.z.boolean().optional()
+});
+var CatalogDisplaySchema = import_zod.z.looseObject({
+  provider: import_zod.z.string(),
+  description: import_zod.z.string(),
+  logo: import_zod.z.string().optional(),
+  costTier: import_zod.z.union([import_zod.z.literal(1), import_zod.z.literal(2), import_zod.z.literal(3)]).optional(),
+  recommended: import_zod.z.boolean().optional(),
+  sortOrder: import_zod.z.number().optional(),
+  chat: import_zod.z.looseObject({
+    providerOptions: ProviderOptionsSchema.optional(),
+    temperature: import_zod.z.number().optional()
+  }).optional()
+});
+var CatalogCapabilitiesSchema = import_zod.z.looseObject({
+  acceptsSourceVideo: import_zod.z.boolean().optional(),
+  framesExcludeReferences: import_zod.z.boolean().optional(),
+  reasoning: import_zod.z.boolean().optional(),
+  vision: import_zod.z.boolean().optional(),
+  contextWindow: import_zod.z.number().optional()
+});
+var CatalogModelSchemaBase = import_zod.z.looseObject({
+  id: import_zod.z.string().min(1),
+  aliases: import_zod.z.array(import_zod.z.string()).default([]),
+  label: import_zod.z.string().min(1),
+  type: ModelTypeSchema,
+  adapter: AdapterSchema,
+  providerModelId: import_zod.z.string().min(1),
+  lifecycle: LifecycleSchema,
+  replacedBy: import_zod.z.string().optional(),
+  exposure: import_zod.z.enum(["catalog", "internal"]),
+  constraints: ModelConstraintsSchema,
+  defaults: DefaultsSchema,
+  providerOptions: ProviderOptionsSchema.optional(),
+  usage: import_zod.z.looseObject({
+    unit: UsageUnitSchema,
+    slug: import_zod.z.string().optional(),
+    providerLabel: import_zod.z.string().optional()
+  }),
+  pricingKind: PricingKindSchema,
+  display: CatalogDisplaySchema.optional(),
+  capabilities: CatalogCapabilitiesSchema.optional()
+}).superRefine((row, ctx) => {
+  if (row.lifecycle === "active" && !row.display) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["display"],
+      message: "active rows need display"
+    });
+  }
+  if (row.lifecycle === "active" && row.type === "text" && !row.capabilities?.contextWindow) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["capabilities", "contextWindow"],
+      message: "active text rows need contextWindow"
+    });
+  }
+  if (row.replacedBy !== void 0 && row.replacedBy === row.id) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["replacedBy"],
+      message: "replacedBy must not equal id"
+    });
+  }
+});
+var CatalogModelSchema = CatalogModelSchemaBase;
+var CatalogSchema = import_zod.z.array(CatalogModelSchemaBase).superRefine((rows, ctx) => {
+  const seenIds = /* @__PURE__ */ new Map();
+  rows.forEach((row, index) => {
+    if (seenIds.has(row.id)) {
+      ctx.addIssue({
+        code: "custom",
+        path: [index, "id"],
+        message: `Duplicate model id "${row.id}"`
+      });
+    } else {
+      seenIds.set(row.id, index);
+    }
+  });
+  const seenAliases = /* @__PURE__ */ new Map();
+  rows.forEach((row, index) => {
+    row.aliases.forEach((alias, aliasIndex) => {
+      const path = [index, "aliases", aliasIndex];
+      if (alias === row.id || seenIds.has(alias)) {
+        ctx.addIssue({
+          code: "custom",
+          path,
+          message: `Alias "${alias}" collides with a model id`
+        });
+        return;
+      }
+      if (seenAliases.has(alias)) {
+        ctx.addIssue({
+          code: "custom",
+          path,
+          message: `Duplicate alias "${alias}"`
+        });
+      } else {
+        seenAliases.set(alias, index);
+      }
+    });
+  });
+});
+
+// src/catalog/live.ts
+var KEY = /* @__PURE__ */ Symbol.for("@shop-os/modelkit/live-catalog");
+var store = globalThis;
+var liveState = store[KEY] ??= {
+  catalog: new Catalog(MODELS),
+  memo: void 0,
+  timer: void 0,
+  revision: void 0,
+  origin: "snapshot"
+};
+var liveCatalog = liveState.catalog;
+
+// src/catalog/load.ts
+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 };
+}
+function describeError(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function parseEnvelope(json) {
+  if (typeof json !== "object" || json === null || !("rows" in json)) {
+    throw new Error("invalid catalog response: missing rows");
+  }
+  const rows = CatalogSchema.parse(json.rows);
+  const rev = json.revision;
+  if (typeof rev === "string") return { rows, revision: rev };
+  return { rows };
+}
+function logPrimed(logger, result) {
+  const { origin: loggedOrigin, rowCount: loggedCount, revision: loggedRevision } = result;
+  logger.info("[modelkit] catalog primed", {
+    origin: loggedOrigin,
+    rowCount: loggedCount,
+    revision: loggedRevision
+  });
+}
+async function fetchRemote(source, logger) {
+  const fetchImpl = source.fetch ?? globalThis.fetch;
+  const headers = authHeaders(source.auth);
+  if (liveState.revision !== void 0) headers["If-None-Match"] = `"${liveState.revision}"`;
+  const res = await fetchImpl(`${source.baseUrl}/models/catalog`, {
+    headers,
+    signal: AbortSignal.timeout(source.timeoutMs ?? 1e4)
+  });
+  if (res.status === 304) return { kept: true };
+  if (!res.ok) throw new Error(`catalog fetch failed with status ${res.status}`);
+  const json = await res.json();
+  const { rows, revision: rev } = parseEnvelope(json);
+  if (rev === void 0) return { rows, fromCache: false };
+  return { rows, revision: rev, fromCache: false };
+}
+async function writeCache(source, logger, rows, rev) {
+  if (!source.cache) return;
+  try {
+    await source.cache.set(JSON.stringify({ rows, revision: rev }));
+  } catch (err) {
+    logger.warn("[modelkit] catalog cache write failed", err);
+  }
+}
+async function prime(source, logger) {
+  try {
+    const fetched = await fetchRemote(source, logger);
+    if ("kept" in fetched) {
+      const result2 = { origin: liveState.origin, rowCount: rowCount() };
+      if (liveState.revision !== void 0) result2.revision = liveState.revision;
+      logPrimed(logger, result2);
+      return result2;
+    }
+    liveCatalog.replace(fetched.rows);
+    liveState.origin = "remote";
+    liveState.revision = fetched.revision;
+    await writeCache(source, logger, fetched.rows, fetched.revision);
+    const result = { origin: liveState.origin, rowCount: rowCount() };
+    if (fetched.revision !== void 0) result.revision = fetched.revision;
+    logPrimed(logger, result);
+    return result;
+  } catch (err) {
+    logger.warn("[modelkit] catalog remote failed, trying cache", err);
+    const error = describeError(err);
+    try {
+      const cached = await source.cache?.get();
+      if (!cached) throw new Error("no cached catalog");
+      const { rows, revision: rev } = parseEnvelope(JSON.parse(cached));
+      liveCatalog.replace(rows);
+      liveState.origin = "last-good";
+      liveState.revision = rev;
+      const result = {
+        origin: liveState.origin,
+        rowCount: rowCount(),
+        error
+      };
+      if (rev !== void 0) result.revision = rev;
+      logPrimed(logger, result);
+      return result;
+    } catch (cacheErr) {
+      logger.warn("[modelkit] catalog cache failed, using snapshot", cacheErr);
+      liveCatalog.replace([...MODELS]);
+      liveState.origin = "snapshot";
+      liveState.revision = void 0;
+      const result = {
+        origin: liveState.origin,
+        rowCount: rowCount(),
+        error
+      };
+      logPrimed(logger, result);
+      return result;
+    }
+  }
+}
+async function refresh(source, logger) {
+  try {
+    const fetched = await fetchRemote(source, logger);
+    if ("kept" in fetched) return;
+    liveCatalog.replace(fetched.rows);
+    liveState.origin = "remote";
+    liveState.revision = fetched.revision;
+    await writeCache(source, logger, fetched.rows, fetched.revision);
+  } catch (err) {
+    logger.warn("[modelkit] catalog refresh failed, keeping current rows", err);
+  }
+}
+function primeCatalog(source) {
+  const memo = liveState.memo;
+  if (memo) return memo;
+  const logger = source.logger ?? console;
+  liveState.memo = prime(source, logger).then((result) => {
+    const ttlMs = source.ttlMs ?? 3e5;
+    if (ttlMs > 0 && liveState.timer === void 0) {
+      liveState.timer = setInterval(() => void refresh(source, logger), ttlMs);
+      const maybeUnref = liveState.timer;
+      maybeUnref.unref?.();
+    }
+    return result;
+  });
+  return liveState.memo;
+}
+function resetLiveCatalog() {
+  if (liveState.timer !== void 0) {
+    clearInterval(liveState.timer);
+    liveState.timer = void 0;
+  }
+  liveState.memo = void 0;
+  liveState.revision = void 0;
+  liveState.origin = "snapshot";
+  liveCatalog.replace([...MODELS]);
+}
+
 // src/resolve-options.ts
 var SIZE_ORDER = ["512", "1K", "2K", "4K"];
 var RESOLUTION_ORDER = ["360p", "480p", "720p", "768p", "1080p", "2k", "4k"];