@argo-video/cli 0.1.0 → 0.2.0

package/tests/overlays/templates.test.ts

@@ -1,69 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { renderTemplate } from '../../src/overlays/templates.js';
-
-describe('renderTemplate', () => {
-  describe('lower-third', () => {
-    it('renders text in a styled span', () => {
-      const result = renderTemplate({ type: 'lower-third', text: 'Hello world' });
-      expect(result.contentHtml).toContain('Hello world');
-      expect(result.styles.background).toBeDefined();
-      expect(result.styles.borderRadius).toBeDefined();
-    });
-    it('includes maxWidth for readability', () => {
-      const result = renderTemplate({ type: 'lower-third', text: 'Test' });
-      expect(result.styles.maxWidth).toBeDefined();
-    });
-    it('escapes HTML in text', () => {
-      const result = renderTemplate({ type: 'lower-third', text: '<script>alert("xss")</script>' });
-      expect(result.contentHtml).not.toContain('<script>');
-      expect(result.contentHtml).toContain('&lt;script&gt;');
-    });
-  });
-
-  describe('headline-card', () => {
-    it('renders title', () => {
-      const result = renderTemplate({ type: 'headline-card', title: 'Big Title' });
-      expect(result.contentHtml).toContain('Big Title');
-    });
-    it('renders kicker when provided', () => {
-      const result = renderTemplate({ type: 'headline-card', title: 'Title', kicker: 'LABEL' });
-      expect(result.contentHtml).toContain('LABEL');
-    });
-    it('renders body when provided', () => {
-      const result = renderTemplate({ type: 'headline-card', title: 'Title', body: 'Details here' });
-      expect(result.contentHtml).toContain('Details here');
-    });
-    it('omits kicker element when not provided', () => {
-      const result = renderTemplate({ type: 'headline-card', title: 'Title' });
-      expect(result.contentHtml).not.toContain('uppercase');
-    });
-    it('has backdrop blur style', () => {
-      const result = renderTemplate({ type: 'headline-card', title: 'T' });
-      expect(result.styles.backdropFilter).toContain('blur');
-    });
-  });
-
-  describe('callout', () => {
-    it('renders text in a compact bubble', () => {
-      const result = renderTemplate({ type: 'callout', text: 'Note this' });
-      expect(result.contentHtml).toContain('Note this');
-      expect(result.styles.borderRadius).toBeDefined();
-    });
-  });
-
-  describe('image-card', () => {
-    it('renders img tag with src', () => {
-      const result = renderTemplate({ type: 'image-card', src: 'http://localhost:9999/diagram.png' });
-      expect(result.contentHtml).toContain('<img');
-      expect(result.contentHtml).toContain('http://localhost:9999/diagram.png');
-    });
-    it('renders title when provided', () => {
-      const result = renderTemplate({ type: 'image-card', src: 'http://x/img.png', title: 'Architecture' });
-      expect(result.contentHtml).toContain('Architecture');
-    });
-    it('renders body when provided', () => {
-      const result = renderTemplate({ type: 'image-card', src: 'http://x/img.png', body: 'Description' });
-      expect(result.contentHtml).toContain('Description');
-    });
-  });
-});

package/tests/overlays/types.test.ts

@@ -1,36 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { isValidZone, isValidTemplateType, isValidMotion } from '../../src/overlays/types.js';
-
-describe('isValidZone', () => {
-  it('accepts all defined zones', () => {
-    for (const z of ['bottom-center', 'top-left', 'top-right', 'bottom-left', 'bottom-right', 'center']) {
-      expect(isValidZone(z)).toBe(true);
-    }
-  });
-  it('rejects unknown zones', () => {
-    expect(isValidZone('middle')).toBe(false);
-    expect(isValidZone('')).toBe(false);
-  });
-});
-
-describe('isValidTemplateType', () => {
-  it('accepts all defined types', () => {
-    for (const t of ['lower-third', 'headline-card', 'callout', 'image-card']) {
-      expect(isValidTemplateType(t)).toBe(true);
-    }
-  });
-  it('rejects unknown types', () => {
-    expect(isValidTemplateType('banner')).toBe(false);
-  });
-});
-
-describe('isValidMotion', () => {
-  it('accepts defined motions and none', () => {
-    expect(isValidMotion('fade-in')).toBe(true);
-    expect(isValidMotion('slide-in')).toBe(true);
-    expect(isValidMotion('none')).toBe(true);
-  });
-  it('rejects unknown motions', () => {
-    expect(isValidMotion('bounce')).toBe(false);
-  });
-});

