@bendyline/squisq-video-react 2.0.2 → 2.1.0

package/src/__tests__/audioTrack.test.ts

@@ -1,108 +0,0 @@
-/**
- * audioTrack — tier selection + capability probe.
- *
- * The tier decision is the boundary `useVideoExport` delegates to, so testing
- * `selectAudioTier` directly exercises the exact logic the hook runs (jsdom
- * lacks real WebCodecs / OfflineAudioContext, so the end-to-end encode path
- * can only be exercised in a browser). `supportsWebCodecsAac` is verified to
- * degrade to `false` when `AudioEncoder` is undefined (jsdom's state).
- */
-
-import { describe, it, expect } from 'vitest';
-import {
-  selectAudioTier,
-  supportsWebCodecsAac,
-  REASON_NO_AAC_NO_SAB,
-  audioBufferToWav,
-} from '../audioTrack.js';
-
-describe('selectAudioTier', () => {
-  it('tier 1 when AAC is supported on the main-thread WebCodecs encoder', () => {
-    expect(
-      selectAudioTier({
-        hasClips: true,
-        aacSupported: true,
-        sharedArrayBufferAvailable: true,
-        canUseMainThreadWebCodecs: true,
-      }),
-    ).toEqual({ tier: 1, reason: null });
-  });
-
-  it('tier 2 when AAC is unsupported but SharedArrayBuffer (ffmpeg.wasm) is available', () => {
-    expect(
-      selectAudioTier({
-        hasClips: true,
-        aacSupported: false,
-        sharedArrayBufferAvailable: true,
-        canUseMainThreadWebCodecs: false,
-      }),
-    ).toEqual({ tier: 2, reason: null });
-  });
-
-  it('tier 2 when AAC is supported but the main-thread encoder is not in use', () => {
-    // AAC exists but the video is going through the worker/ffmpeg path — the
-    // inline muxer isn't available, so fall back to the ffmpeg mux pass.
-    expect(
-      selectAudioTier({
-        hasClips: true,
-        aacSupported: true,
-        sharedArrayBufferAvailable: true,
-        canUseMainThreadWebCodecs: false,
-      }),
-    ).toEqual({ tier: 2, reason: null });
-  });
-
-  it('tier 3 with a reason when neither AAC nor SharedArrayBuffer is available', () => {
-    expect(
-      selectAudioTier({
-        hasClips: true,
-        aacSupported: false,
-        sharedArrayBufferAvailable: false,
-        canUseMainThreadWebCodecs: false,
-      }),
-    ).toEqual({ tier: 3, reason: REASON_NO_AAC_NO_SAB });
-  });
-
-  it('tier 3 with a null reason when there is no audio to include', () => {
-    expect(
-      selectAudioTier({
-        hasClips: false,
-        aacSupported: true,
-        sharedArrayBufferAvailable: true,
-        canUseMainThreadWebCodecs: true,
-      }),
-    ).toEqual({ tier: 3, reason: null });
-  });
-});
-
-describe('supportsWebCodecsAac', () => {
-  it('returns false when AudioEncoder is undefined (jsdom/Node)', async () => {
-    expect(typeof AudioEncoder).toBe('undefined');
-    await expect(supportsWebCodecsAac()).resolves.toBe(false);
-  });
-});
-
-describe('audioBufferToWav', () => {
-  it('serializes a minimal AudioBuffer-shaped value to a RIFF/WAVE header', () => {
-    // Hand-rolled AudioBuffer stand-in (jsdom has no AudioBuffer). Only the
-    // fields audioBufferToWav reads are provided.
-    const frames = 4;
-    const left = new Float32Array([0, 0.5, -0.5, 1]);
-    const right = new Float32Array([0, -1, 0.25, -0.25]);
-    const fake = {
-      numberOfChannels: 2,
-      sampleRate: 48_000,
-      length: frames,
-      getChannelData: (ch: number) => (ch === 0 ? left : right),
-    } as unknown as AudioBuffer;
-
-    const wav = audioBufferToWav(fake);
-    const ascii = (i: number, n: number) =>
-      String.fromCharCode(...Array.from(wav.subarray(i, i + n)));
-    expect(ascii(0, 4)).toBe('RIFF');
-    expect(ascii(8, 4)).toBe('WAVE');
-    expect(ascii(36, 4)).toBe('data');
-    // 44-byte header + 2 channels * 2 bytes * 4 frames = 60 bytes.
-    expect(wav.byteLength).toBe(44 + frames * 2 * 2);
-  });
-});

