@argo-video/cli 0.1.0 → 0.1.1

package/tests/export.test.ts

@@ -1,155 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-
-vi.mock('node:child_process', () => ({
-  execFileSync: vi.fn(),
-  spawnSync: vi.fn(),
-}));
-
-vi.mock('node:fs', () => ({
-  existsSync: vi.fn(),
-  mkdirSync: vi.fn(),
-}));
-
-import { execFileSync, spawnSync } from 'node:child_process';
-import { existsSync, mkdirSync } from 'node:fs';
-import { checkFfmpeg, exportVideo } from '../src/export.js';
-
-const mockedExecFileSync = vi.mocked(execFileSync);
-const mockedSpawnSync = vi.mocked(spawnSync);
-const mockedExistsSync = vi.mocked(existsSync);
-const mockedMkdirSync = vi.mocked(mkdirSync);
-
-beforeEach(() => {
-  vi.resetAllMocks();
-});
-
-// ---------- checkFfmpeg ----------
-describe('checkFfmpeg', () => {
-  it('returns true when ffmpeg is available', () => {
-    mockedExecFileSync.mockReturnValue(Buffer.from('ffmpeg version 6.0'));
-    expect(checkFfmpeg()).toBe(true);
-    expect(mockedExecFileSync).toHaveBeenCalledWith('ffmpeg', ['-version'], { stdio: 'pipe' });
-  });
-
-  it('throws with install instructions when ffmpeg is missing', () => {
-    mockedExecFileSync.mockImplementation(() => {
-      throw new Error('command not found');
-    });
-    expect(() => checkFfmpeg()).toThrow(/ffmpeg is not installed/i);
-    expect(() => checkFfmpeg()).toThrow(/brew install ffmpeg/);
-    expect(() => checkFfmpeg()).toThrow(/apt install ffmpeg/);
-    expect(() => checkFfmpeg()).toThrow(/choco install ffmpeg/);
-  });
-});
-
-// ---------- exportVideo ----------
-describe('exportVideo', () => {
-  function setupHappy() {
-    mockedExecFileSync.mockReturnValue(Buffer.from('ok'));
-    mockedExistsSync.mockReturnValue(true);
-    mockedSpawnSync.mockReturnValue({ status: 0 } as any);
-  }
-
-  it('builds correct default ffmpeg args', async () => {
-    setupHappy();
-    const result = await exportVideo({ demoName: 'my-demo', argoDir: '.argo', outputDir: 'videos' });
-
-    expect(mockedSpawnSync).toHaveBeenCalledTimes(1);
-    const [cmd, args] = mockedSpawnSync.mock.calls[0];
-    expect(cmd).toBe('ffmpeg');
-    expect(args).toEqual([
-      '-i', '.argo/my-demo/video.webm',
-      '-i', '.argo/my-demo/narration-aligned.wav',
-      '-c:v', 'libx264',
-      '-preset', 'slow',
-      '-crf', '16',
-      '-c:a', 'aac',
-      '-b:a', '192k',
-      '-shortest',
-      '-y',
-      'videos/my-demo.mp4',
-    ]);
-    expect(result).toBe('videos/my-demo.mp4');
-  });
-
-  it('applies custom preset and crf', async () => {
-    setupHappy();
-    await exportVideo({ demoName: 'demo', argoDir: '.argo', outputDir: 'out', preset: 'fast', crf: 23 });
-
-    const [, args] = mockedSpawnSync.mock.calls[0];
-    expect(args).toContain('fast');
-    expect(args).toContain('23');
-  });
-
-  it('adds -r flag when fps is specified', async () => {
-    setupHappy();
-    await exportVideo({ demoName: 'demo', argoDir: '.argo', outputDir: 'out', fps: 30 });
-
-    const [, args] = mockedSpawnSync.mock.calls[0];
-    const rIdx = (args as string[]).indexOf('-r');
-    expect(rIdx).toBeGreaterThan(-1);
-    expect((args as string[])[rIdx + 1]).toBe('30');
-  });
-
-  it('throws on missing video.webm', async () => {
-    mockedExecFileSync.mockReturnValue(Buffer.from('ok'));
-    mockedExistsSync.mockImplementation((p) => {
-      if (String(p).endsWith('video.webm')) return false;
-      return true;
-    });
-
-    await expect(exportVideo({ demoName: 'demo', argoDir: '.argo', outputDir: 'out' }))
-      .rejects.toThrow(/video\.webm/);
-  });
-
-  it('throws on missing narration-aligned.wav', async () => {
-    mockedExecFileSync.mockReturnValue(Buffer.from('ok'));
-    mockedExistsSync.mockImplementation((p) => {
-      if (String(p).endsWith('narration-aligned.wav')) return false;
-      return true;
-    });
-
-    await expect(exportVideo({ demoName: 'demo', argoDir: '.argo', outputDir: 'out' }))
-      .rejects.toThrow(/narration-aligned\.wav/);
-  });
-
-  it('creates output directory if it does not exist', async () => {
-    mockedExecFileSync.mockReturnValue(Buffer.from('ok'));
-    mockedExistsSync.mockImplementation((p) => {
-      if (String(p) === 'out') return false;
-      return true;
-    });
-    mockedSpawnSync.mockReturnValue({ status: 0 } as any);
-
-    await exportVideo({ demoName: 'demo', argoDir: '.argo', outputDir: 'out' });
-
-    expect(mockedMkdirSync).toHaveBeenCalledWith('out', { recursive: true });
-  });
-
-  it('throws on non-zero exit code', async () => {
-    mockedExecFileSync.mockReturnValue(Buffer.from('ok'));
-    mockedExistsSync.mockReturnValue(true);
-    mockedSpawnSync.mockReturnValue({ status: 1 } as any);
-
-    await expect(exportVideo({ demoName: 'demo', argoDir: '.argo', outputDir: 'out' }))
-      .rejects.toThrow(/ffmpeg.*failed|exit code/i);
-  });
-
-  it('throws with signal info when ffmpeg is killed', async () => {
-    mockedExecFileSync.mockReturnValue(Buffer.from('ok'));
-    mockedExistsSync.mockReturnValue(true);
-    mockedSpawnSync.mockReturnValue({ status: null, signal: 'SIGKILL' } as any);
-
-    await expect(exportVideo({ demoName: 'demo', argoDir: '.argo', outputDir: 'out' }))
-      .rejects.toThrow(/killed by signal SIGKILL/);
-  });
-
-  it('throws with spawn error when ffmpeg cannot be launched', async () => {
-    mockedExecFileSync.mockReturnValue(Buffer.from('ok'));
-    mockedExistsSync.mockReturnValue(true);
-    mockedSpawnSync.mockReturnValue({ status: null, error: new Error('ENOENT') } as any);
-
-    await expect(exportVideo({ demoName: 'demo', argoDir: '.argo', outputDir: 'out' }))
-      .rejects.toThrow(/Failed to launch ffmpeg/);
-  });
-});