package/tests/overlays/zones.test.ts

@@ -1,49 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { injectIntoZone, removeZone, ZONE_ID_PREFIX } from '../../src/overlays/zones.js';
-import type { Page } from '@playwright/test';
-
-function createMockPage() {
-  return {
-    evaluate: vi.fn(),
-    waitForTimeout: vi.fn(),
-  } as unknown as Page;
-}
-
-describe('ZONE_ID_PREFIX', () => {
-  it('is argo-overlay-', () => {
-    expect(ZONE_ID_PREFIX).toBe('argo-overlay-');
-  });
-});
-
-describe('injectIntoZone', () => {
-  let page: Page;
-
-  beforeEach(() => {
-    page = createMockPage();
-  });
-
-  it('calls page.evaluate with zone ID', async () => {
-    await injectIntoZone(page, 'top-left', '<div>Hello</div>', { color: 'red' });
-    expect(page.evaluate).toHaveBeenCalledTimes(1);
-    const [fn, args] = (page.evaluate as any).mock.calls[0];
-    expect(typeof fn).toBe('function');
-    expect(args[0]).toBe('argo-overlay-top-left');
-  });
-
-  it('uses bottom-center zone ID correctly', async () => {
-    await injectIntoZone(page, 'bottom-center', '<span>text</span>', {});
-    const [, args] = (page.evaluate as any).mock.calls[0];
-    expect(args[0]).toBe('argo-overlay-bottom-center');
-  });
-});
-
-describe('removeZone', () => {
-  it('calls page.evaluate to remove element by zone ID', async () => {
-    const page = createMockPage();
-    await removeZone(page, 'top-left');
-    expect(page.evaluate).toHaveBeenCalledTimes(1);
-    const [fn, arg] = (page.evaluate as any).mock.calls[0];
-    expect(typeof fn).toBe('function');
-    expect(arg).toBe('argo-overlay-top-left');
-  });
-});

package/tests/pipeline.test.ts

