badgr-cli 1.0.31 → 1.0.32

package/src/router.js

@@ -1,56 +1,26 @@
 /**
- * GPU catalog and routing preview.
+ * GPU catalog — static display info only (name, VRAM, tags, indicative rate).
  *
- * Provider pricing mirrors the order in overflow_providers.py:
- * Vast.ai → RunPod → TensorDock → SaladCloud.
- * Actual routing happens server-side; this is the dry-run preview.
+ * ratePerHour values are indicative market averages for reference display.
+ * Actual billing is always set by the backend and returned as cost_per_hour
+ * on every deployment response. For live rates, use GET /v1/gpus.
+ *
+ * Provider routing logic lives entirely in the backend.
  */
 
 export const GPU_CATALOG = [
-  { id: 'rtx-3080',  canonical: 'RTX_3080', name: 'NVIDIA RTX 3080',  vramGb: 10, ratePerHour: 0.35, tags: ['inference', 'dev'] },
-  { id: 'rtx-4090',  canonical: 'RTX_4090', name: 'NVIDIA RTX 4090',  vramGb: 24, ratePerHour: 1.10, tags: ['inference', 'training', 'dev'] },
-  { id: 'l40s',      canonical: 'L40S',     name: 'NVIDIA L40S',      vramGb: 48, ratePerHour: 1.40, tags: ['inference', 'training'] },
-  { id: 'a6000',     canonical: 'A6000',    name: 'NVIDIA RTX A6000', vramGb: 48, ratePerHour: 1.60, tags: ['inference', 'training'] },
-  { id: 'a100-40gb', canonical: 'A100',     name: 'NVIDIA A100 40GB',  vramGb: 40, ratePerHour: 1.80, tags: ['training', 'inference'] },
-  { id: 'a100-80gb', canonical: 'A100',     name: 'NVIDIA A100 80GB',  vramGb: 80, ratePerHour: 2.50, tags: ['training', 'large-model'] },
-  { id: 'h100',      canonical: 'H100',     name: 'NVIDIA H100 80GB',  vramGb: 80, ratePerHour: 3.50, tags: ['training', 'large-model'] },
+  { id: 'rtx-3080',  canonical: 'RTX_3080',  name: 'NVIDIA RTX 3080',   vramGb: 10, ratePerHour: 0.35, tags: ['inference', 'dev'] },
+  { id: 'rtx-3090',  canonical: 'RTX_3090',  name: 'NVIDIA RTX 3090',   vramGb: 24, ratePerHour: 0.60, tags: ['inference', 'dev'] },
+  { id: 'rtx-4090',  canonical: 'RTX_4090',  name: 'NVIDIA RTX 4090',   vramGb: 24, ratePerHour: 1.10, tags: ['inference', 'training', 'dev'] },
+  { id: 'a4000',     canonical: 'A4000',      name: 'NVIDIA RTX A4000',  vramGb: 16, ratePerHour: 0.50, tags: ['inference', 'dev'] },
+  { id: 'a5000',     canonical: 'A5000',      name: 'NVIDIA RTX A5000',  vramGb: 24, ratePerHour: 0.70, tags: ['inference', 'dev'] },
+  { id: 'l40s',      canonical: 'L40S',       name: 'NVIDIA L40S',       vramGb: 48, ratePerHour: 1.40, tags: ['inference', 'training'] },
+  { id: 'a6000',     canonical: 'A6000',      name: 'NVIDIA RTX A6000',  vramGb: 48, ratePerHour: 1.60, tags: ['inference', 'training'] },
+  { id: 'a100-40gb', canonical: 'A100',       name: 'NVIDIA A100 40GB',  vramGb: 40, ratePerHour: 1.80, tags: ['training', 'inference'] },
+  { id: 'a100-80gb', canonical: 'A100_80GB',  name: 'NVIDIA A100 80GB',  vramGb: 80, ratePerHour: 2.50, tags: ['training', 'large-model'] },
+  { id: 'h100',      canonical: 'H100',       name: 'NVIDIA H100 80GB',  vramGb: 80, ratePerHour: 3.50, tags: ['training', 'large-model'] },
 ];
 