package/tests/fixtures.test.ts

@@ -1,74 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { createNarrationFixture, demoType } from '../src/fixtures.js';
-
-// ---------- createNarrationFixture ----------
-describe('createNarrationFixture', () => {
-  it('creates timeline, calls start, provides it via use, calls flush after', async () => {
-    const mockTimeline = {
-      start: vi.fn(),
-      mark: vi.fn(),
-      getTimings: vi.fn(),
-      flush: vi.fn().mockResolvedValue(undefined),
-    };
-    const factory = vi.fn().mockReturnValue(mockTimeline);
-
-    let provided: unknown;
-    const use = vi.fn(async (value: unknown) => {
-      provided = value;
-    });
-    const testInfo = { title: 'my test' };
-
-    const fixture = createNarrationFixture(factory);
-    await fixture({ /* placeholder */ } as any, use, testInfo as any);
-
-    expect(factory).toHaveBeenCalledWith('my test');
-    expect(mockTimeline.start).toHaveBeenCalled();
-    expect(use).toHaveBeenCalledWith(mockTimeline);
-    expect(provided).toBe(mockTimeline);
-    expect(mockTimeline.flush).toHaveBeenCalled();
-  });
-
-  it('calls flush even if test (use callback) throws', async () => {
-    const mockTimeline = {
-      start: vi.fn(),
-      mark: vi.fn(),
-      getTimings: vi.fn(),
-      flush: vi.fn().mockResolvedValue(undefined),
-    };
-    const factory = vi.fn().mockReturnValue(mockTimeline);
-
-    const use = vi.fn(async () => {
-      throw new Error('test failure');
-    });
-    const testInfo = { title: 'failing test' };
-
-    const fixture = createNarrationFixture(factory);
-    await expect(fixture({} as any, use, testInfo as any)).rejects.toThrow('test failure');
-
-    expect(mockTimeline.flush).toHaveBeenCalled();
-  });
-});
-
-// ---------- demoType ----------
-describe('demoType', () => {
-  it('calls locator(selector).pressSequentially(text, {delay: 60})', async () => {
-    const pressSequentially = vi.fn().mockResolvedValue(undefined);
-    const locator = vi.fn().mockReturnValue({ pressSequentially });
-    const page = { locator } as any;
-
-    await demoType(page, '#input', 'hello');
-
-    expect(locator).toHaveBeenCalledWith('#input');
-    expect(pressSequentially).toHaveBeenCalledWith('hello', { delay: 60 });
-  });
-
-  it('accepts custom delay', async () => {
-    const pressSequentially = vi.fn().mockResolvedValue(undefined);
-    const locator = vi.fn().mockReturnValue({ pressSequentially });
-    const page = { locator } as any;
-
-    await demoType(page, '#input', 'hello', 120);
-
-    expect(pressSequentially).toHaveBeenCalledWith('hello', { delay: 120 });
-  });
-});