@@ -1,177 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-
-vi.mock('../src/tts/generate.js', () => ({
-  generateClips: vi.fn(),
-}));
-
-vi.mock('../src/record.js', () => ({
-  record: vi.fn(),
-}));
-
-vi.mock('../src/export.js', () => ({
-  checkFfmpeg: vi.fn(),
-  exportVideo: vi.fn(),
-}));
-
-// Mock execFileSync (used by getVideoDurationMs for ffprobe)
-vi.mock('node:child_process', () => ({
-  execFileSync: vi.fn().mockReturnValue('16.240\n'),
-}));
-
-import { execFileSync } from 'node:child_process';
-import { generateClips } from '../src/tts/generate.js';
-import { record } from '../src/record.js';
-import { checkFfmpeg, exportVideo } from '../src/export.js';
-import { runPipeline } from '../src/pipeline.js';
-import { createWavBuffer } from '../src/tts/engine.js';
-import type { ArgoConfig } from '../src/config.js';
-
-const mockedExecFileSync = vi.mocked(execFileSync);
-const mockedGenerateClips = vi.mocked(generateClips);
-const mockedRecord = vi.mocked(record);
-const mockedCheckFfmpeg = vi.mocked(checkFfmpeg);
-const mockedExportVideo = vi.mocked(exportVideo);
-
-const DEMO_NAME = 'test-demo';
-const ARGO_DIR = join('.argo', DEMO_NAME);
-const TIMING_PATH = join(ARGO_DIR, '.timing.json');
-const VIDEO_PATH = join(ARGO_DIR, 'video.webm');
-
-const mockEngine = { generate: vi.fn().mockResolvedValue(Buffer.from('fake')) };
-
-const defaultConfig: Pick<ArgoConfig, 'baseURL' | 'demosDir' | 'outputDir' | 'tts' | 'video' | 'export'> = {
-  baseURL: 'http://localhost:3000',
-  demosDir: 'demos',
-  outputDir: 'videos',
-  tts: { defaultVoice: 'af_heart', defaultSpeed: 1.0, engine: mockEngine },
-  video: { width: 1920, height: 1080, fps: 30 },
-  export: { preset: 'slow', crf: 16 },
-};
-
-function setupFixtures() {
-  mkdirSync(join(ARGO_DIR, 'clips'), { recursive: true });
-  // Write a minimal timing file
-  writeFileSync(TIMING_PATH, JSON.stringify({ intro: 1000, done: 5000 }));
-  // Write a minimal video placeholder (ffprobe is mocked)
-  writeFileSync(VIDEO_PATH, Buffer.from('fake-video'));
-  // Write clip WAV files
-  const silence = createWavBuffer(new Float32Array(24000), 24000); // 1s silence
-  writeFileSync(join(ARGO_DIR, 'clips', 'intro.wav'), silence);
-  writeFileSync(join(ARGO_DIR, 'clips', 'done.wav'), silence);
-}
-
-beforeEach(() => {
-  vi.resetAllMocks();
-  rmSync('.argo', { recursive: true, force: true });
-  setupFixtures();
-
-  mockedExecFileSync.mockReturnValue('16.240\n');
-  mockedCheckFfmpeg.mockReturnValue(true);
-  mockedGenerateClips.mockResolvedValue([
-    { scene: 'intro', clipPath: join(ARGO_DIR, 'clips', 'intro.wav') },
-    { scene: 'done', clipPath: join(ARGO_DIR, 'clips', 'done.wav') },
-  ]);
-  mockedRecord.mockResolvedValue({ videoPath: VIDEO_PATH, timingPath: TIMING_PATH });
-  mockedExportVideo.mockResolvedValue(`videos/${DEMO_NAME}.mp4`);
-});
-
-describe('runPipeline', () => {
-  it('calls checkFfmpeg before other steps', async () => {
-    const callOrder: string[] = [];
-    mockedCheckFfmpeg.mockImplementation(() => { callOrder.push('checkFfmpeg'); return true; });
-    mockedGenerateClips.mockImplementation(async () => {
-      callOrder.push('generateClips');
-      return [
-        { scene: 'intro', clipPath: join(ARGO_DIR, 'clips', 'intro.wav') },
-        { scene: 'done', clipPath: join(ARGO_DIR, 'clips', 'done.wav') },
-      ];
-    });
-    mockedRecord.mockImplementation(async () => { callOrder.push('record'); return { videoPath: VIDEO_PATH, timingPath: TIMING_PATH }; });
-    mockedExportVideo.mockImplementation(async () => { callOrder.push('exportVideo'); return 'out.mp4'; });
-
-    await runPipeline(DEMO_NAME, defaultConfig);
-    expect(callOrder[0]).toBe('checkFfmpeg');
-  });
-
-  it('calls steps in order: generateClips → record → exportVideo', async () => {
-    const callOrder: string[] = [];
-    mockedCheckFfmpeg.mockImplementation(() => { callOrder.push('checkFfmpeg'); return true; });
-    mockedGenerateClips.mockImplementation(async () => {
-      callOrder.push('generateClips');
-      return [
-        { scene: 'intro', clipPath: join(ARGO_DIR, 'clips', 'intro.wav') },
-        { scene: 'done', clipPath: join(ARGO_DIR, 'clips', 'done.wav') },
-      ];
-    });
-    mockedRecord.mockImplementation(async () => { callOrder.push('record'); return { videoPath: VIDEO_PATH, timingPath: TIMING_PATH }; });
-    mockedExportVideo.mockImplementation(async () => { callOrder.push('exportVideo'); return 'out.mp4'; });
-
-    await runPipeline(DEMO_NAME, defaultConfig);
-    expect(callOrder).toEqual(['checkFfmpeg', 'generateClips', 'record', 'exportVideo']);
-  });
-
-  it('returns the output path from exportVideo', async () => {
-    const result = await runPipeline(DEMO_NAME, defaultConfig);
-    expect(result).toBe(`videos/${DEMO_NAME}.mp4`);
-  });
-
-  it('passes correct options to generateClips', async () => {
-    await runPipeline(DEMO_NAME, defaultConfig);
-    expect(mockedGenerateClips).toHaveBeenCalledWith({
-      manifestPath: `demos/${DEMO_NAME}.voiceover.json`,
-      demoName: DEMO_NAME,
-      engine: mockEngine,
-      projectRoot: '.',
-      defaults: { voice: 'af_heart', speed: 1.0 },
-    });
-  });
-
-  it('passes correct options to record', async () => {
-    await runPipeline(DEMO_NAME, defaultConfig);
-    expect(mockedRecord).toHaveBeenCalledWith(DEMO_NAME, {
-      demosDir: 'demos',
-      baseURL: 'http://localhost:3000',
-      video: { width: 1920, height: 1080 },
-    });
-  });
-
-  it('passes correct options to exportVideo', async () => {
-    await runPipeline(DEMO_NAME, defaultConfig);
-    expect(mockedExportVideo).toHaveBeenCalledWith({
-      demoName: DEMO_NAME,
-      argoDir: '.argo',
-      outputDir: 'videos',
-      preset: 'slow',
-      crf: 16,
-      fps: 30,
-    });
-  });
-
-  it('writes narration-aligned.wav to .argo/<demo>/', async () => {
-    const { existsSync } = await import('node:fs');
-    await runPipeline(DEMO_NAME, defaultConfig);
-    expect(existsSync(join(ARGO_DIR, 'narration-aligned.wav'))).toBe(true);
-  });
-
-  it('propagates error from checkFfmpeg', async () => {
-    mockedCheckFfmpeg.mockImplementation(() => { throw new Error('ffmpeg not found'); });
-    await expect(runPipeline(DEMO_NAME, defaultConfig)).rejects.toThrow('ffmpeg not found');
-  });
-
-  it('propagates error from generateClips', async () => {
-    mockedGenerateClips.mockRejectedValue(new Error('TTS failed'));
-    await expect(runPipeline(DEMO_NAME, defaultConfig)).rejects.toThrow('TTS failed');
-  });
-
-  it('propagates error from record', async () => {
-    mockedRecord.mockRejectedValue(new Error('Recording failed'));
-    await expect(runPipeline(DEMO_NAME, defaultConfig)).rejects.toThrow('Recording failed');
-  });
-
-  it('propagates error from exportVideo', async () => {
-    mockedExportVideo.mockRejectedValue(new Error('Export failed'));
-    await expect(runPipeline(DEMO_NAME, defaultConfig)).rejects.toThrow('Export failed');
-  });
-});