-// Provider-level pricing per canonical GPU type (ordered cheapest-first per provider).
-// Mirrors overflow_providers.py search ordering: Vast → RunPod → TensorDock → Salad.
-export const PROVIDER_CATALOG = {
-  RTX_3080: [
-    { provider: 'vastai',      ratePerHour: 0.28, reliability: 0.93 },
-    { provider: 'runpod',      ratePerHour: 0.35, reliability: 0.96 },
-    { provider: 'tensordock',  ratePerHour: 0.40, reliability: 0.90 },
-  ],
-  RTX_4090: [
-    { provider: 'vastai',      ratePerHour: 0.65, reliability: 0.94 },
-    { provider: 'runpod',      ratePerHour: 0.72, reliability: 0.97 },
-    { provider: 'tensordock',  ratePerHour: 0.81, reliability: 0.91 },
-    { provider: 'salad',       ratePerHour: 0.89, reliability: 0.89 },
-  ],
-  L40S: [
-    { provider: 'vastai',      ratePerHour: 1.10, reliability: 0.94 },
-    { provider: 'runpod',      ratePerHour: 1.25, reliability: 0.97 },
-    { provider: 'salad',       ratePerHour: 1.40, reliability: 0.88 },
-  ],
-  A6000: [
-    { provider: 'vastai',      ratePerHour: 1.05, reliability: 0.93 },
-    { provider: 'runpod',      ratePerHour: 1.20, reliability: 0.97 },
-    { provider: 'salad',       ratePerHour: 1.35, reliability: 0.88 },
-  ],
-  A100: [
-    { provider: 'runpod',      ratePerHour: 1.20, reliability: 0.98 },
-    { provider: 'vastai',      ratePerHour: 1.35, reliability: 0.95 },
-    { provider: 'tensordock',  ratePerHour: 1.50, reliability: 0.92 },
-  ],
-  H100: [
-    { provider: 'runpod',      ratePerHour: 2.80, reliability: 0.99 },
-    { provider: 'vastai',      ratePerHour: 3.10, reliability: 0.96 },
-  ],
-};
-
 export function findById(id) {
   return GPU_CATALOG.find(g => g.id === id) ?? null;
 }
@@ -72,33 +42,6 @@ export function listAll() {
   return [...GPU_CATALOG].sort((a, b) => a.ratePerHour - b.ratePerHour);
 }
 
-/**
- * Build the routing preview shown in --dry-run output.
- * Mirrors the lane 1→2→3 logic in overflow_dispatch.py.
- */
-export function getRoutePlan(canonical, count = 1) {
-  const providers = PROVIDER_CATALOG[canonical] ?? [];
-  const sorted = [...providers].sort((a, b) => a.ratePerHour - b.ratePerHour);
-
-  const cheapest = sorted[0];
-  const overhead = 0.25; // ~25% overhead: startup risk + failure buffer + badgr margin
-  const costWithOverhead = cheapest ? cheapest.ratePerHour * (1 + overhead) * count : null;
-
-  return {
-    canonical,
-    gpu: findByCanonical(canonical),
-    lane1: { label: 'Own GPU hosts', description: 'checked at runtime against live worker pool' },
-    lane2: sorted.map((p, i) => ({
-      rank: i + 1,
-      provider: p.provider,
-      ratePerHour: p.ratePerHour * count,
-      reliability: p.reliability,
-    })),
-    cheapestRate: cheapest ? cheapest.ratePerHour * count : null,
-    costWithOverhead,
-  };
-}
-
 export function estimateCost(ratePerHour, durationMinutes) {
   return (ratePerHour / 60) * durationMinutes;
 }

package/src/store.js