package/tests/init.test.ts

@@ -1,77 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdtemp, rm, readFile, writeFile, mkdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { init } from '../src/init.js';
-
-describe('init', () => {
-  let dir: string;
-
-  beforeEach(async () => {
-    dir = await mkdtemp(join(tmpdir(), 'argo-init-'));
-  });
-
-  afterEach(async () => {
-    await rm(dir, { recursive: true, force: true });
-  });
-
-  it('creates demos/ directory', async () => {
-    await init(dir);
-    const { stat } = await import('node:fs/promises');
-    const s = await stat(join(dir, 'demos'));
-    expect(s.isDirectory()).toBe(true);
-  });
-
-  it('creates example.demo.ts with correct content', async () => {
-    await init(dir);
-    const content = await readFile(join(dir, 'demos', 'example.demo.ts'), 'utf-8');
-    expect(content).toContain("import { test } from '@argo-video/cli'");
-    expect(content).toContain("import { showCaption, withCaption } from '@argo-video/cli'");
-    expect(content).toContain("narration.mark('welcome')");
-    expect(content).toContain('showCaption(page,');
-    expect(content).toContain('withCaption(page,');
-  });
-
-  it('creates example.voiceover.json with valid JSON array', async () => {
-    await init(dir);
-    const content = await readFile(join(dir, 'demos', 'example.voiceover.json'), 'utf-8');
-    const parsed = JSON.parse(content);
-    expect(Array.isArray(parsed)).toBe(true);
-    expect(parsed.length).toBe(3);
-    expect(parsed[0]).toHaveProperty('scene');
-    expect(parsed[0]).toHaveProperty('text');
-  });
-
-  it('creates example.overlays.json with valid JSON array', async () => {
-    await init(dir);
-    const content = await readFile(join(dir, 'demos', 'example.overlays.json'), 'utf-8');
-    const parsed = JSON.parse(content);
-    expect(Array.isArray(parsed)).toBe(true);
-    expect(parsed.length).toBe(2);
-    expect(parsed[0]).toHaveProperty('scene');
-    expect(parsed[0]).toHaveProperty('type');
-    expect(parsed[1].type).toBe('headline-card');
-    expect(parsed[1].placement).toBe('top-left');
-  });
-
-  it('creates argo.config.js with config', async () => {
-    await init(dir);
-    const content = await readFile(join(dir, 'argo.config.js'), 'utf-8');
-    expect(content).toContain('export default');
-    expect(content).toContain('baseURL');
-  });
-
-  it('does NOT overwrite existing files', async () => {
-    await mkdir(join(dir, 'demos'), { recursive: true });
-    await writeFile(join(dir, 'demos', 'example.demo.ts'), 'existing content');
-    await writeFile(join(dir, 'argo.config.js'), 'existing config');
-
-    await init(dir);
-
-    const demo = await readFile(join(dir, 'demos', 'example.demo.ts'), 'utf-8');
-    expect(demo).toBe('existing content');
-
-    const config = await readFile(join(dir, 'argo.config.js'), 'utf-8');
-    expect(config).toBe('existing config');
-  });
-});

package/tests/narration.test.ts