package/src/__tests__/gifTranscode.test.ts

@@ -1,118 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-const ffmpegState = vi.hoisted(() => ({
-  exitCode: 0,
-  loadConfig: undefined as unknown,
-  writes: [] as Array<[string, Uint8Array]>,
-  execArgs: [] as string[],
-  readPath: '',
-  execPromise: null as Promise<number> | null,
-  terminate: vi.fn(),
-}));
-
-vi.mock('@ffmpeg/ffmpeg', () => ({
-  FFmpeg: class {
-    async load(config?: unknown): Promise<boolean> {
-      ffmpegState.loadConfig = config;
-      return true;
-    }
-    async writeFile(path: string, data: Uint8Array): Promise<void> {
-      ffmpegState.writes.push([path, data]);
-    }
-    async exec(args: string[]): Promise<number> {
-      ffmpegState.execArgs = args;
-      return ffmpegState.execPromise ?? ffmpegState.exitCode;
-    }
-    async readFile(path: string): Promise<Uint8Array> {
-      ffmpegState.readPath = path;
-      return new Uint8Array([0x47, 0x49, 0x46, 0x38, 0x39, 0x61]);
-    }
-    terminate(): void {
-      ffmpegState.terminate();
-    }
-  },
-}));
-
-import { buildGifFfmpegArgs, transcodeMp4ToGifWithFfmpegWasm } from '../gifTranscode.js';
-
-describe('GIF ffmpeg.wasm transcode', () => {
-  beforeEach(() => {
-    ffmpegState.exitCode = 0;
-    ffmpegState.loadConfig = undefined;
-    ffmpegState.writes = [];
-    ffmpegState.execArgs = [];
-    ffmpegState.readPath = '';
-    ffmpegState.execPromise = null;
-    ffmpegState.terminate.mockClear();
-  });
-
-  it('builds a looping palette-based GIF command from the shared argument builder', () => {
-    const args = buildGifFfmpegArgs({ width: 960, height: 540, loop: 0 });
-    expect(args.slice(0, 3)).toEqual(['-y', '-i', 'video.mp4']);
-    expect(args).toContain('-filter_complex');
-    expect(args.join(' ')).toContain('palettegen=stats_mode=diff');
-    expect(args.join(' ')).toContain('paletteuse=dither=sierra2_4a:diff_mode=rectangle');
-    expect(args.slice(-3)).toEqual(['-loop', '0', 'out.gif']);
-  });
-
-  it('writes the MP4 intermediate, reads GIF89a bytes, and threads runtime URLs', async () => {
-    const input = new Uint8Array([1, 2, 3]);
-    const output = await transcodeMp4ToGifWithFfmpegWasm(
-      input,
-      { width: 960, height: 540 },
-      {
-        coreURL: '/vendor/core.js',
-        wasmURL: '/vendor/core.wasm',
-        classWorkerURL: '/vendor/class-worker.js',
-      },
-    );
-
-    expect(ffmpegState.loadConfig).toEqual({
-      coreURL: '/vendor/core.js',
-      wasmURL: '/vendor/core.wasm',
-      classWorkerURL: '/vendor/class-worker.js',
-    });
-    expect(ffmpegState.writes).toEqual([['video.mp4', input]]);
-    expect(ffmpegState.execArgs.at(-1)).toBe('out.gif');
-    expect(ffmpegState.readPath).toBe('out.gif');
-    expect(new TextDecoder().decode(output)).toBe('GIF89a');
-    expect(ffmpegState.terminate).toHaveBeenCalledOnce();
-  });
-
-  it('reports ffmpeg failures and still terminates the runtime', async () => {
-    ffmpegState.exitCode = 7;
-    await expect(
-      transcodeMp4ToGifWithFfmpegWasm(new Uint8Array([1]), { width: 960, height: 540 }),
-    ).rejects.toThrow('GIF transcode failed with exit code 7');
-    expect(ffmpegState.terminate).toHaveBeenCalledOnce();
-  });
-
-  it('rejects an empty MP4 before allocating the runtime', async () => {
-    await expect(
-      transcodeMp4ToGifWithFfmpegWasm(new Uint8Array(), { width: 960, height: 540 }),
-    ).rejects.toThrow('empty MP4');
-    expect(ffmpegState.terminate).not.toHaveBeenCalled();
-  });
-
-  it('terminates an in-progress palette transcode when aborted', async () => {
-    let finishExec!: (exitCode: number) => void;
-    ffmpegState.execPromise = new Promise<number>((resolve) => {
-      finishExec = resolve;
-    });
-    const controller = new AbortController();
-    const pending = transcodeMp4ToGifWithFfmpegWasm(
-      new Uint8Array([1]),
-      { width: 960, height: 540 },
-      undefined,
-      controller.signal,
-    );
-
-    await vi.waitFor(() => expect(ffmpegState.execArgs).not.toEqual([]));
-    controller.abort();
-    expect(ffmpegState.terminate).toHaveBeenCalledOnce();
-    finishExec(0);
-
-    await expect(pending).rejects.toMatchObject({ name: 'AbortError' });
-    expect(ffmpegState.terminate).toHaveBeenCalledOnce();
-  });
-});