package/tests/record.test.ts

@@ -1,87 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-import { tmpdir } from 'node:os';
-
-const { execFileMock } = vi.hoisted(() => ({
-  execFileMock: vi.fn(),
-}));
-
-vi.mock('node:child_process', () => ({
-  execFile: execFileMock,
-}));
-
-import { record } from '../src/record.js';
-
-const originalCwd = process.cwd();
-
-describe('record', () => {
-  let tempDir: string;
-
-  beforeEach(async () => {
-    execFileMock.mockReset();
-    tempDir = await mkdtemp(join(tmpdir(), 'argo-record-'));
-    process.chdir(tempDir);
-    mkdirSync('custom-demos', { recursive: true });
-  });
-
-  afterEach(async () => {
-    process.chdir(originalCwd);
-    await rm(tempDir, { recursive: true, force: true });
-  });
-
-  it('generates a Playwright config from record options and copies artifacts', async () => {
-    execFileMock.mockImplementation((_cmd, args, options, callback) => {
-      const testResultsDir = resolve(tempDir, 'test-results');
-      const argoOutputDir = options.env.ARGO_OUTPUT_DIR as string;
-
-      mkdirSync(join(testResultsDir, 'demo-run'), { recursive: true });
-      writeFileSync(join(testResultsDir, 'demo-run', 'video.webm'), 'video');
-      mkdirSync(resolve(tempDir, argoOutputDir), { recursive: true });
-      writeFileSync(resolve(tempDir, argoOutputDir, '.timing.json'), '{}');
-
-      callback(null, '', '');
-      return {} as never;
-    });
-
-    const result = await record('demo', {
-      demosDir: 'custom-demos',
-      baseURL: 'http://localhost:4321',
-      video: { width: 1280, height: 720 },
-    });
-
-    const configPath = join(tempDir, '.argo', 'demo', 'playwright.record.config.mjs');
-    const config = readFileSync(configPath, 'utf-8');
-
-    expect(config).toContain(`testDir: ${JSON.stringify(resolve('custom-demos'))}`);
-    expect(config).toContain(`baseURL: ${JSON.stringify('http://localhost:4321')}`);
-    expect(config).toContain('viewport: { width: 1280, height: 720 }');
-    expect(config).toContain('size: { width: 1280, height: 720 }');
-    expect(existsSync(join(tempDir, '.argo', 'demo', 'video.webm'))).toBe(true);
-    expect(result).toEqual({
-      videoPath: join('.argo', 'demo', 'video.webm'),
-      timingPath: join('.argo', 'demo', '.timing.json'),
-    });
-    expect(execFileMock).toHaveBeenCalledWith(
-      'npx',
-      [
-        'playwright',
-        'test',
-        '--config',
-        join('.argo', 'demo', 'playwright.record.config.mjs'),
-        '--grep',
-        'demo',
-        '--project',
-        'demos',
-      ],
-      expect.objectContaining({
-        env: expect.objectContaining({
-          ARGO_OUTPUT_DIR: join('.argo', 'demo'),
-          BASE_URL: 'http://localhost:4321',
-        }),
-      }),
-      expect.any(Function),
-    );
-  });
-});