@@ -1,120 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { join } from 'node:path';
-import { mkdtemp, rm, readFile, stat } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { NarrationTimeline } from '../src/narration.js';
-
-// ---------- start ----------
-describe('start', () => {
-  it('sets t=0 — a mark immediately after should be <50ms', () => {
-    const timeline = new NarrationTimeline();
-    timeline.start();
-    timeline.mark('intro');
-    const timings = timeline.getTimings();
-    expect(timings.intro).toBeGreaterThanOrEqual(0);
-    expect(timings.intro).toBeLessThan(50);
-  });
-
-  it('clears existing timings on re-start', () => {
-    const timeline = new NarrationTimeline();
-    timeline.start();
-    timeline.mark('scene1');
-    timeline.start();
-    expect(timeline.getTimings()).toEqual({});
-  });
-});
-
-// ---------- mark ----------
-describe('mark', () => {
-  it('throws if called before start()', () => {
-    const timeline = new NarrationTimeline();
-    expect(() => timeline.mark('intro')).toThrow();
-  });
-
-  it('records elapsed ms (~100ms delay)', async () => {
-    const timeline = new NarrationTimeline();
-    timeline.start();
-    await new Promise((r) => setTimeout(r, 100));
-    timeline.mark('after-delay');
-    const timings = timeline.getTimings();
-    expect(timings['after-delay']).toBeGreaterThanOrEqual(80);
-    expect(timings['after-delay']).toBeLessThan(300);
-  });
-
-  it('throws on duplicate scene name', () => {
-    const timeline = new NarrationTimeline();
-    timeline.start();
-    timeline.mark('scene1');
-    expect(() => timeline.mark('scene1')).toThrow();
-  });
-});
-
-// ---------- getTimings ----------
-describe('getTimings', () => {
-  it('returns empty object before any marks', () => {
-    const timeline = new NarrationTimeline();
-    timeline.start();
-    expect(timeline.getTimings()).toEqual({});
-  });
-
-  it('returns all recorded marks', () => {
-    const timeline = new NarrationTimeline();
-    timeline.start();
-    timeline.mark('a');
-    timeline.mark('b');
-    timeline.mark('c');
-    const timings = timeline.getTimings();
-    expect(Object.keys(timings)).toEqual(['a', 'b', 'c']);
-  });
-
-  it('returns a copy — mutations do not affect internal state', () => {
-    const timeline = new NarrationTimeline();
-    timeline.start();
-    timeline.mark('scene1');
-    const timings = timeline.getTimings();
-    timings.scene1 = 99999;
-    timings.injected = 1;
-    const fresh = timeline.getTimings();
-    expect(fresh.scene1).not.toBe(99999);
-    expect(fresh).not.toHaveProperty('injected');
-  });
-});
-
-// ---------- flush ----------
-describe('flush', () => {
-  let tmpDir: string;
-
-  beforeEach(async () => {
-    tmpDir = await mkdtemp(join(tmpdir(), 'argo-narration-test-'));
-  });
-
-  afterEach(async () => {
-    await rm(tmpDir, { recursive: true, force: true });
-  });
-
-  it('writes a .timing.json file', async () => {
-    const timeline = new NarrationTimeline();
-    timeline.start();
-    timeline.mark('intro');
-    timeline.mark('outro');
-    const outPath = join(tmpDir, 'demo.timing.json');
-    await timeline.flush(outPath);
-
-    const raw = await readFile(outPath, 'utf-8');
-    const data = JSON.parse(raw);
-    expect(data).toHaveProperty('intro');
-    expect(data).toHaveProperty('outro');
-    expect(typeof data.intro).toBe('number');
-  });
-
-  it('creates parent directories if they do not exist', async () => {
-    const timeline = new NarrationTimeline();
-    timeline.start();
-    timeline.mark('scene1');
-    const outPath = join(tmpDir, 'nested', 'deep', 'output.timing.json');
-    await timeline.flush(outPath);
-
-    const info = await stat(outPath);
-    expect(info.isFile()).toBe(true);
-  });
-});

package/tests/overlays/index.test.ts