@@ -1,5 +1,5 @@
 /**
- * Local deployment state — persisted to ~/.gpu/deployments.json.
+ * Local deployment state — persisted to ~/.badgr/deployments.json.
  *
  * Tracks what `gpu up` has provisioned so `gpu down/status/logs/receipts`
  * have something to work with before a backend deployments API exists.
@@ -83,6 +83,15 @@ export function addReceipt(receipt, storeFile = STORE_FILE) {
   return receipt;
 }
 
+export function updateReceipt(receiptId, updates, storeFile = STORE_FILE) {
+  const store = loadStore(storeFile);
+  const idx = store.receipts.findIndex(r => r.receiptId === receiptId);
+  if (idx === -1) return null;
+  store.receipts[idx] = { ...store.receipts[idx], ...updates };
+  saveStore(store, storeFile);
+  return store.receipts[idx];
+}
+
 export function listReceipts(limit = 20, storeFile = STORE_FILE) {
   return loadStore(storeFile).receipts.slice(0, limit);
 }

package/tests/commands.test.js

@@ -1,6 +1,8 @@
-import { describe, it, expect } from 'vitest';
-import { parseRunArgs } from '../src/commands/run.js';
+import { describe, it, expect, vi } from 'vitest';
+import { parseRunArgs, classifyFailure } from '../src/commands/run.js';
 import { parseServeArgs } from '../src/commands/serve.js';
+import { testCommand, parseTestArgs } from '../src/commands/test-run.js';
+import { rankAlternatives, diffDescription, promptFallback, CapacityError } from '../src/fallback.js';
 
 describe('parseRunArgs', () => {
   it('parses a plain command', () => {
@@ -43,6 +45,124 @@ describe('parseRunArgs', () => {
     expect(positional).toEqual([]);
     expect(flags.gpu).toBeUndefined();
   });
+
+  it('parses --fallback closest', () => {
+    const { flags } = parseRunArgs(['python', 'train.py', '--gpu', 'A100', '--fallback', 'closest']);
+    expect(flags.fallback).toBe('closest');
+    expect(flags.noFallback).toBeUndefined();
+  });
+
+  it('parses --fallback cheapest', () => {
+    const { flags } = parseRunArgs(['python', 'train.py', '--fallback', 'cheapest']);
+    expect(flags.fallback).toBe('cheapest');
+  });
+
+  it('parses --no-fallback', () => {
+    const { flags } = parseRunArgs(['python', 'train.py', '--gpu', 'A100', '--no-fallback']);
+    expect(flags.noFallback).toBe(true);
+    expect(flags.fallback).toBeUndefined();
+  });
+
+  it('parses --max-runtime as a float (minutes)', () => {
+    const { flags } = parseRunArgs(['python', 'train.py', '--max-runtime', '30']);
+    expect(flags.maxRuntime).toBe(30);
+  });
+
+  it('parses --max-cost as a float (dollars)', () => {
+    const { flags } = parseRunArgs(['python', 'train.py', '--max-cost', '5.00']);
+    expect(flags.maxCost).toBe(5.0);
+  });
+
+  it('parses --tier 2 flag', () => {
+    const { flags } = parseRunArgs(['python', 'train.py', '--tier', '2']);
+    expect(flags.tier).toBe('2');
+  });
+
+  it('--tier defaults to undefined when not passed', () => {
+    const { flags } = parseRunArgs(['python', 'train.py']);
+    expect(flags.tier).toBeUndefined();
+  });
+});
+
+describe('classifyFailure', () => {
+  it('returns infrastructure when status is failed and no exit code', () => {
+    expect(classifyFailure('failed', null)).toBe('infrastructure');
+    expect(classifyFailure('failed', undefined)).toBe('infrastructure');
+  });
+
+  it('returns customer_code when exit code is non-zero', () => {
+    expect(classifyFailure('failed', 1)).toBe('customer_code');
+    expect(classifyFailure('completed', 2)).toBe('customer_code');
+  });
+
+  it('returns null for successful jobs', () => {
+    expect(classifyFailure('completed', 0)).toBeNull();
+    expect(classifyFailure('completed', null)).toBeNull();
+  });
+
+  it('returns null for stopped jobs with no exit code', () => {
+    expect(classifyFailure('stopped', null)).toBeNull();
+  });
+});
+
+describe('rankAlternatives', () => {
+  const pool = [
+    { gpu: 'RTX_4090', region: 'US', price: 0.72, rank: 3 },
+    { gpu: 'L40S',     region: 'US', price: 1.25, rank: 2 },
+    { gpu: 'H100',     region: 'EU', price: 2.80, rank: 1 },
+    { gpu: 'A6000',    region: 'US', price: 1.20 },   // no rank field
+  ];
+
+  it('cheapest mode sorts by price ascending', () => {
+    const ranked = rankAlternatives('A100', pool, 'cheapest');
+    expect(ranked[0].price).toBe(0.72);
+    expect(ranked[ranked.length - 1].price).toBe(2.80);
+  });
+
+  it('closest mode honours backend rank field when present', () => {
+    const poolWithRanks = [
+      { gpu: 'RTX_4090', region: 'US', price: 0.72, rank: 3 },
+      { gpu: 'L40S',     region: 'US', price: 1.25, rank: 2 },
+      { gpu: 'H100',     region: 'EU', price: 2.80, rank: 1 },
+    ];
+    const ranked = rankAlternatives('A100', poolWithRanks, 'closest');
+    expect(ranked[0].gpu).toBe('H100');   // rank 1 → top
+    expect(ranked[1].gpu).toBe('L40S');   // rank 2
+    expect(ranked[2].gpu).toBe('RTX_4090'); // rank 3
+  });
+
+  it('closest mode falls back to price sort when no rank field', () => {
+    const noRankPool = [
+      { gpu: 'RTX_4090', region: 'US', price: 0.72 },
+      { gpu: 'L40S',     region: 'US', price: 1.25 },
+    ];
+    const ranked = rankAlternatives('A100', noRankPool, 'closest');
+    expect(ranked[0].price).toBe(0.72);
+  });
+
+  it('returns empty array for empty pool', () => {
+    expect(rankAlternatives('A100', [])).toEqual([]);
+  });
+
+  it('returns empty array for null pool', () => {
+    expect(rankAlternatives('A100', null)).toEqual([]);
+  });
+});
+
+describe('diffDescription', () => {
+  it('uses diff_desc from alt object when backend provides it', () => {
+    const alt = { diff_desc: 'less VRAM (24GB vs 40GB) than A100' };
+    expect(diffDescription('A100', 'RTX_4090', alt)).toBe(alt.diff_desc);
+  });
+
+  it('returns empty string when diff_desc is absent', () => {
+    expect(diffDescription('A100', 'RTX_4090', {})).toBe('');
+    expect(diffDescription('A100', 'RTX_4090')).toBe('');
+  });
+
+  it('returns empty string for unknown GPUs with no alt object', () => {
+    expect(diffDescription('UNKNOWN', 'ALSO_UNKNOWN')).toBe('');
+  });
 });
 
 describe('parseServeArgs', () => {
@@ -78,4 +198,116 @@ describe('parseServeArgs', () => {
     const { model } = parseServeArgs(['--gpu', 'RTX_4090']);
     expect(model).toBeNull();
   });
+
+  it('parses --tier 2 flag', () => {
+    const { flags } = parseServeArgs(['my/model', '--tier', '2']);
+    expect(flags.tier).toBe('2');
+  });
+
+  it('--tier defaults to undefined when not passed', () => {
+    const { flags } = parseServeArgs(['my/model']);
+    expect(flags.tier).toBeUndefined();
+  });
+
+  it('parses --no-fallback as noMarketplaceFallback', () => {
+    const { flags } = parseServeArgs(['my/model', '--no-fallback']);
+    expect(flags.noMarketplaceFallback).toBe(true);
+  });
+
+  it('parses --strict-capacity as noMarketplaceFallback', () => {
+    const { flags } = parseServeArgs(['my/model', '--strict-capacity']);
+    expect(flags.noMarketplaceFallback).toBe(true);
+  });
+
+  it('parses --no-expanded-search as noMarketplaceFallback', () => {
+    const { flags } = parseServeArgs(['my/model', '--no-expanded-search']);
+    expect(flags.noMarketplaceFallback).toBe(true);
+  });
+
+  it('noMarketplaceFallback defaults to falsy when not passed', () => {
+    const { flags } = parseServeArgs(['my/model']);
+    expect(flags.noMarketplaceFallback).toBeFalsy();
+  });
+
+  it('model is not consumed by --no-fallback flag', () => {
+    const { model, flags } = parseServeArgs(['my/model', '--no-fallback']);
+    expect(model).toBe('my/model');
+    expect(flags.noMarketplaceFallback).toBe(true);
+  });
+
+  it('parses --health-path flag', () => {
+    const { flags } = parseServeArgs(['my/model', '--health-path', '/system_stats']);
+    expect(flags.healthPath).toBe('/system_stats');
+  });
+
+  it('parses --health-path with arbitrary path', () => {
+    const { flags } = parseServeArgs(['--image', 'my/image:latest', '--health-path', '/health']);
+    expect(flags.healthPath).toBe('/health');
+  });
+
+  it('healthPath defaults to undefined when not passed', () => {
+    const { flags } = parseServeArgs(['my/model']);
+    expect(flags.healthPath).toBeUndefined();
+  });
+});
+
+describe('testCommand', () => {
+  it('is a function', () => {
+    expect(typeof testCommand).toBe('function');
+  });
+});
+
+describe('parseTestArgs', () => {
+  it('returns empty flags for no args', () => {
+    expect(parseTestArgs([])).toEqual({});
+  });
+
+  it('parses --provider tier1', () => {
+    expect(parseTestArgs(['--provider', 'tier1'])).toEqual({ provider: 'tier1' });
+  });
+
+  it('parses --provider tier2', () => {
+    expect(parseTestArgs(['--provider', 'tier2'])).toEqual({ provider: 'tier2' });
+  });
+
+  it('parses --provider secondary', () => {
+    expect(parseTestArgs(['--provider', 'secondary'])).toEqual({ provider: 'secondary' });
+  });
+
+  it('parses --no-tier-fallback', () => {
+    expect(parseTestArgs(['--no-tier-fallback'])).toEqual({ noTierFallback: true });
+  });
+});
+
+describe('CapacityError', () => {
+  it('is an Error subclass', () => {
+    const err = new CapacityError('no capacity');
+    expect(err).toBeInstanceOf(Error);
+    expect(err.isCapacityError).toBe(true);
+    expect(err.name).toBe('CapacityError');
+    expect(err.message).toBe('no capacity');
+  });
+});
+
+describe('promptFallback output', () => {
+  it('does not print a Difference line', async () => {
+    const lines = [];
+    const chalk = { yellow: s => s, bold: s => s, cyan: s => s, green: s => s, dim: s => s };
+    const origLog = console.log;
+    console.log = (...args) => lines.push(args.join(' '));
+    // force non-TTY so it auto-selects without asking
+    const origIsTTY = process.stdin.isTTY;
+    process.stdin.isTTY = false;
+
+    const pool = [{ gpu: 'L40S', region: 'US', price: 1.25 }];
+    await promptFallback('A100', pool, chalk);
+
+    console.log = origLog;
+    process.stdin.isTTY = origIsTTY;
+
+    const joined = lines.join('\n');
+    expect(joined).not.toContain('Difference');
+    expect(joined).toContain('L40S');
+    expect(joined).toContain('1.25');
+  });
 });

package/tests/config.test.js

@@ -2,7 +2,7 @@ import { describe, it, expect, afterEach } from 'vitest';
 import { tmpdir } from 'os';
 import { join } from 'path';
 import { rmSync, existsSync } from 'fs';
-import { loadConfig, saveConfig, requireApiKey, DEFAULTS } from '../src/config.js';
+import { loadConfig, saveConfig, requireApiKey, normalizeBaseUrl, DEFAULTS } from '../src/config.js';
 
 const tmp = join(tmpdir(), `badgr-cli-test-${process.pid}`);
 const testConfigFile = join(tmp, 'config.json');
@@ -58,6 +58,29 @@ describe('saveConfig', () => {
   });
 });
 
+describe('normalizeBaseUrl', () => {
+  it('rewrites legacy api.badgr.ai to production host', () => {
+    expect(normalizeBaseUrl('https://api.badgr.ai/v1')).toBe(DEFAULTS.baseUrl);
+    expect(normalizeBaseUrl('https://api.badgr.ai')).toBe(DEFAULTS.baseUrl);
+  });
+
+  it('keeps production and localhost URLs', () => {
+    expect(normalizeBaseUrl('https://api.aibadgr.com/v1')).toBe(DEFAULTS.baseUrl);
+    expect(normalizeBaseUrl('http://localhost:8000/v1')).toBe('http://localhost:8000/v1');
+  });
+});
+
+describe('loadConfig legacy migration', () => {
+  it('migrates saved api.badgr.ai baseUrl on load', () => {
+    saveConfig(
+      { apiKey: 'sk-test', baseUrl: 'https://api.badgr.ai/v1' },
+      testConfigFile,
+    );
+    const config = loadConfig(testConfigFile);
+    expect(config.baseUrl).toBe(DEFAULTS.baseUrl);
+  });
+});
+
 describe('requireApiKey', () => {
   it('returns the key when present', () => {
     expect(requireApiKey({ apiKey: 'sk-abc' })).toBe('sk-abc');

package/tests/router.test.js

@@ -1,10 +1,14 @@
 import { describe, it, expect } from 'vitest';
 import {
   findById, findByCanonical, findCheapest, listAll,
-  getRoutePlan, estimateCost,
-  GPU_CATALOG, PROVIDER_CATALOG,
+  estimateCost,
+  GPU_CATALOG,
 } from '../src/router.js';
 
+// getRoutePlan and PROVIDER_CATALOG have been removed from the CLI.
+// Provider routing is now server-side only. Tests below cover the
+// remaining local GPU catalog helpers.
+
 describe('findById', () => {
   it('finds GPU by id', () => {
     expect(findById('rtx-4090').name).toContain('4090');
@@ -67,43 +71,6 @@ describe('listAll', () => {
   });
 });
 
-describe('getRoutePlan', () => {
-  it('returns lane1 and lane2 for RTX_4090', () => {
-    const plan = getRoutePlan('RTX_4090');
-    expect(plan.lane1).toBeTruthy();
-    expect(plan.lane2.length).toBeGreaterThan(0);
-  });
-
-  it('lane2 is sorted cheapest-first', () => {
-    const plan = getRoutePlan('RTX_4090');
-    for (let i = 1; i < plan.lane2.length; i++) {
-      expect(plan.lane2[i].ratePerHour).toBeGreaterThanOrEqual(plan.lane2[i - 1].ratePerHour);
-    }
-  });
-
-  it('scales ratePerHour by count', () => {
-    const plan1 = getRoutePlan('RTX_4090', 1);
-    const plan2 = getRoutePlan('RTX_4090', 2);
-    expect(plan2.lane2[0].ratePerHour).toBeCloseTo(plan1.lane2[0].ratePerHour * 2, 5);
-  });
-
-  it('cheapestRate matches first provider rate', () => {
-    const plan = getRoutePlan('H100');
-    expect(plan.cheapestRate).toBe(plan.lane2[0].ratePerHour);
-  });
-
-  it('costWithOverhead > cheapestRate', () => {
-    const plan = getRoutePlan('RTX_4090');
-    expect(plan.costWithOverhead).toBeGreaterThan(plan.cheapestRate);
-  });
-
-  it('includes gpu info for known canonical', () => {
-    const plan = getRoutePlan('H100');
-    expect(plan.gpu).not.toBeNull();
-    expect(plan.gpu.id).toBe('h100');
-  });
-});
-
 describe('estimateCost', () => {
   it('calculates cost for 60 minutes = 1 hour', () => {
     expect(estimateCost(1.10, 60)).toBeCloseTo(1.10, 5);
@@ -124,34 +91,8 @@ describe('L40S', () => {
     expect(findByCanonical('L40S').vramGb).toBe(48);
   });
 
-  it('has provider pricing in PROVIDER_CATALOG', () => {
-    expect(Array.isArray(PROVIDER_CATALOG['L40S'])).toBe(true);
-    expect(PROVIDER_CATALOG['L40S'].length).toBeGreaterThan(0);
-  });
-
-  it('route plan is cheapest-first for L40S', () => {
-    const plan = getRoutePlan('L40S');
-    expect(plan.lane2.length).toBeGreaterThan(0);
-    for (let i = 1; i < plan.lane2.length; i++) {
-      expect(plan.lane2[i].ratePerHour).toBeGreaterThanOrEqual(plan.lane2[i - 1].ratePerHour);
-    }
-  });
-});
-
-describe('PROVIDER_CATALOG', () => {
-  it('exists for all GPU_CATALOG canonical types', () => {
-    const catalogCanonicals = [...new Set(GPU_CATALOG.map(g => g.canonical))];
-    catalogCanonicals.forEach(c => {
-      // Some may not have provider pricing — just check the ones that do are valid arrays
-      if (PROVIDER_CATALOG[c]) {
-        expect(Array.isArray(PROVIDER_CATALOG[c])).toBe(true);
-        PROVIDER_CATALOG[c].forEach(p => {
-          expect(p.provider).toBeTruthy();
-          expect(p.ratePerHour).toBeGreaterThan(0);
-          expect(p.reliability).toBeGreaterThan(0);
-          expect(p.reliability).toBeLessThanOrEqual(1);
-        });
-      }
-    });
+  it('has no PROVIDER_CATALOG (provider routing is server-side)', async () => {
+    const mod = await import('../src/router.js');
+    expect(mod.PROVIDER_CATALOG).toBeUndefined();
   });
 });