package/src/__tests__/mp4MuxAudio.test.ts

@@ -1,72 +0,0 @@
-/**
- * mp4Mux audio track — verifies the additive AAC track wiring.
- *
- * mp4-muxer runs in Node, so we can add a raw audio sample and assert the
- * finalized MP4 actually carries an `mp4a` sample-description box (i.e. the
- * audio track made it into the container). We also assert the video-only
- * configuration produces no such box, guarding the "byte-identical when no
- * audio" contract.
- */
-
-import { describe, it, expect } from 'vitest';
-import { createMp4Muxer, type Mp4MuxerHandle } from '../mp4Mux.js';
-
-/** Add one stub AVC keyframe so the always-present video track can finalize. */
-function addStubVideoSample(muxer: Mp4MuxerHandle): void {
-  const avcDescription = new Uint8Array([
-    0x01, 0x64, 0x00, 0x28, 0xff, 0xe1, 0x00, 0x04, 0x67, 0x64, 0x00, 0x28, 0x01, 0x00, 0x04, 0x68,
-    0xee, 0x3c, 0x80,
-  ]);
-  muxer.addVideoChunkRaw(new Uint8Array([0x00, 0x00, 0x00, 0x02, 0x09, 0x10]), 'key', 0, 33_333, {
-    decoderConfig: { codec: 'avc1.640028', description: avcDescription },
-  });
-}
-
-/** Find the ASCII 4CC `needle` anywhere in the MP4 bytes. */
-function containsFourCC(buffer: ArrayBuffer, needle: string): boolean {
-  const bytes = new Uint8Array(buffer);
-  const pat = Array.from(needle, (c) => c.charCodeAt(0));
-  outer: for (let i = 0; i + pat.length <= bytes.length; i++) {
-    for (let j = 0; j < pat.length; j++) {
-      if (bytes[i + j] !== pat[j]) continue outer;
-    }
-    return true;
-  }
-  return false;
-}
-
-describe('createMp4Muxer audio track', () => {
-  it('writes an mp4a sample entry when an audio track is configured', () => {
-    const muxer = createMp4Muxer({
-      width: 320,
-      height: 240,
-      fps: 30,
-      audio: { numberOfChannels: 2, sampleRate: 48_000 },
-    });
-
-    expect(muxer.hasAudioTrack).toBe(true);
-
-    // The video track needs at least one sample to finalize. Feed a raw AVC
-    // sample with a stub decoderConfig (bytes don't need to be a valid stream
-    // for the container-level box check).
-    addStubVideoSample(muxer);
-
-    // Feed one raw AAC sample (contents don't matter for the container check).
-    const sample = new Uint8Array([0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08]);
-    // timestamp/duration are in microseconds.
-    muxer.addAudioChunkRaw(sample, 'key', 0, 1_000_000);
-
-    const mp4 = muxer.finalize();
-    expect(mp4.byteLength).toBeGreaterThan(0);
-    // The AAC audio sample entry box is named 'mp4a'.
-    expect(containsFourCC(mp4, 'mp4a')).toBe(true);
-  });
-
-  it('produces no audio track (no mp4a box) when audio is omitted', () => {
-    const muxer = createMp4Muxer({ width: 320, height: 240, fps: 30 });
-    expect(muxer.hasAudioTrack).toBe(false);
-    addStubVideoSample(muxer);
-    const mp4 = muxer.finalize();
-    expect(containsFourCC(mp4, 'mp4a')).toBe(false);
-  });
-});