@@ -1,73 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { showOverlay, hideOverlay, withOverlay } from '../../src/overlays/index.js';
-import type { Page } from '@playwright/test';
-
-function createMockPage() {
-  return {
-    evaluate: vi.fn(),
-    waitForTimeout: vi.fn(),
-  } as unknown as Page;
-}
-
-describe('showOverlay', () => {
-  let page: Page;
-  beforeEach(() => { page = createMockPage(); });
-
-  it('injects overlay and removes after duration', async () => {
-    await showOverlay(page, 'intro', { type: 'lower-third', text: 'Hello' }, 2000);
-    expect(page.evaluate).toHaveBeenCalledTimes(2);
-    expect(page.waitForTimeout).toHaveBeenCalledWith(2000);
-  });
-
-  it('defaults to bottom-center zone', async () => {
-    await showOverlay(page, 'intro', { type: 'lower-third', text: 'Hi' }, 1000);
-    const [, args] = (page.evaluate as any).mock.calls[0];
-    expect(args[0]).toContain('bottom-center');
-  });
-
-  it('uses specified zone', async () => {
-    await showOverlay(page, 'intro', {
-      type: 'headline-card', title: 'Title', placement: 'top-left',
-    }, 1000);
-    const [, args] = (page.evaluate as any).mock.calls[0];
-    expect(args[0]).toContain('top-left');
-  });
-});
-
-describe('hideOverlay', () => {
-  it('removes overlay from specified zone', async () => {
-    const page = createMockPage();
-    await hideOverlay(page, 'top-left');
-    expect(page.evaluate).toHaveBeenCalledTimes(1);
-  });
-
-  it('defaults to bottom-center', async () => {
-    const page = createMockPage();
-    await hideOverlay(page);
-    const [, arg] = (page.evaluate as any).mock.calls[0];
-    expect(arg).toContain('bottom-center');
-  });
-});
-
-describe('withOverlay', () => {
-  let page: Page;
-  beforeEach(() => { page = createMockPage(); });
-
-  it('shows overlay during action and removes after', async () => {
-    let actionRan = false;
-    await withOverlay(page, 'demo', { type: 'callout', text: 'Watch' }, async () => {
-      actionRan = true;
-    });
-    expect(actionRan).toBe(true);
-    expect(page.evaluate).toHaveBeenCalledTimes(2);
-  });
-
-  it('removes overlay even if action throws', async () => {
-    await expect(
-      withOverlay(page, 'demo', { type: 'lower-third', text: 'Hi' }, async () => {
-        throw new Error('boom');
-      }),
-    ).rejects.toThrow('boom');
-    expect(page.evaluate).toHaveBeenCalledTimes(2);
-  });
-});

package/tests/overlays/manifest.test.ts