package/tests/tts/align.test.ts

@@ -1,118 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  alignClips,
-  type SceneTiming,
-  type ClipInfo,
-  type Placement,
-  type AlignResult,
-} from '../../src/tts/align.js';
-
-function makeClip(scene: string, durationMs: number, fillValue = 0): ClipInfo {
-  const sampleRate = 24_000;
-  const numSamples = Math.round((durationMs / 1000) * sampleRate);
-  const samples = new Float32Array(numSamples);
-  if (fillValue !== 0) samples.fill(fillValue);
-  return { scene, durationMs, samples };
-}
-
-describe('alignClips', () => {
-  it('places clips at their scene timestamps (no overlap)', () => {
-    const timing: SceneTiming = { intro: 0, middle: 5000, end: 10000 };
-    const clips: ClipInfo[] = [
-      makeClip('intro', 2000),
-      makeClip('middle', 2000),
-      makeClip('end', 2000),
-    ];
-    const result = alignClips(timing, clips, 15000);
-    expect(result.placements).toEqual([
-      { scene: 'intro', startMs: 0, endMs: 2000 },
-      { scene: 'middle', startMs: 5000, endMs: 7000 },
-      { scene: 'end', startMs: 10000, endMs: 12000 },
-    ]);
-  });
-
-  it('prevents overlap with 100ms gap', () => {
-    const timing: SceneTiming = { a: 0, b: 1000 };
-    // Clip 'a' is 2000ms, so it extends past b's timestamp of 1000ms
-    const clips: ClipInfo[] = [
-      makeClip('a', 2000),
-      makeClip('b', 500),
-    ];
-    const result = alignClips(timing, clips, 5000);
-    // 'b' should be pushed to 2000 + 100 = 2100
-    expect(result.placements).toEqual([
-      { scene: 'a', startMs: 0, endMs: 2000 },
-      { scene: 'b', startMs: 2100, endMs: 2600 },
-    ]);
-  });
-
-  it('output buffer has correct total duration', () => {
-    const timing: SceneTiming = { x: 0 };
-    const clips: ClipInfo[] = [makeClip('x', 500)];
-    const sampleRate = 24_000;
-    const totalDurationMs = 10000;
-    const result = alignClips(timing, clips, totalDurationMs, sampleRate);
-    const expectedSamples = Math.round((totalDurationMs / 1000) * sampleRate);
-    expect(result.samples.length).toBe(expectedSamples);
-  });
-
-  it('mixes samples at correct positions', () => {
-    const timing: SceneTiming = { a: 1000 };
-    const fillValue = 0.5;
-    const clips: ClipInfo[] = [makeClip('a', 100, fillValue)];
-    const sampleRate = 24_000;
-    const result = alignClips(timing, clips, 3000, sampleRate);
-
-    const startSample = Math.round((1000 / 1000) * sampleRate);
-    const clipSamples = Math.round((100 / 1000) * sampleRate);
-
-    // Before clip: silence
-    expect(result.samples[0]).toBe(0);
-    // At clip start
-    expect(result.samples[startSample]).toBe(fillValue);
-    // At clip end - 1
-    expect(result.samples[startSample + clipSamples - 1]).toBe(fillValue);
-    // After clip: silence
-    expect(result.samples[startSample + clipSamples]).toBe(0);
-  });
-
-  it('handles empty clips array', () => {
-    const timing: SceneTiming = { a: 0 };
-    const result = alignClips(timing, [], 5000);
-    expect(result.placements).toEqual([]);
-    expect(result.samples.length).toBe(Math.round((5000 / 1000) * 24_000));
-    // All silence
-    expect(result.samples.every((s) => s === 0)).toBe(true);
-  });
-
-  it('orders by timestamp, not input order', () => {
-    const timing: SceneTiming = { first: 0, second: 3000, third: 6000 };
-    // Provide clips in reverse order
-    const clips: ClipInfo[] = [
-      makeClip('third', 1000),
-      makeClip('first', 1000),
-      makeClip('second', 1000),
-    ];
-    const result = alignClips(timing, clips, 10000);
-    expect(result.placements.map((p) => p.scene)).toEqual([
-      'first',
-      'second',
-      'third',
-    ]);
-  });
-
-  it('skips clips whose scene is not in timing data', () => {
-    const timing: SceneTiming = { a: 0, b: 3000 };
-    const clips: ClipInfo[] = [
-      makeClip('a', 1000),
-      makeClip('unknown', 1000),
-      makeClip('b', 1000),
-    ];
-    const result = alignClips(timing, clips, 6000);
-    expect(result.placements).toEqual([
-      { scene: 'a', startMs: 0, endMs: 1000 },
-      { scene: 'b', startMs: 3000, endMs: 4000 },
-    ]);
-    expect(result.placements.some((p) => p.scene === 'unknown')).toBe(false);
-  });
-});