package/src/__tests__/useVideoExportGif.test.ts

@@ -1,155 +0,0 @@
-import { act, renderHook } from '@testing-library/react';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import type { Doc } from '@bendyline/squisq/schemas';
-
-const mocks = vi.hoisted(() => {
-  const bitmap = { close: vi.fn() } as unknown as ImageBitmap;
-  return {
-    bitmap,
-    frameInit: vi.fn(async () => 0.1),
-    captureFrame: vi.fn(async () => bitmap),
-    destroy: vi.fn(),
-    encodeFrame: vi.fn(async (frame: ImageBitmap) => frame.close()),
-    finalize: vi.fn(async () => new Uint8Array([0, 0, 0, 1]).buffer),
-    closeEncoder: vi.fn(),
-    computeAudioTimeline: vi.fn(() => []),
-    supportsAac: vi.fn(async () => true),
-    gifTranscode: vi.fn(
-      async (_video: Uint8Array, _options: unknown, _loadConfig?: unknown, _signal?: AbortSignal) =>
-        new Uint8Array([0x47, 0x49, 0x46, 0x38, 0x39, 0x61]),
-    ),
-  };
-});
-
-vi.mock('../hooks/useFrameCapture.js', () => ({
-  useFrameCapture: () => ({
-    init: mocks.frameInit,
-    captureFrame: mocks.captureFrame,
-    destroy: mocks.destroy,
-  }),
-}));
-
-vi.mock('../mainThreadEncoder.js', () => ({
-  supportsWebCodecs: () => true,
-  supportsWebCodecsH264: async () => true,
-  createEncoder: () => ({
-    encodeFrame: mocks.encodeFrame,
-    finalize: mocks.finalize,
-    close: mocks.closeEncoder,
-  }),
-}));
-
-vi.mock('../gifTranscode.js', () => ({
-  transcodeMp4ToGifWithFfmpegWasm: mocks.gifTranscode,
-}));
-
-vi.mock('../audioTrack.js', () => ({
-  supportsWebCodecsAac: mocks.supportsAac,
-  selectAudioTier: () => ({ tier: 3, reason: null }),
-  renderAudioTimeline: vi.fn(),
-  encodeAacTrack: vi.fn(),
-  audioBufferToWav: vi.fn(),
-  muxAudioWithFfmpegWasm: vi.fn(),
-  EXPORT_AUDIO_SAMPLE_RATE: 48_000,
-  EXPORT_AUDIO_CHANNELS: 2,
-}));
-
-vi.mock('@bendyline/squisq-video', async () => {
-  const actual =
-    await vi.importActual<typeof import('@bendyline/squisq-video')>('@bendyline/squisq-video');
-  return { ...actual, computeAudioTimeline: mocks.computeAudioTimeline };
-});
-
-import { useVideoExport } from '../hooks/useVideoExport.js';
-
-const doc: Doc = {
-  articleId: 'gif-hook-test',
-  duration: 0.1,
-  blocks: [{ id: 'b1', startTime: 0, duration: 0.1, audioSegment: 0, layers: [] }],
-  audio: {
-    segments: [{ name: 'narration', src: 'narration.mp3', startTime: 0, duration: 0.1 }],
-  },
-};
-
-describe('useVideoExport GIF flow', () => {
-  let createObjectUrl: ReturnType<typeof vi.spyOn>;
-  let revokeObjectUrl: ReturnType<typeof vi.spyOn>;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mocks.gifTranscode.mockResolvedValue(new Uint8Array([0x47, 0x49, 0x46, 0x38, 0x39, 0x61]));
-    createObjectUrl = vi.spyOn(URL, 'createObjectURL').mockReturnValue('blob:gif-output');
-    revokeObjectUrl = vi.spyOn(URL, 'revokeObjectURL').mockImplementation(() => {});
-    if (typeof SharedArrayBuffer === 'undefined') {
-      vi.stubGlobal('SharedArrayBuffer', ArrayBuffer);
-    }
-  });
-
-  afterEach(() => {
-    createObjectUrl.mockRestore();
-    revokeObjectUrl.mockRestore();
-    vi.unstubAllGlobals();
-  });
-
-  it('uses compact/static defaults, skips audio, and emits an image/gif Blob', async () => {
-    const { result, unmount } = renderHook(() => useVideoExport());
-
-    await act(async () => {
-      await result.current.startExport(doc, { outputFormat: 'gif' });
-    });
-
-    expect(mocks.frameInit).toHaveBeenCalledWith(
-      doc,
-      expect.objectContaining({ width: 960, height: 540, animationsEnabled: false }),
-      undefined,
-    );
-    expect(mocks.captureFrame).toHaveBeenCalledTimes(1);
-    expect(mocks.computeAudioTimeline).not.toHaveBeenCalled();
-    expect(mocks.supportsAac).not.toHaveBeenCalled();
-    expect(mocks.gifTranscode).toHaveBeenCalledWith(
-      expect.any(Uint8Array),
-      { width: 960, height: 540, loop: 0 },
-      undefined,
-      expect.any(AbortSignal),
-    );
-
-    const blob = createObjectUrl.mock.calls[0][0] as Blob;
-    expect(blob.type).toBe('image/gif');
-    expect(result.current.state).toBe('complete');
-    expect(result.current.outputFormat).toBe('gif');
-    expect(result.current.audioIncluded).toBe(false);
-    expect(result.current.audioSkippedReason).toBeNull();
-
-    unmount();
-  });
-
-  it('aborts the palette worker when the export is cancelled', async () => {
-    mocks.gifTranscode.mockImplementationOnce(
-      async (_video: Uint8Array, _options: unknown, _loadConfig: unknown, signal?: AbortSignal) =>
-        new Promise<Uint8Array<ArrayBuffer>>((_resolve, reject) => {
-          if (!signal) throw new Error('Expected an AbortSignal');
-          signal.addEventListener(
-            'abort',
-            () => reject(new DOMException('cancelled', 'AbortError')),
-            { once: true },
-          );
-        }),
-    );
-    const { result, unmount } = renderHook(() => useVideoExport());
-
-    let exportPromise!: Promise<void>;
-    await act(async () => {
-      exportPromise = result.current.startExport(doc, { outputFormat: 'gif' });
-      await vi.waitFor(() => expect(mocks.gifTranscode).toHaveBeenCalledOnce());
-    });
-    const signal = mocks.gifTranscode.mock.calls[0][3] as AbortSignal;
-
-    act(() => result.current.cancel());
-    await act(async () => exportPromise);
-
-    expect(signal.aborted).toBe(true);
-    expect(result.current.state).toBe('idle');
-    expect(result.current.phase).toBe('Cancelled');
-    unmount();
-  });
-});