@@ -1,120 +0,0 @@
-import { describe, it, expect, afterEach } from 'vitest';
-import { loadOverlayManifest, hasImageAssets, resolveAssetURLs } from '../../src/overlays/manifest.js';
-import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-describe('loadOverlayManifest', () => {
-  let tmpDir: string;
-
-  function setup() {
-    tmpDir = mkdtempSync(join(tmpdir(), 'argo-manifest-'));
-  }
-
-  afterEach(() => {
-    if (tmpDir) rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('returns null when file does not exist', async () => {
-    setup();
-    const result = await loadOverlayManifest(join(tmpDir, 'missing.overlays.json'));
-    expect(result).toBeNull();
-  });
-
-  it('parses a valid manifest', async () => {
-    setup();
-    const manifestPath = join(tmpDir, 'demo.overlays.json');
-    writeFileSync(manifestPath, JSON.stringify([
-      { scene: 'intro', type: 'lower-third', text: 'Hello' },
-      { scene: 'mid', type: 'headline-card', title: 'Title', placement: 'top-left' },
-    ]));
-    const result = await loadOverlayManifest(manifestPath);
-    expect(result).toHaveLength(2);
-    expect(result![0].scene).toBe('intro');
-    expect(result![1].type).toBe('headline-card');
-  });
-
-  it('throws on invalid JSON', async () => {
-    setup();
-    const manifestPath = join(tmpDir, 'bad.overlays.json');
-    writeFileSync(manifestPath, '{ nope }}}');
-    await expect(loadOverlayManifest(manifestPath)).rejects.toThrow('Failed to parse overlay manifest');
-  });
-
-  it('throws when manifest is not an array', async () => {
-    setup();
-    const manifestPath = join(tmpDir, 'obj.overlays.json');
-    writeFileSync(manifestPath, JSON.stringify({ scene: 'x' }));
-    await expect(loadOverlayManifest(manifestPath)).rejects.toThrow('must contain a JSON array');
-  });
-
-  it('throws on entry missing scene', async () => {
-    setup();
-    const manifestPath = join(tmpDir, 'no-scene.overlays.json');
-    writeFileSync(manifestPath, JSON.stringify([{ type: 'lower-third', text: 'Hi' }]));
-    await expect(loadOverlayManifest(manifestPath)).rejects.toThrow('missing required field "scene"');
-  });
-
-  it('throws on entry missing type', async () => {
-    setup();
-    const manifestPath = join(tmpDir, 'no-type.overlays.json');
-    writeFileSync(manifestPath, JSON.stringify([{ scene: 'x', text: 'Hi' }]));
-    await expect(loadOverlayManifest(manifestPath)).rejects.toThrow('missing required field "type"');
-  });
-
-  it('throws on unknown template type', async () => {
-    setup();
-    const manifestPath = join(tmpDir, 'bad-type.overlays.json');
-    writeFileSync(manifestPath, JSON.stringify([{ scene: 'x', type: 'banner', text: 'Hi' }]));
-    await expect(loadOverlayManifest(manifestPath)).rejects.toThrow('unknown overlay type "banner"');
-  });
-
-  it('throws on unknown zone', async () => {
-    setup();
-    const manifestPath = join(tmpDir, 'bad-zone.overlays.json');
-    writeFileSync(manifestPath, JSON.stringify([
-      { scene: 'x', type: 'lower-third', text: 'Hi', placement: 'middle' },
-    ]));
-    await expect(loadOverlayManifest(manifestPath)).rejects.toThrow('unknown placement "middle"');
-  });
-});
-
-describe('hasImageAssets', () => {
-  it('returns true when entries contain image-card', () => {
-    expect(hasImageAssets([
-      { scene: 'x', type: 'image-card', src: 'img.png' },
-    ] as any)).toBe(true);
-  });
-
-  it('returns false when no image-card entries', () => {
-    expect(hasImageAssets([
-      { scene: 'x', type: 'lower-third', text: 'Hi' },
-    ] as any)).toBe(false);
-  });
-});
-
-describe('resolveAssetURLs', () => {
-  it('prefixes relative image-card src with asset server URL', () => {
-    const entries = [
-      { scene: 'x', type: 'image-card' as const, src: 'assets/diagram.png' },
-    ];
-    const resolved = resolveAssetURLs(entries as any, 'http://127.0.0.1:9999');
-    expect(resolved[0]).toHaveProperty('src', 'http://127.0.0.1:9999/diagram.png');
-  });
-
-  it('leaves absolute URLs unchanged', () => {
-    const entries = [
-      { scene: 'x', type: 'image-card' as const, src: 'http://example.com/img.png' },
-    ];
-    const resolved = resolveAssetURLs(entries as any, 'http://127.0.0.1:9999');
-    expect(resolved[0]).toHaveProperty('src', 'http://example.com/img.png');
-  });
-
-  it('leaves non-image-card entries unchanged', () => {
-    const entries = [
-      { scene: 'x', type: 'lower-third' as const, text: 'Hello' },
-    ];
-    const resolved = resolveAssetURLs(entries as any, 'http://127.0.0.1:9999');
-    expect(resolved[0]).toEqual(entries[0]);
-  });
-});

package/tests/overlays/motion.test.ts

@@ -1,34 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { getMotionCSS, getMotionStyles } from '../../src/overlays/motion.js';
-
-describe('getMotionCSS', () => {
-  it('returns empty string for none', () => {
-    expect(getMotionCSS('none', 'argo-overlay-top-left')).toBe('');
-  });
-  it('returns fade-in keyframes', () => {
-    const css = getMotionCSS('fade-in', 'argo-overlay-top-left');
-    expect(css).toContain('@keyframes');
-    expect(css).toContain('opacity');
-    expect(css).toContain('argo-overlay-top-left');
-  });
-  it('returns slide-in keyframes', () => {
-    const css = getMotionCSS('slide-in', 'argo-overlay-top-left');
-    expect(css).toContain('@keyframes');
-    expect(css).toContain('translateX');
-    expect(css).toContain('argo-overlay-top-left');
-  });
-});
-
-describe('getMotionStyles', () => {
-  it('returns empty object for none', () => {
-    expect(getMotionStyles('none', 'test-id')).toEqual({});
-  });
-  it('returns animation property for fade-in', () => {
-    const styles = getMotionStyles('fade-in', 'test-id');
-    expect(styles.animation).toContain('300ms');
-  });
-  it('returns animation property for slide-in', () => {
-    const styles = getMotionStyles('slide-in', 'test-id');
-    expect(styles.animation).toContain('400ms');
-  });
-});