@1agh/maude 1.0.11 → 1.2.0

package/apps/studio/generation/jobs.test.ts

@@ -1,128 +0,0 @@
-// generation/jobs.test.ts — the generation job queue: enqueue → done/failed
-// transitions, history ledger, backpressure. Uses a tiny fake Bus + a tmp
-// designRoot so no real server or provider is involved.
-
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { createGenerationJobQueue, GenerationQueueFullError } from './jobs.ts';
-
-interface FakeBus {
-  emit(evt: string, payload?: unknown): void;
-  on(evt: string, fn: (p: unknown) => void): void;
-}
-
-function fakeBus(): { bus: FakeBus; events: Array<{ evt: string; payload: unknown }> } {
-  const events: Array<{ evt: string; payload: unknown }> = [];
-  return {
-    events,
-    bus: { emit: (evt, payload) => events.push({ evt, payload }), on: () => {} },
-  };
-}
-
-let dir: string;
-beforeEach(() => {
-  dir = mkdtempSync(join(tmpdir(), 'maude-genq-'));
-});
-afterEach(() => rmSync(dir, { recursive: true, force: true }));
-
-describe('generation job queue', () => {
-  test('a successful job transitions queued→running→done and records assets', async () => {
-    const { bus, events } = fakeBus();
-    const q = createGenerationJobQueue(bus as never, dir);
-    const { id, result } = q.enqueue({
-      provider: 'gemini',
-      modality: 'image',
-      model: 'gemini-2.5-flash-image',
-      run: async () => ({ assets: ['assets/abc12345.png'], usage: { ms: 5 } }),
-    });
-    const job = await result;
-    expect(job.id).toBe(id);
-    expect(job.status).toBe('done');
-    expect(job.assets).toEqual(['assets/abc12345.png']);
-    const statuses = events
-      .filter((e) => e.evt === 'generate:job')
-      .map((e) => (e.payload as { status: string }).status);
-    expect(statuses).toContain('queued');
-    expect(statuses).toContain('running');
-    expect(statuses).toContain('done');
-  });
-
-  test('a failing run marks the job failed and captures the error', async () => {
-    const { bus } = fakeBus();
-    const q = createGenerationJobQueue(bus as never, dir);
-    const { result } = q.enqueue({
-      provider: 'gemini',
-      modality: 'image',
-      run: async () => {
-        throw new Error('provider exploded');
-      },
-    });
-    await expect(result).rejects.toThrow(/provider exploded/);
-    const job = q.list()[0];
-    expect(job.status).toBe('failed');
-    expect(job.error).toMatch(/provider exploded/);
-  });
-
-  test('finished jobs persist to the _generate-history.json ledger', async () => {
-    const { bus } = fakeBus();
-    const q = createGenerationJobQueue(bus as never, dir);
-    await q.enqueue({
-      provider: 'gemini',
-      modality: 'image',
-      run: async () => ({ assets: ['assets/deadbeef.png'] }),
-    }).result;
-    const ledger = JSON.parse(readFileSync(join(dir, '_generate-history.json'), 'utf8'));
-    expect(Array.isArray(ledger)).toBe(true);
-    expect(ledger[0].assets).toEqual(['assets/deadbeef.png']);
-    expect(ledger[0].status).toBe('done');
-  });
-
-  test('the ledger is re-seeded on a fresh queue (survives restart)', async () => {
-    const { bus } = fakeBus();
-    const q1 = createGenerationJobQueue(bus as never, dir);
-    await q1.enqueue({
-      provider: 'gemini',
-      modality: 'image',
-      run: async () => ({ assets: ['assets/seed0001.png'] }),
-    }).result;
-    const q2 = createGenerationJobQueue(bus as never, dir);
-    expect(q2.loadHistory().some((h) => h.assets?.includes('assets/seed0001.png'))).toBe(true);
-  });
-
-  test('backpressure — a flood past MAX_PENDING throws GenerationQueueFullError', async () => {
-    const prev = process.env.MAUDE_GENERATE_MAX_QUEUED;
-    const prevConc = process.env.MAUDE_GENERATE_MAX_CONCURRENT;
-    process.env.MAUDE_GENERATE_MAX_QUEUED = '2';
-    process.env.MAUDE_GENERATE_MAX_CONCURRENT = '1';
-    try {
-      const { bus } = fakeBus();
-      const q = createGenerationJobQueue(bus as never, dir);
-      // A run that never resolves until we let it, so jobs stay pending.
-      let release!: () => void;
-      const gate = new Promise<void>((r) => {
-        release = r;
-      });
-      const mk = () =>
-        q.enqueue({
-          provider: 'gemini',
-          modality: 'image',
-          run: async () => {
-            await gate;
-            return { assets: [] };
-          },
-        });
-      mk(); // running (holds the single concurrency slot)
-      mk(); // queued
-      expect(() => mk()).toThrow(GenerationQueueFullError); // over the cap
-      release();
-    } finally {
-      if (prev === undefined) delete process.env.MAUDE_GENERATE_MAX_QUEUED;
-      else process.env.MAUDE_GENERATE_MAX_QUEUED = prev;
-      if (prevConc === undefined) delete process.env.MAUDE_GENERATE_MAX_CONCURRENT;
-      else process.env.MAUDE_GENERATE_MAX_CONCURRENT = prevConc;
-    }
-  });
-});