package/src/__tests__/videoExportProps.test.tsx

@@ -1,148 +0,0 @@
-/**
- * Prop-surface tests for the video export components.
- *
- * `playerScript` is unused on the browser export path (frames are captured
- * from a live in-page DocPlayer), so both VideoExportButton and
- * VideoExportModal must accept being rendered without it.
- */
-
-import { describe, it, expect } from 'vitest';
-import { fireEvent, render, renderHook } from '@testing-library/react';
-import { VideoExportButton } from '../VideoExportButton';
-import { VideoExportModal } from '../VideoExportModal';
-import { useVideoExport } from '../hooks/useVideoExport';
-import type { Doc } from '@bendyline/squisq/schemas';
-
-function minimalDoc(): Doc {
-  return {
-    articleId: 'export-test',
-    duration: 5,
-    blocks: [{ id: 'b1', startTime: 0, duration: 5, audioSegment: 0, layers: [] }],
-    audio: { segments: [] },
-  };
-}
-
-describe('VideoExportButton', () => {
-  it('renders without a playerScript prop', () => {
-    const { getByRole } = render(<VideoExportButton doc={minimalDoc()} />);
-    expect(getByRole('button', { name: 'Export Video' })).toBeTruthy();
-  });
-
-  it('accepts a defaultConfig prop', () => {
-    const { getByRole } = render(
-      <VideoExportButton doc={minimalDoc()} defaultConfig={{ quality: 'high', fps: 30 }} />,
-    );
-    expect(getByRole('button', { name: 'Export Video' })).toBeTruthy();
-  });
-
-  it('uses a GIF-specific default label when configured for GIF output', () => {
-    const { getByRole } = render(
-      <VideoExportButton doc={minimalDoc()} defaultConfig={{ outputFormat: 'gif' }} />,
-    );
-    expect(getByRole('button', { name: 'Export GIF' })).toBeTruthy();
-  });
-
-  it('forwards the requested color scheme to its portaled modal', () => {
-    const { getByRole } = render(<VideoExportButton doc={minimalDoc()} colorScheme="dark" />);
-    fireEvent.click(getByRole('button', { name: 'Export Video' }));
-    expect(document.querySelector('[data-color-scheme="dark"]')).toBeTruthy();
-  });
-});
-
-describe('VideoExportModal', () => {
-  it('renders the configure state without a playerScript prop', () => {
-    const { container } = render(<VideoExportModal doc={minimalDoc()} onClose={() => {}} />);
-    expect(container.textContent).toContain('Export Video');
-  });
-
-  it('seeds the initial selections from defaultConfig', () => {
-    const { container } = render(
-      <VideoExportModal
-        doc={minimalDoc()}
-        defaultConfig={{
-          quality: 'high',
-          fps: 30,
-          orientation: 'portrait',
-          captionMode: 'standard',
-        }}
-        onClose={() => {}}
-      />,
-    );
-    expect((container.querySelector('[aria-label="Format"]') as HTMLSelectElement).value).toBe(
-      'mp4',
-    );
-    expect((container.querySelector('[aria-label="Quality"]') as HTMLSelectElement).value).toBe(
-      'high',
-    );
-    expect((container.querySelector('[aria-label="Frame Rate"]') as HTMLSelectElement).value).toBe(
-      '30',
-    );
-    expect((container.querySelector('[aria-label="Orientation"]') as HTMLSelectElement).value).toBe(
-      'portrait',
-    );
-    expect((container.querySelector('[aria-label="Captions"]') as HTMLSelectElement).value).toBe(
-      'standard',
-    );
-    expect(
-      (container.querySelector('[aria-label="Animations and transitions"]') as HTMLSelectElement)
-        .value,
-    ).toBe('enabled');
-  });
-
-  it('defaults GIF export to 10fps with animations and transitions disabled', () => {
-    const { container, getByRole } = render(
-      <VideoExportModal
-        doc={minimalDoc()}
-        defaultConfig={{ outputFormat: 'gif' }}
-        onClose={() => {}}
-      />,
-    );
-
-    expect(getByRole('heading', { name: 'Export Animated GIF' })).toBeTruthy();
-    expect((container.querySelector('[aria-label="Frame Rate"]') as HTMLSelectElement).value).toBe(
-      '10',
-    );
-    expect(
-      (container.querySelector('[aria-label="Animations and transitions"]') as HTMLSelectElement)
-        .value,
-    ).toBe('disabled');
-    expect(container.textContent).toContain('Landscape (960 × 540)');
-    expect(getByRole('button', { name: 'Export GIF' })).toBeTruthy();
-  });
-
-  it('applies GIF recommendations when the format selection changes', () => {
-    const { container } = render(<VideoExportModal doc={minimalDoc()} onClose={() => {}} />);
-    fireEvent.change(container.querySelector('[aria-label="Format"]')!, {
-      target: { value: 'gif' },
-    });
-
-    expect((container.querySelector('[aria-label="Frame Rate"]') as HTMLSelectElement).value).toBe(
-      '10',
-    );
-    expect(
-      (container.querySelector('[aria-label="Animations and transitions"]') as HTMLSelectElement)
-        .value,
-    ).toBe('disabled');
-  });
-
-  it('applies dark colors to the modal surface and native controls', () => {
-    const { container } = render(
-      <VideoExportModal doc={minimalDoc()} colorScheme="dark" onClose={() => {}} />,
-    );
-    const overlay = container.querySelector('[data-color-scheme="dark"]');
-    const modal = overlay?.firstElementChild as HTMLElement | null;
-    const select = container.querySelector('select');
-    expect(modal?.style.colorScheme).toBe('dark');
-    expect(modal?.style.background).toBe('rgb(17, 24, 39)');
-    expect(select?.style.colorScheme).toBe('dark');
-  });
-});
-
-describe('useVideoExport result shape', () => {
-  it('exposes the additive audio result fields, defaulted for idle', () => {
-    const { result } = renderHook(() => useVideoExport());
-    expect(result.current.outputFormat).toBe('mp4');
-    expect(result.current.audioIncluded).toBe(false);
-    expect(result.current.audioSkippedReason).toBeNull();
-  });
-});