package/tests/tts/cache.test.ts

@@ -1,110 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-import crypto from 'node:crypto';
-import { createWavBuffer } from '../../src/tts/engine.js';
-import { ClipCache, type ManifestEntry } from '../../src/tts/cache.js';
-
-function makeTmpDir(): string {
-  return fs.mkdtempSync(path.join(os.tmpdir(), 'argo-cache-test-'));
-}
-
-function makeHash(entry: ManifestEntry): string {
-  const { scene, text, voice, speed } = entry;
-  return crypto.createHash('sha256').update(JSON.stringify({ scene, text, voice, speed })).digest('hex');
-}
-
-describe('ClipCache', () => {
-  let tmpDir: string;
-  let cache: ClipCache;
-
-  beforeEach(() => {
-    tmpDir = makeTmpDir();
-    cache = new ClipCache(tmpDir);
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  const entry: ManifestEntry = { scene: 'intro', text: 'Hello world' };
-  const demoName = 'demo1';
-
-  function makeWav(): Buffer {
-    return createWavBuffer(new Float32Array([0.1, 0.2, 0.3]));
-  }
-
-  describe('isCached', () => {
-    it('returns false when not cached', () => {
-      expect(cache.isCached(demoName, entry)).toBe(false);
-    });
-
-    it('returns true after caching', () => {
-      cache.cacheClip(demoName, entry, makeWav());
-      expect(cache.isCached(demoName, entry)).toBe(true);
-    });
-  });
-
-  describe('getCachedClip', () => {
-    it('returns null when not cached', () => {
-      expect(cache.getCachedClip(demoName, entry)).toBeNull();
-    });
-
-    it('returns buffer when cached', () => {
-      const wav = makeWav();
-      cache.cacheClip(demoName, entry, wav);
-      const result = cache.getCachedClip(demoName, entry);
-      expect(result).not.toBeNull();
-      expect(Buffer.compare(result!, wav)).toBe(0);
-    });
-  });
-
-  describe('cacheClip', () => {
-    it('creates directory structure and writes file named by hash', () => {
-      const wav = makeWav();
-      cache.cacheClip(demoName, entry, wav);
-
-      const hash = makeHash(entry);
-      const expectedPath = path.join(tmpDir, '.argo', demoName, 'clips', `${hash}.wav`);
-      expect(fs.existsSync(expectedPath)).toBe(true);
-
-      const contents = fs.readFileSync(expectedPath);
-      expect(Buffer.compare(contents, wav)).toBe(0);
-    });
-  });
-
-  describe('getClipPath', () => {
-    it('returns correct path', () => {
-      const hash = makeHash(entry);
-      const expected = path.join(tmpDir, '.argo', demoName, 'clips', `${hash}.wav`);
-      expect(cache.getClipPath(demoName, entry)).toBe(expected);
-    });
-  });
-
-  describe('invalidation', () => {
-    it('different text produces different hash', () => {
-      const entry2: ManifestEntry = { scene: 'intro', text: 'Goodbye world' };
-      expect(cache.getClipPath(demoName, entry)).not.toBe(cache.getClipPath(demoName, entry2));
-    });
-
-    it('different voice produces different hash', () => {
-      const entry2: ManifestEntry = { scene: 'intro', text: 'Hello world', voice: 'alloy' };
-      expect(cache.getClipPath(demoName, entry)).not.toBe(cache.getClipPath(demoName, entry2));
-    });
-
-    it('different speed produces different hash', () => {
-      const entry2: ManifestEntry = { scene: 'intro', text: 'Hello world', speed: 1.5 };
-      expect(cache.getClipPath(demoName, entry)).not.toBe(cache.getClipPath(demoName, entry2));
-    });
-  });
-
-  describe('independent per demo name', () => {
-    it('caching under one demo does not affect another', () => {
-      const wav = makeWav();
-      cache.cacheClip('demoA', entry, wav);
-      expect(cache.isCached('demoA', entry)).toBe(true);
-      expect(cache.isCached('demoB', entry)).toBe(false);
-    });
-  });
-});