@thunderkiller/video-clipper 1.2.0 → 1.4.0

package/tests/segmentRanker.test.ts

@@ -1,133 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { rankSegments } from '../src/services/segmentRanker/index.js';
-import type { MergedCandidate } from '../src/types/index.js';
-
-function seg(
-  start: number,
-  end: number,
-  score: number,
-  source: 'transcript' | 'audio' | 'both' = 'transcript',
-  audio_event?: string,
-): MergedCandidate {
-  return {
-    start,
-    end,
-    score,
-    source,
-    reason: `reason for ${start}-${end}`,
-    audio_event,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('rankSegments', () => {
-  it('returns empty array when input is empty', () => {
-    expect(rankSegments([], 7, 10)).toEqual([]);
-  });
-
-  it('filters out segments with score below threshold', () => {
-    const segments = [seg(0, 30, 6), seg(30, 60, 8)];
-    const result = rankSegments(segments, 7, 10);
-    expect(result).toHaveLength(1);
-    expect(result[0].score).toBe(8);
-  });
-
-  it('filters out segments with score below threshold', () => {
-    const segments = [seg(0, 30, 6, 'transcript'), seg(30, 60, 8, 'transcript')];
-    const result = rankSegments(segments, 7, 10);
-    expect(result).toHaveLength(1);
-    expect(result[0].score).toBe(8);
-  });
-
-  it('filters out segments exactly at threshold (must be >=)', () => {
-    const segments = [seg(0, 30, 7), seg(30, 60, 6)];
-    const result = rankSegments(segments, 7, 10);
-    expect(result).toHaveLength(1);
-    expect(result[0].score).toBe(7);
-  });
-
-  it('sorts segments by score descending', () => {
-    const segments = [seg(0, 30, 7), seg(60, 90, 9), seg(120, 150, 8)];
-    const result = rankSegments(segments, 7, 10);
-    expect(result.map((r) => r.score)).toEqual([9, 8, 7]);
-  });
-
-  it('assigns sequential ranks starting at 1', () => {
-    const segments = [seg(0, 30, 9), seg(60, 90, 8), seg(120, 150, 7)];
-    const result = rankSegments(segments, 7, 10);
-    expect(result.map((r) => r.rank)).toEqual([1, 2, 3]);
-  });
-
-  it('caps output at topN', () => {
-    const segments = Array.from({ length: 8 }, (_, i) => seg(i * 60, i * 60 + 30, 10 - i));
-    const result = rankSegments(segments, 1, 3);
-    expect(result).toHaveLength(3);
-    expect(result[0].rank).toBe(1);
-    expect(result[2].rank).toBe(3);
-  });
-
-  it('renames clip_start/clip_end to start/end', () => {
-    const segments = [seg(42, 99, 8)];
-    const result = rankSegments(segments, 7, 10);
-    expect(result[0].start).toBe(42);
-    expect(result[0].end).toBe(99);
-    // RankedSegment type should not have clip_start / clip_end
-    expect((result[0] as Record<string, unknown>)['clip_start']).toBeUndefined();
-    expect((result[0] as Record<string, unknown>)['clip_end']).toBeUndefined();
-  });
-
-  describe('deduplication', () => {
-    it('drops the lower-scored segment when overlap > 50% of either duration', () => {
-      // Segment A: 0–100 (100s), Segment B: 60–120 (60s)
-      // Overlap: 60–100 = 40s
-      // 40/100 = 40% of A, 40/60 = 66% of B → significant overlap → drop B (lower score)
-      const segments = [seg(0, 100, 9), seg(60, 120, 8)];
-      const result = rankSegments(segments, 7, 10);
-      expect(result).toHaveLength(1);
-      expect(result[0].score).toBe(9);
-      expect(result[0].start).toBe(0);
-    });
-
-    it('keeps both segments when overlap is <= 50% of both durations', () => {
-      // Segment A: 0–100 (100s), Segment B: 80–200 (120s)
-      // Overlap: 80–100 = 20s
-      // 20/100 = 20% of A, 20/120 = 16% of B → not significant → keep both
-      const segments = [seg(0, 100, 9), seg(80, 200, 8)];
-      const result = rankSegments(segments, 7, 10);
-      expect(result).toHaveLength(2);
-    });
-
-    it('keeps both non-overlapping segments', () => {
-      const segments = [seg(0, 30, 9), seg(60, 90, 8)];
-      const result = rankSegments(segments, 7, 10);
-      expect(result).toHaveLength(2);
-    });
-
-    it('keeps the higher-scored segment when two nearly identical segments compete', () => {
-      const segments = [seg(0, 60, 7), seg(10, 70, 9)];
-      // Overlap: 10–60 = 50s; A duration=60, B duration=60
-      // 50/60 ≈ 83% → significant → keep score=9
-      const result = rankSegments(segments, 7, 10);
-      expect(result).toHaveLength(1);
-      expect(result[0].score).toBe(9);
-    });
-
-    it('correctly deduplicates multiple overlapping segments keeping highest scores', () => {
-      // Three segments all overlapping with the first
-      const segments = [
-        seg(0, 60, 9), // best, kept
-        seg(10, 70, 8), // overlaps A > 50% → dropped
-        seg(20, 80, 7), // overlaps A > 50% → dropped
-        seg(200, 250, 8), // no overlap → kept
-      ];
-      const result = rankSegments(segments, 7, 10);
-      expect(result).toHaveLength(2);
-      expect(result[0].score).toBe(9);
-      expect(result[1].score).toBe(8);
-      expect(result[1].start).toBe(200);
-    });
-  });
-});

package/tests/setup.ts

@@ -1,48 +0,0 @@
-import { vi } from 'vitest';
-
-vi.mock('../src/config/index.js', () => ({
-  config: {
-    LLM_PROVIDER: 'openai',
-    OPENAI_API_KEY: 'test-key',
-    ANTHROPIC_API_KEY: undefined,
-    GOOGLE_GENERATIVE_AI_API_KEY: undefined,
-    XAI_API_KEY: undefined,
-    MISTRAL_API_KEY: undefined,
-    GROQ_API_KEY: undefined,
-    ZAI_API_KEY: undefined,
-    OPENROUTER_API_KEY: undefined,
-    SCORE_THRESHOLD: 7,
-    TOP_N_SEGMENTS: 10,
-    CHUNK_LENGTH_SEC: 120,
-    CHUNK_OVERLAP_SEC: 20,
-    MICRO_BLOCK_SEC: 15,
-    LLM_MODEL: 'gpt-4o',
-    LLM_MAX_RETRIES: 3,
-    DOWNLOAD_DIR: 'downloads/',
-    OUTPUT_DIR: 'outputs/',
-    CACHE_DIR: 'outputs/cache',
-    DUMP_OUTPUTS: false,
-    MAX_CHUNKS: undefined,
-    LLM_CONCURRENCY: 3,
-    CLIP_CONCURRENCY: 1,
-    LLM_SYSTEM_PROMPT: undefined,
-    AUDIO_GEMINI_MODEL: 'gemini-2.5-flash',
-    AUDIO_EXTRA_INSTRUCTIONS: undefined,
-    DOWNLOAD_SECTIONS_MODE: 'all' as const,
-    FFMPEG_PATH: undefined,
-    FFPROBE_PATH: undefined,
-    FFMPEG_PRESET: 'fast' as const,
-    TIMESTAMP_OFFSET_SECONDS: 0,
-    TRANSCRIPT_PROVIDER: 'ytdlp',
-    AUDIO_DETECTION_ENABLED: true,
-    AUDIO_PROVIDER: 'gemini,whisper',
-    AUDIO_CONFIDENCE_THRESHOLD: 0.3,
-    AUDIO_CLIP_PRE_ROLL: 5,
-    AUDIO_CLIP_POST_ROLL: 15,
-    AUDIO_LLM_BOOST_WINDOW: 10,
-    AUDIO_LLM_SCORE_BOOST: 2,
-    GAME_PROFILE: 'general' as const,
-    YT_DLP_COOKIES_FROM_BROWSER: undefined,
-    YT_DLP_COOKIES_FILE: undefined,
-  },
-}));

package/tests/signalMerger.test.ts

@@ -1,197 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { mergeSignals } from '../src/services/signalMerger/index.js';
-import type { ChunkEvaluation, AudioEvent } from '../src/types/index.js';
-
-function createSuccessEvaluation(
-  clipStart: number,
-  clipEnd: number,
-  score: number,
-  interesting = true,
-): ChunkEvaluation {
-  return {
-    status: 'success',
-    chunk_index: 0,
-    chunk_start: 0,
-    chunk_end: 100,
-    interesting,
-    score,
-    reason: 'Test reason',
-    clip_start: clipStart,
-    clip_end: clipEnd,
-  };
-}
-
-function createFailedEvaluation(): ChunkEvaluation {
-  return {
-    status: 'failed',
-    chunk_index: 0,
-    chunk_start: 0,
-    chunk_end: 100,
-    error: 'Test error',
-  };
-}
-
-function createAudioEvent(time: number, confidence = 0.8, event = 'gunshot'): AudioEvent {
-  return {
-    time,
-    event,
-    confidence,
-    source: 'gemini',
-  };
-}
-
-describe('mergeSignals', () => {
-  it('returns empty array when both inputs are empty', () => {
-    const result = mergeSignals([], [], 10, 2, 5, 15);
-    expect(result).toEqual([]);
-  });
-
-  it('processes LLM-only segments with no audio events', () => {
-    const llmSegments = [createSuccessEvaluation(10, 20, 7)];
-    const audioEvents: AudioEvent[] = [];
-
-    const result = mergeSignals(llmSegments, audioEvents, 10, 2, 5, 15);
-
-    expect(result).toHaveLength(1);
-    expect(result[0]).toMatchObject({
-      start: 10,
-      end: 20,
-      score: 7,
-      source: 'transcript',
-      reason: 'Test reason',
-      audio_event: undefined,
-    });
-  });
-
-  it('processes audio-only events with no nearby LLM segments', () => {
-    const llmSegments: ChunkEvaluation[] = [];
-    const audioEvents = [createAudioEvent(30, 0.9, 'explosion')];
-
-    const result = mergeSignals(llmSegments, audioEvents, 10, 2, 5, 15);
-
-    expect(result).toHaveLength(1);
-    expect(result[0]).toMatchObject({
-      start: 25,
-      end: 45,
-      score: 9,
-      source: 'audio',
-      reason: 'Audio event: explosion (90% confidence)',
-      audio_event: 'explosion',
-    });
-  });
-
-  it('boosts LLM segment score when nearby audio event exists', () => {
-    const llmSegments = [createSuccessEvaluation(10, 20, 6)];
-    const audioEvents = [createAudioEvent(15, 0.8, 'gunshot')];
-
-    const result = mergeSignals(llmSegments, audioEvents, 10, 2, 5, 15);
-
-    expect(result).toHaveLength(1);
-    expect(result[0]).toMatchObject({
-      start: 10,
-      end: 20,
-      score: 8,
-      source: 'both',
-      reason: 'Test reason',
-      audio_event: 'gunshot',
-    });
-  });
-
-  it('caps boosted score at 10', () => {
-    const llmSegments = [createSuccessEvaluation(10, 20, 9)];
-    const audioEvents = [createAudioEvent(15, 0.8, 'gunshot')];
-
-    const result = mergeSignals(llmSegments, audioEvents, 10, 2, 5, 15);
-
-    expect(result[0].score).toBe(10);
-  });
-
-  it('ignores audio event when LLM segment is outside boost window', () => {
-    const llmSegments = [createSuccessEvaluation(10, 20, 7)];
-    const audioEvents = [createAudioEvent(50, 0.8, 'gunshot')];
-
-    const result = mergeSignals(llmSegments, audioEvents, 10, 2, 5, 15);
-
-    expect(result).toHaveLength(2);
-    expect(result[0]).toMatchObject({
-      source: 'transcript',
-      score: 7,
-    });
-    expect(result[1]).toMatchObject({
-      source: 'audio',
-      start: 45,
-      end: 65,
-    });
-  });
-
-  it('ignores LLM segments with interesting=false', () => {
-    const llmSegments = [createSuccessEvaluation(10, 20, 7, false)];
-    const audioEvents = [createAudioEvent(15, 0.8, 'gunshot')];
-
-    const result = mergeSignals(llmSegments, audioEvents, 10, 2, 5, 15);
-
-    expect(result).toHaveLength(0);
-  });
-
-  it('ignores failed LLM segments', () => {
-    const llmSegments = [createFailedEvaluation()];
-    const audioEvents = [createAudioEvent(15, 0.8, 'gunshot')];
-
-    const result = mergeSignals(llmSegments, audioEvents, 10, 2, 5, 15);
-
-    expect(result).toHaveLength(1);
-    expect(result[0]).toMatchObject({
-      source: 'audio',
-    });
-  });
-
-  it('handles multiple LLM segments and audio events correctly', () => {
-    const llmSegments = [createSuccessEvaluation(10, 20, 6), createSuccessEvaluation(50, 60, 7)];
-    const audioEvents = [
-      createAudioEvent(15, 0.8, 'gunshot'),
-      createAudioEvent(100, 0.9, 'explosion'),
-    ];
-
-    const result = mergeSignals(llmSegments, audioEvents, 10, 2, 5, 15);
-
-    expect(result).toHaveLength(3);
-    expect(result[0]).toMatchObject({
-      source: 'both',
-      score: 8,
-    });
-    expect(result[1]).toMatchObject({
-      source: 'transcript',
-      score: 7,
-    });
-    expect(result[2]).toMatchObject({
-      source: 'audio',
-      start: 95,
-      end: 115,
-    });
-  });
-
-  it('handles audio event at start time with clamp to 0 for negative start', () => {
-    const llmSegments: ChunkEvaluation[] = [];
-    const audioEvents = [createAudioEvent(3, 0.8, 'gunshot')];
-
-    const result = mergeSignals(llmSegments, audioEvents, 10, 2, 5, 15);
-
-    expect(result).toHaveLength(1);
-    expect(result[0]).toMatchObject({
-      start: 0,
-      end: 18,
-    });
-  });
-
-  it('uses default config values when overrides not provided', () => {
-    const llmSegments = [createSuccessEvaluation(10, 20, 6)];
-    const audioEvents = [createAudioEvent(15, 0.8, 'gunshot')];
-
-    const result = mergeSignals(llmSegments, audioEvents);
-
-    expect(result).toHaveLength(1);
-    expect(result[0]).toMatchObject({
-      source: 'both',
-    });
-  });
-});

package/tests/transcriptDetector.test.ts

@@ -1,150 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { TranscriptDetector } from '../src/services/transcriptDetector/index.js';
-import type { TranscriptAnalyzer } from '../src/services/transcriptAnalyzers/index.js';
-import type { TranscriptLine } from '../src/types/index.js';
-import type { Cache } from '../src/utils/cache.js';
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-const LINE_A: TranscriptLine = { text: 'Hello world', start: 0, duration: 2 };
-const LINE_B: TranscriptLine = { text: 'Second line', start: 2, duration: 2 };
-
-function makeAnalyzer(source: string, result: TranscriptLine[] | Error): TranscriptAnalyzer {
-  return {
-    source,
-    detect: vi
-      .fn()
-      .mockImplementation(() =>
-        result instanceof Error ? Promise.reject(result) : Promise.resolve(result),
-      ),
-  } as unknown as TranscriptAnalyzer;
-}
-
-function makeCache(cachedLines: TranscriptLine[] | null = null): Cache {
-  return {
-    readTranscript: vi.fn().mockResolvedValue(cachedLines),
-    writeTranscript: vi.fn().mockResolvedValue(undefined),
-  } as unknown as Cache;
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('TranscriptDetector', () => {
-  describe('constructor', () => {
-    it('throws when chain is empty', () => {
-      expect(() => new TranscriptDetector([])).toThrow(
-        'TranscriptDetector requires at least one TranscriptAnalyzer',
-      );
-    });
-  });
-
-  describe('detect — cache-first behaviour', () => {
-    it('returns cached lines without calling any analyzer', async () => {
-      const cached = [LINE_A, LINE_B];
-      const analyzer = makeAnalyzer('ytdlp', []);
-      const cache = makeCache(cached);
-      const detector = new TranscriptDetector([analyzer]);
-
-      const result = await detector.detect('abc123', null, cache);
-
-      expect(result.lines).toEqual(cached);
-      expect(analyzer.detect).not.toHaveBeenCalled();
-      expect(cache.writeTranscript).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('detect — provider chain', () => {
-    let cache: Cache;
-
-    beforeEach(() => {
-      cache = makeCache(null); // no cache → always hits the chain
-    });
-
-    it('returns lines from the first analyzer on success', async () => {
-      const analyzer = makeAnalyzer('ytdlp', [LINE_A]);
-      const detector = new TranscriptDetector([analyzer]);
-
-      const result = await detector.detect('abc123', null, cache);
-
-      expect(result.lines).toEqual([LINE_A]);
-      expect(cache.writeTranscript).toHaveBeenCalledWith('abc123', [LINE_A]);
-    });
-
-    it('falls back to second analyzer when first throws', async () => {
-      const first = makeAnalyzer('ytdlp', new Error('no subtitles'));
-      const second = makeAnalyzer('whisper', [LINE_B]);
-      const detector = new TranscriptDetector([first, second]);
-
-      const result = await detector.detect('abc123', null, cache);
-
-      expect(result.lines).toEqual([LINE_B]);
-      expect(cache.writeTranscript).toHaveBeenCalledWith('abc123', [LINE_B]);
-    });
-
-    it('re-throws the last error when the whole chain is exhausted', async () => {
-      const err1 = new Error('ytdlp failed');
-      const err2 = new Error('whisper crashed');
-      const first = makeAnalyzer('ytdlp', err1);
-      const second = makeAnalyzer('whisper', err2);
-      const detector = new TranscriptDetector([first, second]);
-
-      await expect(detector.detect('abc123', null, cache)).rejects.toThrow('whisper crashed');
-    });
-
-    it('does not call the second analyzer when the first succeeds', async () => {
-      const first = makeAnalyzer('ytdlp', [LINE_A]);
-      const second = makeAnalyzer('whisper', [LINE_B]);
-      const detector = new TranscriptDetector([first, second]);
-
-      await detector.detect('abc123', null, cache);
-      expect(second.detect).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('detect — chunk/micro-block building', () => {
-    it('returns non-empty microBlocks and chunks for multi-line transcripts', async () => {
-      // Produce enough lines to form at least one micro-block and one chunk
-      const lines: TranscriptLine[] = Array.from({ length: 20 }, (_, i) => ({
-        text: `line ${i}`,
-        start: i * 5,
-        duration: 5,
-      }));
-      const analyzer = makeAnalyzer('ytdlp', lines);
-      const cache = makeCache(null);
-      const detector = new TranscriptDetector([analyzer]);
-
-      const result = await detector.detect('abc123', null, cache);
-
-      expect(result.lines).toHaveLength(20);
-      expect(result.microBlocks.length).toBeGreaterThan(0);
-      expect(result.chunks.length).toBeGreaterThan(0);
-    });
-
-    it('returns empty microBlocks and chunks for an empty transcript', async () => {
-      const analyzer = makeAnalyzer('ytdlp', []);
-      const cache = makeCache(null);
-      const detector = new TranscriptDetector([analyzer]);
-
-      const result = await detector.detect('abc123', null, cache);
-
-      expect(result.lines).toHaveLength(0);
-      expect(result.microBlocks).toHaveLength(0);
-      expect(result.chunks).toHaveLength(0);
-    });
-  });
-
-  describe('detect — audioPath forwarding', () => {
-    it('passes audioPath through to the analyzer', async () => {
-      const analyzer = makeAnalyzer('whisper', [LINE_A]);
-      const cache = makeCache(null);
-      const detector = new TranscriptDetector([analyzer]);
-
-      await detector.detect('abc123', '/tmp/audio.wav', cache);
-      expect(analyzer.detect).toHaveBeenCalledWith('abc123', '/tmp/audio.wav');
-    });
-  });
-});

package/tests/transcriptFetcher.test.ts

@@ -1,179 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { parseVtt } from '../src/services/transcriptFetcher/index.js';
-
-const BASIC_VTT = `WEBVTT
-Kind: captions
-Language: en
-
-00:00:01.000 --> 00:00:03.500
-Hello world
-
-00:00:04.000 --> 00:00:06.000
-This is a test
-
-`;
-
-const INLINE_TAGS_VTT = `WEBVTT
-
-00:00:01.000 --> 00:00:04.000
-<00:00:01.000><c>Hello</c> <00:00:02.000><c>world</c>
-
-00:00:05.000 --> 00:00:08.000
-<c>Some</c> <c>tagged</c> <c>text</c>
-
-`;
-
-const DUPLICATE_CUES_VTT = `WEBVTT
-
-00:00:01.000 --> 00:00:03.000
-Repeated line
-
-00:00:02.000 --> 00:00:04.000
-Repeated line
-
-00:00:04.000 --> 00:00:06.000
-New line
-
-`;
-
-const HTML_ENTITIES_VTT = `WEBVTT
-
-00:00:01.000 --> 00:00:03.000
-Hello &amp; world
-
-00:00:04.000 --> 00:00:06.000
-&lt;tag&gt; content
-
-`;
-
-const MULTILINE_CUE_VTT = `WEBVTT
-
-00:00:01.000 --> 00:00:04.000
-First line
-Second line
-
-`;
-
-const EMPTY_CUES_VTT = `WEBVTT
-
-00:00:01.000 --> 00:00:03.000
-<c></c>
-
-00:00:04.000 --> 00:00:06.000
-Real content
-
-`;
-
-const HOURS_VTT = `WEBVTT
-
-01:30:00.000 --> 01:30:05.500
-Deep into the video
-
-`;
-
-const COMMA_SEPARATOR_VTT = `WEBVTT
-
-00:00:01,000 --> 00:00:03,500
-Comma separated timestamps
-
-`;
-
-describe('parseVtt', () => {
-  describe('basic parsing', () => {
-    it('parses a standard VTT with two cues', () => {
-      const result = parseVtt(BASIC_VTT);
-      expect(result).toHaveLength(2);
-    });
-
-    it('normalizes timestamps to seconds', () => {
-      const result = parseVtt(BASIC_VTT);
-      expect(result[0].start).toBeCloseTo(1.0);
-      expect(result[0].duration).toBeCloseTo(2.5);
-      expect(result[1].start).toBeCloseTo(4.0);
-      expect(result[1].duration).toBeCloseTo(2.0);
-    });
-
-    it('preserves cue text', () => {
-      const result = parseVtt(BASIC_VTT);
-      expect(result[0].text).toBe('Hello world');
-      expect(result[1].text).toBe('This is a test');
-    });
-  });
-
-  describe('inline tag stripping', () => {
-    it('strips VTT timestamp tags and <c> tags', () => {
-      const result = parseVtt(INLINE_TAGS_VTT);
-      expect(result[0].text).toBe('Hello world');
-      expect(result[1].text).toBe('Some tagged text');
-    });
-  });
-
-  describe('deduplication', () => {
-    it('skips consecutive duplicate cue text', () => {
-      const result = parseVtt(DUPLICATE_CUES_VTT);
-      // "Repeated line" should appear only once
-      expect(result.filter((l) => l.text === 'Repeated line')).toHaveLength(1);
-    });
-
-    it('keeps non-duplicate cues after duplicates', () => {
-      const result = parseVtt(DUPLICATE_CUES_VTT);
-      expect(result[result.length - 1].text).toBe('New line');
-    });
-  });
-
-  describe('HTML entity decoding', () => {
-    it('decodes &amp;', () => {
-      const result = parseVtt(HTML_ENTITIES_VTT);
-      expect(result[0].text).toBe('Hello & world');
-    });
-
-    it('decodes &lt; and &gt;', () => {
-      const result = parseVtt(HTML_ENTITIES_VTT);
-      expect(result[1].text).toBe('<tag> content');
-    });
-  });
-
-  describe('multiline cues', () => {
-    it('joins multiple text lines within a cue with a space', () => {
-      const result = parseVtt(MULTILINE_CUE_VTT);
-      expect(result[0].text).toBe('First line Second line');
-    });
-  });
-
-  describe('empty cues', () => {
-    it('skips cues that are empty after tag stripping', () => {
-      const result = parseVtt(EMPTY_CUES_VTT);
-      expect(result).toHaveLength(1);
-      expect(result[0].text).toBe('Real content');
-    });
-  });
-
-  describe('timestamp formats', () => {
-    it('handles HH:MM:SS.mmm with large hours', () => {
-      const result = parseVtt(HOURS_VTT);
-      expect(result[0].start).toBeCloseTo(1 * 3600 + 30 * 60);
-      expect(result[0].duration).toBeCloseTo(5.5);
-    });
-
-    it('handles comma as decimal separator in timestamps', () => {
-      const result = parseVtt(COMMA_SEPARATOR_VTT);
-      expect(result[0].start).toBeCloseTo(1.0);
-      expect(result[0].duration).toBeCloseTo(2.5);
-    });
-  });
-
-  describe('edge cases', () => {
-    it('returns empty array for empty string', () => {
-      expect(parseVtt('')).toEqual([]);
-    });
-
-    it('returns empty array for WEBVTT header only', () => {
-      expect(parseVtt('WEBVTT\n')).toEqual([]);
-    });
-
-    it('returns empty array when all cues are empty after stripping', () => {
-      const vtt = 'WEBVTT\n\n00:00:01.000 --> 00:00:02.000\n<c></c>\n\n';
-      expect(parseVtt(vtt)).toEqual([]);
-    });
-  });
-});