package/apps/studio/generation/keys.test.ts

@@ -1,75 +0,0 @@
-// generation/keys.test.ts — key custody: 0600 mode assert, round-trip, and
-// missing-key returns null. Points MAUDE_GEN_KEYS_PATH at a sandbox file so the
-// user's real ~/.config/maude/keys.json is never touched.
-
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { existsSync, mkdtempSync, rmSync, statSync } from 'node:fs';
-import { platform, tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import {
-  configuredProviders,
-  deleteProviderKey,
-  getProviderKey,
-  isConfigured,
-  keysConfigPath,
-  setProviderKey,
-} from './keys.ts';
-
-let dir: string;
-const prevPath = process.env.MAUDE_GEN_KEYS_PATH;
-
-beforeEach(() => {
-  dir = mkdtempSync(join(tmpdir(), 'maude-keys-'));
-  process.env.MAUDE_GEN_KEYS_PATH = join(dir, 'keys.json');
-});
-
-afterEach(() => {
-  if (prevPath === undefined) delete process.env.MAUDE_GEN_KEYS_PATH;
-  else process.env.MAUDE_GEN_KEYS_PATH = prevPath;
-  rmSync(dir, { recursive: true, force: true });
-});
-
-describe('generation key custody', () => {
-  test('missing key resolves to null; isConfigured false', async () => {
-    expect(await getProviderKey('gemini')).toBeNull();
-    expect(isConfigured('gemini')).toBe(false);
-    expect(configuredProviders()).toEqual([]);
-  });
-
-  test('set → get round-trips and reports configured', async () => {
-    setProviderKey('gemini', 'AIza-secret-123');
-    expect(await getProviderKey('gemini')).toBe('AIza-secret-123');
-    expect(isConfigured('gemini')).toBe(true);
-    expect(configuredProviders()).toContain('gemini');
-  });
-
-  test('the keys file is written mode 0600', () => {
-    setProviderKey('elevenlabs', 'sk-eleven');
-    const path = keysConfigPath();
-    expect(existsSync(path)).toBe(true);
-    if (platform() !== 'win32') {
-      const mode = statSync(path).mode & 0o777;
-      expect(mode).toBe(0o600);
-    }
-  });
-
-  test('set trims whitespace and rejects empties', () => {
-    setProviderKey('gemini', '  padded-key  ');
-    expect(isConfigured('gemini')).toBe(true);
-    expect(() => setProviderKey('gemini', '   ')).toThrow();
-  });
-
-  test('delete removes the key', async () => {
-    setProviderKey('gemini', 'k');
-    deleteProviderKey('gemini');
-    expect(await getProviderKey('gemini')).toBeNull();
-    expect(isConfigured('gemini')).toBe(false);
-  });
-
-  test('a malformed provider id never resolves or writes', async () => {
-    expect(await getProviderKey('../etc')).toBeNull();
-    expect(() => setProviderKey('../etc', 'x')).toThrow();
-    expect(isConfigured('../etc')).toBe(false);
-  });
-});

package/apps/studio/generation/prefs.test.ts

@@ -1,95 +0,0 @@
-// prefs.test.ts — non-secret generation preferences (Task 2.6). The transcription
-// engine choice must round-trip through `.design/config.json`, default to whisper
-// when unset, reject an invalid engine, and NEVER clobber other config fields.
-
-import { describe, expect, test } from 'bun:test';
-import { mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import {
-  isTranscriptionProvider,
-  readTranscriptionProvider,
-  writeTranscriptionProvider,
-} from './prefs.ts';
-
-function tmpRepo(config?: unknown): string {
-  const root = mkdtempSync(join(tmpdir(), 'maude-prefs-'));
-  mkdirSync(join(root, '.design'), { recursive: true });
-  if (config !== undefined)
-    writeFileSync(join(root, '.design', 'config.json'), JSON.stringify(config, null, 2));
-  return root;
-}
-
-describe('isTranscriptionProvider', () => {
-  test('accepts the three engines, rejects anything else', () => {
-    expect(isTranscriptionProvider('whisper')).toBe(true);
-    expect(isTranscriptionProvider('elevenlabs')).toBe(true);
-    expect(isTranscriptionProvider('groq')).toBe(true);
-    expect(isTranscriptionProvider('openai')).toBe(false);
-    expect(isTranscriptionProvider('')).toBe(false);
-    expect(isTranscriptionProvider(null)).toBe(false);
-  });
-});
-
-describe('readTranscriptionProvider', () => {
-  test('defaults to whisper when no config exists', () => {
-    expect(readTranscriptionProvider(tmpRepo())).toBe('whisper');
-  });
-
-  test('defaults to whisper when the block is absent', () => {
-    expect(readTranscriptionProvider(tmpRepo({ name: 'x' }))).toBe('whisper');
-  });
-
-  test('reads a configured engine', () => {
-    const repo = tmpRepo({ generation: { transcription: { provider: 'groq' } } });
-    expect(readTranscriptionProvider(repo)).toBe('groq');
-  });
-
-  test('ignores a malformed engine value', () => {
-    const repo = tmpRepo({ generation: { transcription: { provider: 'bogus' } } });
-    expect(readTranscriptionProvider(repo)).toBe('whisper');
-  });
-});
-
-describe('writeTranscriptionProvider', () => {
-  test('round-trips the choice', async () => {
-    const repo = tmpRepo({ name: 'x' });
-    await writeTranscriptionProvider(repo, 'elevenlabs');
-    expect(readTranscriptionProvider(repo)).toBe('elevenlabs');
-  });
-
-  test('preserves other config fields and other generation keys', async () => {
-    const repo = tmpRepo({
-      name: 'proj',
-      generation: { defaultImageProvider: 'gemini', transcription: { model: 'scribe_v1' } },
-    });
-    await writeTranscriptionProvider(repo, 'groq');
-    const cfg = JSON.parse(readFileSync(join(repo, '.design', 'config.json'), 'utf8'));
-    expect(cfg.name).toBe('proj');
-    expect(cfg.generation.defaultImageProvider).toBe('gemini');
-    expect(cfg.generation.transcription.model).toBe('scribe_v1'); // sibling key kept
-    expect(cfg.generation.transcription.provider).toBe('groq');
-  });
-
-  test('creates the generation block when absent', async () => {
-    const repo = tmpRepo(); // no config file at all
-    await writeTranscriptionProvider(repo, 'whisper');
-    expect(readTranscriptionProvider(repo)).toBe('whisper');
-  });
-
-  test('rejects an invalid engine', async () => {
-    const repo = tmpRepo();
-    await expect(writeTranscriptionProvider(repo, 'openai')).rejects.toThrow(/invalid/);
-  });
-
-  test('fails closed on an existing-but-corrupt config (never clobbers it)', async () => {
-    const repo = mkdtempSync(join(tmpdir(), 'maude-prefs-'));
-    mkdirSync(join(repo, '.design'), { recursive: true });
-    const corrupt = '{ this is not json ';
-    writeFileSync(join(repo, '.design', 'config.json'), corrupt);
-    await expect(writeTranscriptionProvider(repo, 'groq')).rejects.toThrow(/valid JSON/);
-    // The corrupt file is left untouched, not overwritten with a partial config.
-    expect(readFileSync(join(repo, '.design', 'config.json'), 'utf8')).toBe(corrupt);
-  });
-});

package/apps/studio/generation/types.test.ts

@@ -1,123 +0,0 @@
-// generation/types.test.ts — type-level invariants proven through a fake
-// adapter + the request validator (the security surface behind
-// /_api/generate-jobs). Mirrors photo/schema.test.ts's dependency-free style.
-
-import { describe, expect, test } from 'bun:test';
-
-import {
-  type AdapterContext,
-  type GenAsset,
-  type GenResult,
-  type Job,
-  type ProviderAdapter,
-  validateGenRequest,
-} from './types.ts';
-
-// A minimal sync fake — returns an already-`done` Job, proving the contract is
-// implementable without branching on sync/async.
-function fakeAdapter(_ctx: AdapterContext): ProviderAdapter {
-  return {
-    descriptor: {
-      id: 'fake',
-      label: 'Fake',
-      kind: 'cloud',
-      auth: 'api-key',
-      keychainService: 'com.maude.app.fake',
-      modalities: ['image'],
-    },
-    async submit() {
-      const result: GenResult = {
-        assets: [{ kind: 'image', mime: 'image/png', bytes: new Uint8Array([1, 2, 3]) }],
-        usage: { ms: 1 },
-      };
-      const job: Job = {
-        id: 'job_1',
-        status: () => 'done',
-        async *events() {
-          yield { status: 'done' as const };
-        },
-        result: async () => result,
-        cancel: () => {},
-      };
-      return job;
-    },
-  };
-}
-
-describe('generation contract', () => {
-  test('a sync adapter returns an already-done Job whose result localizes', async () => {
-    const localized: GenAsset[] = [];
-    const ctx: AdapterContext = {
-      apiKey: 'k',
-      localize: async (a) => {
-        localized.push(a);
-        return 'assets/deadbeef.png';
-      },
-    };
-    const adapter = fakeAdapter(ctx);
-    const job = await adapter.submit({ modality: 'image', provider: 'fake', prompt: 'a circle' });
-    expect(job.status()).toBe('done');
-    const res = await job.result();
-    expect(res.assets).toHaveLength(1);
-    const rel = await ctx.localize(res.assets[0]);
-    expect(rel).toBe('assets/deadbeef.png');
-    expect(localized).toHaveLength(1);
-  });
-});
-
-describe('validateGenRequest', () => {
-  test('accepts a well-formed image request', () => {
-    const r = validateGenRequest({ modality: 'image', provider: 'gemini', prompt: 'a red circle' });
-    expect(r.ok).toBe(true);
-    expect(r.errors).toEqual([]);
-  });
-
-  test('accepts a source-only edit request (no prompt)', () => {
-    const r = validateGenRequest({
-      modality: 'transcription',
-      provider: 'whisper',
-      sourceAsset: 'assets/abcd1234.mp4',
-    });
-    expect(r.ok).toBe(true);
-  });
-
-  test('rejects a non-object', () => {
-    expect(validateGenRequest(null).ok).toBe(false);
-    expect(validateGenRequest('x').ok).toBe(false);
-  });
-
-  test('rejects unknown modality + malformed provider', () => {
-    const r = validateGenRequest({ modality: 'hologram', provider: '../etc' });
-    expect(r.ok).toBe(false);
-    expect(r.errors.some((e) => e.startsWith('modality'))).toBe(true);
-    expect(r.errors.some((e) => e.startsWith('provider'))).toBe(true);
-  });
-
-  test('rejects a traversing sourceAsset', () => {
-    const r = validateGenRequest({
-      modality: 'image',
-      provider: 'gemini',
-      sourceAsset: '../../etc/passwd',
-    });
-    expect(r.ok).toBe(false);
-    expect(r.errors.some((e) => e.startsWith('sourceAsset'))).toBe(true);
-  });
-
-  test('rejects a bad aspect ratio + an over-long prompt', () => {
-    const r = validateGenRequest({
-      modality: 'image',
-      provider: 'gemini',
-      prompt: 'x'.repeat(9000),
-      aspectRatio: 'wide',
-    });
-    expect(r.ok).toBe(false);
-    expect(r.errors.some((e) => e.startsWith('prompt'))).toBe(true);
-    expect(r.errors.some((e) => e.startsWith('aspectRatio'))).toBe(true);
-  });
-
-  test('rejects a request with neither prompt nor sourceAsset', () => {
-    const r = validateGenRequest({ modality: 'image', provider: 'gemini' });
-    expect(r.ok).toBe(false);
-    expect(r.errors.some((e) => e.includes('prompt or a sourceAsset'))).toBe(true);
-  });
-});

package/apps/studio/generation/whisper-models.test.ts

@@ -1,179 +0,0 @@
-// whisper-models.test.ts — managed local whisper.cpp model registry + resolution
-// + download (Task 2.7, approach A). Uses a temp XDG_CACHE_HOME so the real
-// user cache is never touched, and a stubbed fetch for the download path.
-
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { existsSync, mkdtempSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import {
-  downloadWhisperModel,
-  getWhisperModel,
-  listWhisperModels,
-  removeWhisperModel,
-  resolveWhisperModel,
-  WHISPER_MODELS,
-  whisperModelsDir,
-  whisperModelUrl,
-} from './whisper-models.ts';
-
-const realFetch = globalThis.fetch;
-let cacheRoot: string;
-const prevXdg = process.env.XDG_CACHE_HOME;
-
-beforeEach(() => {
-  cacheRoot = mkdtempSync(join(tmpdir(), 'maude-wm-'));
-  process.env.XDG_CACHE_HOME = cacheRoot;
-});
-afterEach(() => {
-  globalThis.fetch = realFetch;
-  if (prevXdg === undefined) delete process.env.XDG_CACHE_HOME;
-  else process.env.XDG_CACHE_HOME = prevXdg;
-});
-
-describe('registry', () => {
-  test('carries base (multilingual) + base.en (English-only)', () => {
-    expect(getWhisperModel('base')?.multilingual).toBe(true);
-    expect(getWhisperModel('base.en')?.multilingual).toBe(false);
-    expect(getWhisperModel('nope')).toBeNull();
-  });
-  test('whisperModelUrl derives the frozen ggerganov/whisper.cpp URL (SSRF-safe host)', () => {
-    const url = whisperModelUrl(getWhisperModel('base'));
-    expect(url).toBe('https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base.bin');
-  });
-  test('whisperModelsDir honors XDG_CACHE_HOME', () => {
-    expect(whisperModelsDir()).toBe(join(cacheRoot, 'maude', 'whisper-models'));
-  });
-});
-
-describe('resolveWhisperModel', () => {
-  function fakeDownloaded(file: string) {
-    const dir = whisperModelsDir();
-    require('node:fs').mkdirSync(dir, { recursive: true });
-    writeFileSync(join(dir, file), 'x');
-  }
-
-  test('returns null when nothing is downloaded', () => {
-    expect(resolveWhisperModel()).toBeNull();
-  });
-  test('prefers the configured id when present', () => {
-    fakeDownloaded('ggml-small.bin');
-    fakeDownloaded('ggml-base.bin');
-    expect(resolveWhisperModel('small')).toBe(join(whisperModelsDir(), 'ggml-small.bin'));
-  });
-  test('prefers a MULTILINGUAL model over an English-only one (Czech-footage safety)', () => {
-    fakeDownloaded('ggml-base.en.bin'); // English-only
-    fakeDownloaded('ggml-base.bin'); // multilingual
-    expect(resolveWhisperModel()).toBe(join(whisperModelsDir(), 'ggml-base.bin'));
-  });
-  test('falls back to any model if only English-only is present', () => {
-    fakeDownloaded('ggml-base.en.bin');
-    expect(resolveWhisperModel()).toBe(join(whisperModelsDir(), 'ggml-base.en.bin'));
-  });
-});
-
-describe('listWhisperModels', () => {
-  test('flags a downloaded model', () => {
-    const dir = whisperModelsDir();
-    require('node:fs').mkdirSync(dir, { recursive: true });
-    writeFileSync(join(dir, 'ggml-tiny.bin'), 'abc');
-    const tiny = listWhisperModels().find((m) => m.id === 'tiny');
-    expect(tiny?.downloaded).toBe(true);
-    expect(tiny?.bytes).toBe(3);
-    expect(listWhisperModels().find((m) => m.id === 'base')?.downloaded).toBe(false);
-  });
-});
-
-describe('downloadWhisperModel', () => {
-  test('streams to the cache, reports progress, atomically lands the file', async () => {
-    const bytes = new Uint8Array(1024);
-    globalThis.fetch = (async () =>
-      new Response(bytes, {
-        status: 200,
-        headers: { 'content-length': String(bytes.byteLength) },
-      })) as typeof fetch;
-    const seen: number[] = [];
-    const path = await downloadWhisperModel('tiny', (r) => seen.push(r));
-    expect(path).toBe(join(whisperModelsDir(), 'ggml-tiny.bin'));
-    expect(existsSync(path)).toBe(true);
-    expect(existsSync(`${path}.part`)).toBe(false); // temp renamed away
-    expect(seen.at(-1)).toBe(1024);
-    expect(await removeWhisperModel('tiny')).toBe(true);
-    expect(existsSync(path)).toBe(false);
-  });
-
-  test('rejects an over-cap body (declared content-length) without writing', async () => {
-    globalThis.fetch = (async () =>
-      new Response(new Uint8Array(1), {
-        status: 200,
-        headers: { 'content-length': String(9999 * 1024 * 1024) }, // way over tiny's cap
-      })) as typeof fetch;
-    await expect(downloadWhisperModel('tiny', () => {})).rejects.toThrow(/larger than expected/);
-    expect(existsSync(join(whisperModelsDir(), 'ggml-tiny.bin'))).toBe(false);
-  });
-
-  test('unknown model id throws', async () => {
-    await expect(downloadWhisperModel('bogus', () => {})).rejects.toThrow(/unknown whisper model/);
-  });
-
-  test('rejects a redirect that lands off huggingface.co (Finding 2)', async () => {
-    // Simulate the HF blob redirect resolving to an attacker/on-path host.
-    globalThis.fetch = (async () => ({
-      url: 'https://evil.example/ggml-tiny.bin',
-      ok: true,
-      headers: new Headers(),
-      body: new Response(new Uint8Array(1)).body,
-    })) as unknown as typeof fetch;
-    await expect(downloadWhisperModel('tiny', () => {})).rejects.toThrow(
-      /off the allowed HF hosts/
-    );
-    expect(existsSync(join(whisperModelsDir(), 'ggml-tiny.bin'))).toBe(false);
-  });
-
-  test('accepts a redirect that stays on a huggingface.co CDN host', async () => {
-    const bytes = new Uint8Array(512);
-    globalThis.fetch = (async () => ({
-      url: 'https://cdn-lfs.huggingface.co/repos/x/ggml-tiny.bin',
-      ok: true,
-      headers: new Headers({ 'content-length': String(bytes.byteLength) }),
-      body: new Response(bytes).body,
-    })) as unknown as typeof fetch;
-    const path = await downloadWhisperModel('tiny', () => {});
-    expect(existsSync(path)).toBe(true);
-  });
-
-  test("accepts a redirect that lands on HF's Xet CDN (xethub.hf.co)", async () => {
-    const bytes = new Uint8Array(512);
-    globalThis.fetch = (async () => ({
-      url: 'https://cas-bridge.xethub.hf.co/repos/x/ggml-tiny.bin',
-      ok: true,
-      headers: new Headers({ 'content-length': String(bytes.byteLength) }),
-      body: new Response(bytes).body,
-    })) as unknown as typeof fetch;
-    const path = await downloadWhisperModel('tiny', () => {});
-    expect(existsSync(path)).toBe(true);
-  });
-
-  test('rejects a lookalike host that merely contains an allowed apex', async () => {
-    globalThis.fetch = (async () => ({
-      url: 'https://xethub.hf.co.evil.example/ggml-tiny.bin',
-      ok: true,
-      headers: new Headers(),
-      body: new Response(new Uint8Array(1)).body,
-    })) as unknown as typeof fetch;
-    await expect(downloadWhisperModel('tiny', () => {})).rejects.toThrow(
-      /off the allowed HF hosts/
-    );
-    expect(existsSync(join(whisperModelsDir(), 'ggml-tiny.bin'))).toBe(false);
-  });
-});
-
-describe('registry integrity', () => {
-  test('every model has a positive size and a ggml- file', () => {
-    for (const m of WHISPER_MODELS) {
-      expect(m.sizeMB).toBeGreaterThan(0);
-      expect(m.file.startsWith('ggml-')).toBe(true);
-    }
-  });
-});