# Video Clipper Implementation Plan

> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.

**Goal:** Build a macOS GUI app (Tauri v2 + Svelte 5) that lets users paste a video URL, scrub a timeline, mark clips, and export them via ffmpeg — without manually downloading the video first.

**Architecture:** Rust backend manages subprocess orchestration (yt-dlp, ffmpeg, ffprobe) and communicates with a Svelte 5 frontend via Tauri commands and channels. The frontend provides a Canvas-based timeline with thumbnail strip, waveform, clip markers, and zoom. A hybrid playback model streams video immediately for preview while downloading in the background for export.

**Tech Stack:** Tauri v2, Svelte 5 (runes), Rust, TypeScript, Vitest, ffmpeg, ffprobe, yt-dlp, deno (for PO token generation)

## Global Constraints

- **Platform:** macOS only (MVP)
- **Rust edition:** 2021
- **Node.js:** v24+ (already installed)
- **Tauri:** v2 latest stable
- **Svelte:** v5 (runes syntax: `$state`, `$derived`, `$effect`)
- **External deps:** ffmpeg, yt-dlp, deno, bgutil-ytdlp-pot-provider (checked at runtime, not bundled)
- **Cookie default:** `--cookies-from-browser firefox`
- **All yt-dlp invocations** must include the user's configured cookie source flags
- **Imports:** Always at top of file, never inline
- **Switch exhaustiveness:** Use `never` check in default case for discriminated unions

---

## File Structure

```
gui-video-clipper/
├── src-tauri/
│   ├── Cargo.toml
│   ├── tauri.conf.json
│   ├── capabilities/
│   │   └── default.json
│   ├── build.rs
│   └── src/
│       ├── lib.rs                      # Tauri entry, plugin + command registration
│       ├── models.rs                   # Shared Rust types (VideoMetadata, ExportConfig, etc.)
│       ├── commands/
│       │   ├── mod.rs                  # Re-exports all command modules
│       │   ├── dependencies.rs         # check_dependencies, install_dependency
│       │   ├── video.rs               # resolve_url, start_download, cancel_download
│       │   ├── media_analysis.rs      # extract_keyframes, extract_waveform, extract_thumbnails
│       │   └── export.rs             # export_clips
│       └── services/
│           ├── mod.rs                  # Re-exports all service modules
│           ├── dependency_manager.rs   # Dependency check/install logic
│           ├── video_resolver.rs       # yt-dlp metadata + stream URL extraction
│           ├── download_manager.rs     # Background download + progress parsing
│           ├── keyframe_index.rs       # ffprobe keyframe extraction
│           ├── waveform_generator.rs   # ffmpeg audio peak extraction
│           ├── thumbnail_extractor.rs  # ffmpeg frame extraction + sprite sheet packing
│           └── clip_exporter.rs        # ffmpeg lossless/precise/merged export
├── src/
│   ├── App.svelte                      # Root component — layout shell
│   ├── main.ts                         # Svelte mount entry point
│   ├── app.css                         # Global styles + CSS custom properties
│   ├── vite-env.d.ts
│   └── lib/
│       ├── stores/
│       │   ├── videoSession.svelte.ts  # Video state (metadata, stream, download progress)
│       │   ├── clips.svelte.ts         # Clip CRUD, selection, pending in-point
│       │   └── preferences.svelte.ts   # Output dir, cookie source, window bounds
│       ├── components/
│       │   ├── UrlInput.svelte         # URL text field with paste detection
│       │   ├── VideoPlayer.svelte      # <video> wrapper, play/pause/seek API
│       │   ├── Timeline.svelte         # Canvas-based multi-layer timeline
│       │   ├── TransportControls.svelte # Play/pause, frame step, seek, I/O buttons
│       │   ├── ClipList.svelte         # Clip list panel with editable timestamps
│       │   ├── ExportDialog.svelte     # Export config modal
│       │   ├── StatusBar.svelte        # Download/export progress
│       │   ├── SetupWizard.svelte      # Dependency check/install wizard
│       │   └── PreferencesPanel.svelte # Cookie source, output dir settings
│       ├── timeline/
│       │   ├── renderer.ts             # Main Canvas draw loop, coordinates
│       │   ├── thumbnailRenderer.ts    # Thumbnail strip layer
│       │   ├── waveformRenderer.ts     # Waveform layer
│       │   ├── clipRenderer.ts         # Clip marker layer + hit testing
│       │   └── interactions.ts         # Mouse, scroll, drag event handlers
│       ├── bindings/
│       │   ├── dependencies.ts         # invoke wrappers for dependency commands
│       │   ├── video.ts               # invoke wrappers for video commands
│       │   ├── mediaAnalysis.ts       # invoke wrappers for analysis commands
│       │   └── export.ts             # invoke wrappers for export commands
│       └── utils/
│           ├── time.ts                 # formatTime, parseTime helpers
│           └── colors.ts              # Clip color palette
├── tests/
│   ├── lib/
│   │   ├── stores/
│   │   │   └── clips.test.ts
│   │   ├── timeline/
│   │   │   ├── renderer.test.ts
│   │   │   └── interactions.test.ts
│   │   └── utils/
│   │       ├── time.test.ts
│   │       └── colors.test.ts
├── package.json
├── svelte.config.js
├── vite.config.ts
└── tsconfig.json
```

Rust service tests live alongside the service files via `#[cfg(test)] mod tests { ... }` blocks.

---

### Task 1: Project Scaffolding & App Shell

**Files:**
- Create: `src-tauri/Cargo.toml`
- Create: `src-tauri/tauri.conf.json`
- Create: `src-tauri/capabilities/default.json`
- Create: `src-tauri/build.rs`
- Create: `src-tauri/src/lib.rs`
- Create: `src-tauri/src/models.rs`
- Create: `src-tauri/src/commands/mod.rs`
- Create: `src-tauri/src/services/mod.rs`
- Create: `src/App.svelte`
- Create: `src/main.ts`
- Create: `src/app.css`
- Create: `package.json`
- Create: `svelte.config.js`
- Create: `vite.config.ts`
- Create: `tsconfig.json`
- Create: `src/lib/utils/time.ts`
- Create: `src/lib/utils/colors.ts`
- Test: `tests/lib/utils/time.test.ts`
- Test: `tests/lib/utils/colors.test.ts`

**Interfaces:**
- Consumes: Nothing (first task)
- Produces:
  - `formatTime(seconds: number): string` — formats `83.5` → `"01:23.500"`
  - `parseTime(str: string): number | null` — parses `"01:23.500"` → `83.5`
  - `getClipColor(index: number): string` — returns a hex color from a rotating palette
  - Tauri app that compiles and shows an empty window
  - CSS custom properties for the app's color scheme

- [ ] **Step 1: Scaffold the Tauri v2 + Svelte project**

Run from the parent directory of `gui-video-clipper`. The scaffold creates the project structure:

```bash
cd .
npm create tauri-app@latest . -- --template svelte-ts --manager npm
```

If prompted, choose: Svelte, TypeScript, npm. This creates the base Tauri v2 project with Svelte 5 and Vite.

- [ ] **Step 2: Install Tauri plugins and dev dependencies**

```bash
cd .

# Tauri plugins (Rust side)
cd src-tauri
cargo add tauri-plugin-shell tauri-plugin-dialog tauri-plugin-store tauri-plugin-process
cargo add serde --features derive
cargo add serde_json
cargo add tokio --features full
cargo add thiserror
cargo add uuid --features v4
cargo add tempfile
cd ..

# Frontend plugin packages
npm install @tauri-apps/plugin-shell @tauri-apps/plugin-dialog @tauri-apps/plugin-store @tauri-apps/plugin-process

# Dev dependencies
npm install -D vitest @testing-library/svelte jsdom
```

- [ ] **Step 3: Configure Tauri capabilities**

Create `src-tauri/capabilities/default.json`:

```json
{
  "$schema": "../gen/schemas/desktop-schema.json",
  "identifier": "default",
  "description": "Capability for the main window",
  "windows": ["main"],
  "permissions": [
    "core:default",
    "shell:allow-execute",
    "shell:allow-open",
    "dialog:allow-open",
    "dialog:allow-save",
    "store:allow-get",
    "store:allow-set",
    "store:allow-save",
    "store:allow-load",
    "process:allow-exit"
  ]
}
```

- [ ] **Step 4: Set up Rust entry point with plugins**

Write `src-tauri/src/lib.rs`:

```rust
mod commands;
mod models;
mod services;

#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    tauri::Builder::default()
        .plugin(tauri_plugin_shell::init())
        .plugin(tauri_plugin_dialog::init())
        .plugin(tauri_plugin_store::Builder::new().build())
        .plugin(tauri_plugin_process::init())
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}
```

Write `src-tauri/src/models.rs`:

```rust
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct VideoMetadata {
    pub url: String,
    pub title: String,
    pub duration: f64,
    pub fps: f64,
    pub thumbnail_url: Option<String>,
    pub stream_url: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Clip {
    pub id: String,
    pub start_time: f64,
    pub end_time: f64,
    pub label: String,
    pub color: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThumbnailSpritesheet {
    pub file_path: String,
    pub start_index: usize,
    pub count: usize,
    pub thumb_width: u32,
    pub thumb_height: u32,
    pub columns: u32,
    pub interval_seconds: f64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", tag = "type")]
pub enum CookieSource {
    #[serde(rename = "browser")]
    Browser { browser: String },
    #[serde(rename = "file")]
    File { path: String },
    #[serde(rename = "none")]
    None,
}

impl CookieSource {
    pub fn to_ytdlp_args(&self) -> Vec<String> {
        match self {
            CookieSource::Browser { browser } => {
                vec!["--cookies-from-browser".to_string(), browser.clone()]
            }
            CookieSource::File { path } => {
                vec!["--cookies".to_string(), path.clone()]
            }
            CookieSource::None => vec![],
        }
    }
}

impl Default for CookieSource {
    fn default() -> Self {
        CookieSource::Browser {
            browser: "firefox".to_string(),
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", tag = "mode")]
pub enum CutMode {
    #[serde(rename = "lossless")]
    Lossless,
    #[serde(rename = "precise")]
    Precise { format: String },
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", tag = "scope")]
pub enum ExportScope {
    #[serde(rename = "individual")]
    Individual,
    #[serde(rename = "merged")]
    Merged,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ExportConfig {
    pub clips: Vec<Clip>,
    pub cut_mode: CutMode,
    pub export_scope: ExportScope,
    pub output_directory: String,
    pub video_title: String,
    pub source_file_path: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DependencyStatus {
    pub name: String,
    pub installed: bool,
    pub version: Option<String>,
    pub install_command: String,
}
```

Write `src-tauri/src/commands/mod.rs`:

```rust
pub mod dependencies;
pub mod export;
pub mod media_analysis;
pub mod video;
```

Write empty placeholder files for each command module so it compiles:

`src-tauri/src/commands/dependencies.rs`:
```rust
// Dependency check and install commands — implemented in Task 2
```

`src-tauri/src/commands/video.rs`:
```rust
// Video resolve and download commands — implemented in Task 4/5
```

`src-tauri/src/commands/media_analysis.rs`:
```rust
// Keyframe, waveform, thumbnail extraction commands — implemented in Tasks 9-11
```

`src-tauri/src/commands/export.rs`:
```rust
// Clip export commands — implemented in Task 12
```

Write `src-tauri/src/services/mod.rs`:

```rust
pub mod clip_exporter;
pub mod dependency_manager;
pub mod download_manager;
pub mod keyframe_index;
pub mod thumbnail_extractor;
pub mod video_resolver;
pub mod waveform_generator;
```

Create empty placeholder files for each service module:

`src-tauri/src/services/dependency_manager.rs`:
```rust
// Implemented in Task 2
```

`src-tauri/src/services/video_resolver.rs`:
```rust
// Implemented in Task 4
```

`src-tauri/src/services/download_manager.rs`:
```rust
// Implemented in Task 5
```

`src-tauri/src/services/keyframe_index.rs`:
```rust
// Implemented in Task 9
```

`src-tauri/src/services/waveform_generator.rs`:
```rust
// Implemented in Task 10
```

`src-tauri/src/services/thumbnail_extractor.rs`:
```rust
// Implemented in Task 11
```

`src-tauri/src/services/clip_exporter.rs`:
```rust
// Implemented in Task 12
```

- [ ] **Step 5: Write the failing tests for utility functions**

Create `tests/lib/utils/time.test.ts`:

```typescript
import { describe, it, expect } from 'vitest';
import { formatTime, parseTime } from '$lib/utils/time';

describe('formatTime', () => {
  it('formats zero seconds', () => {
    expect(formatTime(0)).toBe('00:00.000');
  });

  it('formats seconds with milliseconds', () => {
    expect(formatTime(83.45)).toBe('01:23.450');
  });

  it('formats hours', () => {
    expect(formatTime(3661.5)).toBe('1:01:01.500');
  });

  it('formats exact minutes', () => {
    expect(formatTime(120)).toBe('02:00.000');
  });

  it('handles large values', () => {
    expect(formatTime(7384.123)).toBe('2:03:04.123');
  });
});

describe('parseTime', () => {
  it('parses mm:ss.mmm format', () => {
    expect(parseTime('01:23.450')).toBeCloseTo(83.45);
  });

  it('parses h:mm:ss.mmm format', () => {
    expect(parseTime('1:01:01.500')).toBeCloseTo(3661.5);
  });

  it('returns null for invalid input', () => {
    expect(parseTime('not a time')).toBeNull();
  });

  it('parses mm:ss without milliseconds', () => {
    expect(parseTime('02:00')).toBeCloseTo(120);
  });
});
```

Create `tests/lib/utils/colors.test.ts`:

```typescript
import { describe, it, expect } from 'vitest';
import { getClipColor, CLIP_COLORS } from '$lib/utils/colors';

describe('getClipColor', () => {
  it('returns a valid hex color for index 0', () => {
    expect(getClipColor(0)).toMatch(/^#[0-9a-fA-F]{6}$/);
  });

  it('returns different colors for different indices', () => {
    expect(getClipColor(0)).not.toBe(getClipColor(1));
  });

  it('wraps around the palette', () => {
    expect(getClipColor(0)).toBe(getClipColor(CLIP_COLORS.length));
  });
});
```

- [ ] **Step 6: Run tests to verify they fail**

```bash
npx vitest run tests/lib/utils/
```

Expected: FAIL — modules not found.

- [ ] **Step 7: Implement utility functions**

Configure Vitest by updating `vite.config.ts` to add test config and path aliases:

```typescript
import { defineConfig } from 'vite';
import { svelte } from '@sveltejs/vite-plugin-svelte';

export default defineConfig({
  plugins: [svelte()],
  resolve: {
    alias: {
      $lib: '/src/lib',
    },
  },
  test: {
    environment: 'jsdom',
    include: ['tests/**/*.test.ts'],
    alias: {
      $lib: '/src/lib',
    },
  },
});
```

Create `src/lib/utils/time.ts`:

```typescript
export function formatTime(totalSeconds: number): string {
  const hours = Math.floor(totalSeconds / 3600);
  const minutes = Math.floor((totalSeconds % 3600) / 60);
  const seconds = Math.floor(totalSeconds % 60);
  const millis = Math.round((totalSeconds % 1) * 1000);

  const mm = String(minutes).padStart(2, '0');
  const ss = String(seconds).padStart(2, '0');
  const ms = String(millis).padStart(3, '0');

  if (hours > 0) {
    return `${hours}:${mm}:${ss}.${ms}`;
  }
  return `${mm}:${ss}.${ms}`;
}

export function parseTime(str: string): number | null {
  const hmsMatch = str.match(/^(\d+):(\d{2}):(\d{2})(?:\.(\d{1,3}))?$/);
  if (hmsMatch) {
    const h = parseInt(hmsMatch[1], 10);
    const m = parseInt(hmsMatch[2], 10);
    const s = parseInt(hmsMatch[3], 10);
    const ms = hmsMatch[4] ? parseInt(hmsMatch[4].padEnd(3, '0'), 10) : 0;
    return h * 3600 + m * 60 + s + ms / 1000;
  }

  const msMatch = str.match(/^(\d{2}):(\d{2})(?:\.(\d{1,3}))?$/);
  if (msMatch) {
    const m = parseInt(msMatch[1], 10);
    const s = parseInt(msMatch[2], 10);
    const ms = msMatch[3] ? parseInt(msMatch[3].padEnd(3, '0'), 10) : 0;
    return m * 60 + s + ms / 1000;
  }

  return null;
}
```

Create `src/lib/utils/colors.ts`:

```typescript
export const CLIP_COLORS = [
  '#4A90D9',
  '#E5734A',
  '#5CB85C',
  '#D94A7A',
  '#D9A54A',
  '#7B68EE',
  '#20B2AA',
  '#FF6B6B',
] as const;

export function getClipColor(index: number): string {
  return CLIP_COLORS[index % CLIP_COLORS.length];
}
```

- [ ] **Step 8: Run tests to verify they pass**

```bash
npx vitest run tests/lib/utils/
```

Expected: all tests PASS.

- [ ] **Step 9: Create the app layout shell**

Create `src/app.css`:

```css
:root {
  --bg-primary: #1e1e2e;
  --bg-secondary: #2a2a3e;
  --bg-tertiary: #353550;
  --text-primary: #cdd6f4;
  --text-secondary: #a6adc8;
  --text-muted: #6c7086;
  --accent: #89b4fa;
  --accent-hover: #74c7ec;
  --danger: #f38ba8;
  --success: #a6e3a1;
  --warning: #f9e2af;
  --border: #45475a;
  --clip-handle: #ffffff;
  --timeline-bg: #181825;
  --placeholder-gradient: linear-gradient(90deg, #2a2a3e 25%, #353550 50%, #2a2a3e 75%);
  --font-mono: 'SF Mono', 'Fira Code', monospace;
}

* {
  margin: 0;
  padding: 0;
  box-sizing: border-box;
}

body {
  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
  background: var(--bg-primary);
  color: var(--text-primary);
  overflow: hidden;
  height: 100vh;
}

#app {
  display: flex;
  flex-direction: column;
  height: 100vh;
}

button {
  cursor: pointer;
  border: none;
  background: var(--bg-tertiary);
  color: var(--text-primary);
  padding: 6px 12px;
  border-radius: 4px;
  font-size: 13px;
}

button:hover {
  background: var(--accent);
  color: var(--bg-primary);
}

button:disabled {
  opacity: 0.4;
  cursor: not-allowed;
}

input[type='text'] {
  background: var(--bg-tertiary);
  color: var(--text-primary);
  border: 1px solid var(--border);
  padding: 8px 12px;
  border-radius: 4px;
  font-size: 14px;
  outline: none;
}

input[type='text']:focus {
  border-color: var(--accent);
}
```

Create `src/App.svelte`:

```svelte
<script lang="ts">
  import UrlInput from '$lib/components/UrlInput.svelte';
  import VideoPlayer from '$lib/components/VideoPlayer.svelte';
  import TransportControls from '$lib/components/TransportControls.svelte';
  import Timeline from '$lib/components/Timeline.svelte';
  import ClipList from '$lib/components/ClipList.svelte';
  import StatusBar from '$lib/components/StatusBar.svelte';
</script>

<div id="app">
  <header class="toolbar">
    <UrlInput />
  </header>

  <main class="content">
    <VideoPlayer />
    <TransportControls />
    <Timeline />
    <ClipList />
  </main>

  <StatusBar />
</div>

<style>
  .toolbar {
    display: flex;
    align-items: center;
    padding: 8px 12px;
    background: var(--bg-secondary);
    border-bottom: 1px solid var(--border);
    gap: 8px;
  }

  .content {
    flex: 1;
    display: flex;
    flex-direction: column;
    overflow: hidden;
  }
</style>
```

Create stub components so the app compiles. Each stub is a `<div>` with the component name:

`src/lib/components/UrlInput.svelte`:
```svelte
<div class="url-input">
  <input type="text" placeholder="Paste a video URL..." />
</div>

<style>
  .url-input { flex: 1; }
  .url-input input { width: 100%; }
</style>
```

`src/lib/components/VideoPlayer.svelte`:
```svelte
<div class="video-player">
  <div class="placeholder">Paste a URL above to load a video</div>
</div>

<style>
  .video-player {
    flex: 1;
    display: flex;
    align-items: center;
    justify-content: center;
    background: #000;
    min-height: 200px;
  }
  .placeholder {
    color: var(--text-muted);
    font-size: 16px;
  }
</style>
```

`src/lib/components/TransportControls.svelte`:
```svelte
<div class="transport-controls">
  <span class="placeholder-text">Transport controls</span>
</div>

<style>
  .transport-controls {
    display: flex;
    align-items: center;
    padding: 8px 12px;
    background: var(--bg-secondary);
    border-top: 1px solid var(--border);
    border-bottom: 1px solid var(--border);
    min-height: 40px;
  }
  .placeholder-text { color: var(--text-muted); font-size: 13px; }
</style>
```

`src/lib/components/Timeline.svelte`:
```svelte
<div class="timeline">
  <div class="placeholder-text">Timeline</div>
</div>

<style>
  .timeline {
    height: 160px;
    background: var(--timeline-bg);
    display: flex;
    align-items: center;
    justify-content: center;
  }
  .placeholder-text { color: var(--text-muted); font-size: 13px; }
</style>
```

`src/lib/components/ClipList.svelte`:
```svelte
<div class="clip-list">
  <div class="placeholder-text">No clips yet — press I to mark in-point</div>
</div>

<style>
  .clip-list {
    padding: 8px 12px;
    background: var(--bg-secondary);
    min-height: 80px;
    border-top: 1px solid var(--border);
  }
  .placeholder-text { color: var(--text-muted); font-size: 13px; }
</style>
```

`src/lib/components/StatusBar.svelte`:
```svelte
<div class="status-bar">
  <span class="status-text">Ready</span>
</div>

<style>
  .status-bar {
    display: flex;
    align-items: center;
    padding: 4px 12px;
    background: var(--bg-tertiary);
    border-top: 1px solid var(--border);
    font-size: 12px;
    color: var(--text-secondary);
    min-height: 24px;
  }
</style>
```

- [ ] **Step 10: Verify the app compiles and launches**

```bash
cd .
cargo tauri dev
```

Expected: The app window opens showing the basic layout — URL input bar at top, dark video placeholder in the center, transport controls strip, timeline area, clip list area, status bar at the bottom. No functionality yet.

- [ ] **Step 11: Commit**

```bash
git add -A
git commit -m "feat: scaffold Tauri v2 + Svelte 5 project with base layout and utilities"
```

---

### Task 2: Dependency Manager & Setup Wizard

**Files:**
- Modify: `src-tauri/src/lib.rs` (register commands)
- Create: `src-tauri/src/services/dependency_manager.rs`
- Modify: `src-tauri/src/commands/dependencies.rs`
- Create: `src/lib/bindings/dependencies.ts`
- Create: `src/lib/components/SetupWizard.svelte`
- Modify: `src/App.svelte` (show wizard on launch)

**Interfaces:**
- Consumes: `DependencyStatus` from `models.rs` (Task 1)
- Produces:
  - Tauri command `check_dependencies() -> Vec<DependencyStatus>`
  - Tauri command `install_dependency(name: String, on_event: Channel) -> Result<(), String>`
  - TypeScript `checkDependencies(): Promise<DependencyStatus[]>`
  - TypeScript `installDependency(name: string, onOutput: (line: string) => void): Promise<void>`

- [ ] **Step 1: Write Rust tests for dependency checking**

Write `src-tauri/src/services/dependency_manager.rs`:

```rust
use crate::models::DependencyStatus;
use std::process::Command;

pub fn check_tool_exists(name: &str) -> Option<String> {
    let output = Command::new("which").arg(name).output().ok()?;

    if output.status.success() {
        let version_output = Command::new(name).arg("--version").output().ok()?;
        let version = String::from_utf8_lossy(&version_output.stdout)
            .lines()
            .next()
            .unwrap_or("")
            .trim()
            .to_string();
        Some(version)
    } else {
        None
    }
}

pub fn check_js_runtime() -> Option<String> {
    check_tool_exists("deno").or_else(|| check_tool_exists("node"))
}

pub fn check_pot_plugin() -> bool {
    let output = Command::new("yt-dlp")
        .args(["-v", "--simulate", "https://www.youtube.com/watch?v=dQw4w9WgXcQ"])
        .output();

    match output {
        Ok(out) => {
            let stderr = String::from_utf8_lossy(&out.stderr);
            stderr.contains("GetPOT")
        }
        Err(_) => false,
    }
}

pub fn get_all_dependency_statuses() -> Vec<DependencyStatus> {
    let ffmpeg = check_tool_exists("ffmpeg");
    let ytdlp = check_tool_exists("yt-dlp");
    let js_runtime = check_js_runtime();
    let pot_plugin = if ytdlp.is_some() {
        check_pot_plugin()
    } else {
        false
    };

    vec![
        DependencyStatus {
            name: "ffmpeg".to_string(),
            installed: ffmpeg.is_some(),
            version: ffmpeg,
            install_command: "brew install ffmpeg".to_string(),
        },
        DependencyStatus {
            name: "yt-dlp".to_string(),
            installed: ytdlp.is_some(),
            version: ytdlp,
            install_command: "brew install yt-dlp".to_string(),
        },
        DependencyStatus {
            name: "JavaScript runtime (deno/node)".to_string(),
            installed: js_runtime.is_some(),
            version: js_runtime,
            install_command: "brew install deno".to_string(),
        },
        DependencyStatus {
            name: "bgutil-ytdlp-pot-provider".to_string(),
            installed: pot_plugin,
            version: None,
            install_command: "python3 -m pip install -U bgutil-ytdlp-pot-provider".to_string(),
        },
    ]
}

pub fn get_install_args(dep_name: &str) -> Result<Vec<String>, String> {
    match dep_name {
        "ffmpeg" => Ok(vec![
            "brew".into(), "install".into(), "ffmpeg".into(),
        ]),
        "yt-dlp" => Ok(vec![
            "brew".into(), "install".into(), "yt-dlp".into(),
        ]),
        "JavaScript runtime (deno/node)" => Ok(vec![
            "brew".into(), "install".into(), "deno".into(),
        ]),
        "bgutil-ytdlp-pot-provider" => Ok(vec![
            "python3".into(), "-m".into(), "pip".into(), "install".into(), "-U".into(), "bgutil-ytdlp-pot-provider".into(),
        ]),
        _ => Err(format!("Unknown dependency: {dep_name}")),
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_get_install_args_ffmpeg() {
        let args = get_install_args("ffmpeg").unwrap();
        assert_eq!(args, vec!["brew", "install", "ffmpeg"]);
    }

    #[test]
    fn test_get_install_args_ytdlp() {
        let args = get_install_args("yt-dlp").unwrap();
        assert_eq!(args, vec!["brew", "install", "yt-dlp"]);
    }

    #[test]
    fn test_get_install_args_pot_provider() {
        let args = get_install_args("bgutil-ytdlp-pot-provider").unwrap();
        assert_eq!(args, vec!["python3", "-m", "pip", "install", "-U", "bgutil-ytdlp-pot-provider"]);
    }

    #[test]
    fn test_get_install_args_unknown() {
        assert!(get_install_args("unknown-tool").is_err());
    }

    #[test]
    fn test_dependency_statuses_has_four_entries() {
        let statuses = get_all_dependency_statuses();
        assert_eq!(statuses.len(), 4);
        assert_eq!(statuses[0].name, "ffmpeg");
        assert_eq!(statuses[1].name, "yt-dlp");
        assert_eq!(statuses[2].name, "JavaScript runtime (deno/node)");
        assert_eq!(statuses[3].name, "bgutil-ytdlp-pot-provider");
    }
}
```

- [ ] **Step 2: Run Rust tests to verify they pass**

```bash
cd src-tauri && cargo test services::dependency_manager -- --nocapture
```

Expected: all tests PASS.

- [ ] **Step 3: Write the Tauri commands**

Write `src-tauri/src/commands/dependencies.rs`:

```rust
use serde::Serialize;
use std::io::{BufRead, BufReader};
use std::process::{Command, Stdio};
use tauri::ipc::Channel;

use crate::models::DependencyStatus;
use crate::services::dependency_manager;

#[tauri::command]
pub fn check_dependencies() -> Vec<DependencyStatus> {
    dependency_manager::get_all_dependency_statuses()
}

#[derive(Clone, Serialize)]
#[serde(rename_all = "camelCase", tag = "event", content = "data")]
pub enum InstallEvent {
    Output { line: String },
    Finished { success: bool },
}

#[tauri::command]
pub async fn install_dependency(
    name: String,
    on_event: Channel<InstallEvent>,
) -> Result<(), String> {
    let args = dependency_manager::get_install_args(&name)?;
    let (cmd, cmd_args) = args.split_first().ok_or("Empty install command")?;

    let mut child = Command::new(cmd)
        .args(cmd_args)
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()
        .map_err(|e| format!("Failed to start install: {e}"))?;

    if let Some(stdout) = child.stdout.take() {
        let reader = BufReader::new(stdout);
        for line in reader.lines().map_while(Result::ok) {
            let _ = on_event.send(InstallEvent::Output { line });
        }
    }

    let status = child.wait().map_err(|e| format!("Install failed: {e}"))?;
    let _ = on_event.send(InstallEvent::Finished {
        success: status.success(),
    });

    if status.success() {
        Ok(())
    } else {
        Err("Install command exited with non-zero status".to_string())
    }
}
```

Register commands in `src-tauri/src/lib.rs`:

```rust
mod commands;
mod models;
mod services;

use commands::dependencies;

#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    tauri::Builder::default()
        .plugin(tauri_plugin_shell::init())
        .plugin(tauri_plugin_dialog::init())
        .plugin(tauri_plugin_store::Builder::new().build())
        .plugin(tauri_plugin_process::init())
        .invoke_handler(tauri::generate_handler![
            dependencies::check_dependencies,
            dependencies::install_dependency,
        ])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}
```

- [ ] **Step 4: Write the TypeScript bindings**

Create `src/lib/bindings/dependencies.ts`:

```typescript
import { invoke, Channel } from '@tauri-apps/api/core';

export interface DependencyStatus {
  name: string;
  installed: boolean;
  version: string | null;
  installCommand: string;
}

type InstallEvent =
  | { event: 'output'; data: { line: string } }
  | { event: 'finished'; data: { success: boolean } };

export async function checkDependencies(): Promise<DependencyStatus[]> {
  return invoke<DependencyStatus[]>('check_dependencies');
}

export async function installDependency(
  name: string,
  onOutput: (line: string) => void,
  onFinished: (success: boolean) => void
): Promise<void> {
  const onEvent = new Channel<InstallEvent>();
  onEvent.onmessage = (message) => {
    switch (message.event) {
      case 'output':
        onOutput(message.data.line);
        break;
      case 'finished':
        onFinished(message.data.success);
        break;
      default: {
        const _exhaustive: never = message;
        throw new Error(`Unhandled install event: ${(_exhaustive as InstallEvent).event}`);
      }
    }
  };
  await invoke('install_dependency', { name, onEvent });
}
```

- [ ] **Step 5: Create the SetupWizard component**

Create `src/lib/components/SetupWizard.svelte`:

```svelte
<script lang="ts">
  import {
    checkDependencies,
    installDependency,
    type DependencyStatus,
  } from '$lib/bindings/dependencies';

  let {
    onComplete,
  }: {
    onComplete: () => void;
  } = $props();

  let statuses = $state<DependencyStatus[]>([]);
  let loading = $state(true);
  let installingIndex = $state<number | null>(null);
  let installLog = $state<string[]>([]);
  let installError = $state<string | null>(null);

  $effect(() => {
    runChecks();
  });

  async function runChecks() {
    loading = true;
    statuses = await checkDependencies();
    loading = false;

    const criticalMet = statuses[0]?.installed && statuses[1]?.installed;
    const allMet = statuses.every((s) => s.installed);
    if (allMet) {
      onComplete();
    }
  }

  async function install(index: number) {
    const dep = statuses[index];
    installingIndex = index;
    installLog = [];
    installError = null;

    try {
      await installDependency(
        dep.name,
        (line) => {
          installLog = [...installLog, line];
        },
        (success) => {
          if (!success) {
            installError = 'Installation failed. Check the log for details.';
          }
        }
      );
      await runChecks();
    } catch (e) {
      installError = String(e);
    } finally {
      installingIndex = null;
    }
  }

  function skip() {
    const criticalMet = statuses[0]?.installed && statuses[1]?.installed;
    if (criticalMet) {
      onComplete();
    }
  }

  let criticalMet = $derived(statuses[0]?.installed && statuses[1]?.installed);
</script>

{#if loading}
  <div class="wizard-overlay">
    <div class="wizard">
      <h2>Checking dependencies…</h2>
    </div>
  </div>
{:else}
  <div class="wizard-overlay">
    <div class="wizard">
      <h2>Setup</h2>
      <p class="subtitle">
        Video Clipper requires a few tools to work. Let's make sure they're installed.
      </p>

      <ul class="dep-list">
        {#each statuses as dep, i}
          <li class="dep-row">
            <span class="dep-status">
              {#if dep.installed}
                ✅
              {:else if installingIndex === i}
                ⏳
              {:else}
                ❌
              {/if}
            </span>
            <span class="dep-info">
              <strong>{dep.name}</strong>
              {#if dep.version}
                <span class="version">{dep.version}</span>
              {/if}
            </span>
            {#if !dep.installed && installingIndex === null}
              <button onclick={() => install(i)}>Install</button>
            {/if}
          </li>
        {/each}
      </ul>

      {#if installLog.length > 0}
        <div class="log-area">
          {#each installLog as line}
            <div class="log-line">{line}</div>
          {/each}
        </div>
      {/if}

      {#if installError}
        <div class="error">{installError}</div>
      {/if}

      <div class="wizard-actions">
        {#if criticalMet}
          <button class="primary" onclick={skip}>
            {statuses.every((s) => s.installed) ? 'Continue' : 'Skip optional & Continue'}
          </button>
        {:else}
          <p class="hint">ffmpeg and yt-dlp are required to continue.</p>
        {/if}
      </div>
    </div>
  </div>
{/if}

<style>
  .wizard-overlay {
    position: fixed;
    inset: 0;
    background: rgba(0, 0, 0, 0.7);
    display: flex;
    align-items: center;
    justify-content: center;
    z-index: 1000;
  }

  .wizard {
    background: var(--bg-secondary);
    border: 1px solid var(--border);
    border-radius: 12px;
    padding: 24px 32px;
    max-width: 520px;
    width: 100%;
  }

  h2 {
    margin-bottom: 8px;
  }

  .subtitle {
    color: var(--text-secondary);
    margin-bottom: 16px;
    font-size: 14px;
  }

  .dep-list {
    list-style: none;
    margin-bottom: 16px;
  }

  .dep-row {
    display: flex;
    align-items: center;
    gap: 12px;
    padding: 8px 0;
    border-bottom: 1px solid var(--border);
  }

  .dep-info {
    flex: 1;
  }

  .version {
    color: var(--text-muted);
    font-size: 12px;
    margin-left: 8px;
  }

  .log-area {
    max-height: 120px;
    overflow-y: auto;
    background: var(--bg-primary);
    border-radius: 4px;
    padding: 8px;
    font-family: var(--font-mono);
    font-size: 11px;
    color: var(--text-secondary);
    margin-bottom: 12px;
  }

  .log-line {
    white-space: pre-wrap;
    word-break: break-all;
  }

  .error {
    color: var(--danger);
    font-size: 13px;
    margin-bottom: 12px;
  }

  .wizard-actions {
    display: flex;
    justify-content: flex-end;
    gap: 12px;
  }

  .primary {
    background: var(--accent);
    color: var(--bg-primary);
    font-weight: 600;
  }

  .hint {
    color: var(--text-muted);
    font-size: 13px;
  }
</style>
```

- [ ] **Step 6: Wire SetupWizard into App.svelte**

Update `src/App.svelte`:

```svelte
<script lang="ts">
  import UrlInput from '$lib/components/UrlInput.svelte';
  import VideoPlayer from '$lib/components/VideoPlayer.svelte';
  import TransportControls from '$lib/components/TransportControls.svelte';
  import Timeline from '$lib/components/Timeline.svelte';
  import ClipList from '$lib/components/ClipList.svelte';
  import StatusBar from '$lib/components/StatusBar.svelte';
  import SetupWizard from '$lib/components/SetupWizard.svelte';

  let showSetupWizard = $state(true);
</script>

{#if showSetupWizard}
  <SetupWizard onComplete={() => (showSetupWizard = false)} />
{/if}

<div id="app">
  <header class="toolbar">
    <UrlInput />
  </header>

  <main class="content">
    <VideoPlayer />
    <TransportControls />
    <Timeline />
    <ClipList />
  </main>

  <StatusBar />
</div>

<style>
  .toolbar {
    display: flex;
    align-items: center;
    padding: 8px 12px;
    background: var(--bg-secondary);
    border-bottom: 1px solid var(--border);
    gap: 8px;
  }

  .content {
    flex: 1;
    display: flex;
    flex-direction: column;
    overflow: hidden;
  }
</style>
```

- [ ] **Step 7: Verify the app compiles and the wizard appears**

```bash
cd .
cargo tauri dev
```

Expected: App launches, Setup Wizard overlay appears, shows dependency statuses with ✅/❌ indicators. If ffmpeg and yt-dlp are present, the Continue button is enabled. Clicking Continue dismisses the wizard.

- [ ] **Step 8: Commit**

```bash
git add -A
git commit -m "feat: add dependency manager and setup wizard"
```

---

### Task 3: Preferences Store

**Files:**
- Create: `src/lib/stores/preferences.svelte.ts`
- Create: `src/lib/components/PreferencesPanel.svelte`
- Modify: `src/App.svelte` (add prefs button + panel)

**Interfaces:**
- Consumes: `CookieSource` type from `models.rs` (Task 1)
- Produces:
  - `preferences` store: `{ outputDirectory: string; cookieSource: CookieSource }`
  - `loadPreferences(): Promise<void>`
  - `savePreferences(): Promise<void>`
  - `PreferencesPanel` component with cookie source and output dir configuration

- [ ] **Step 1: Create the preferences store**

Create `src/lib/stores/preferences.svelte.ts`:

```typescript
import { load, Store } from '@tauri-apps/plugin-store';

export type CookieSource =
  | { type: 'browser'; browser: 'firefox' }
  | { type: 'file'; path: string }
  | { type: 'none' };

export interface Preferences {
  outputDirectory: string;
  cookieSource: CookieSource;
}

const DEFAULT_PREFERENCES: Preferences = {
  outputDirectory: '~/',
  cookieSource: { type: 'browser', browser: 'firefox' },
};

let store: Store | null = null;

export let outputDirectory = $state(DEFAULT_PREFERENCES.outputDirectory);
export let cookieSource = $state<CookieSource>(DEFAULT_PREFERENCES.cookieSource);

export async function loadPreferences(): Promise<void> {
  store = await load('preferences.json', { autoSave: true });
  const savedDir = await store.get<string>('outputDirectory');
  const savedCookie = await store.get<CookieSource>('cookieSource');
  if (savedDir) outputDirectory = savedDir;
  if (savedCookie) cookieSource = savedCookie;
}

export async function savePreferences(): Promise<void> {
  if (!store) return;
  await store.set('outputDirectory', outputDirectory);
  await store.set('cookieSource', cookieSource);
  await store.save();
}

export async function setOutputDirectory(dir: string): Promise<void> {
  outputDirectory = dir;
  await savePreferences();
}

export async function setCookieSource(source: CookieSource): Promise<void> {
  cookieSource = source;
  await savePreferences();
}
```

- [ ] **Step 2: Create the PreferencesPanel component**

Create `src/lib/components/PreferencesPanel.svelte`:

```svelte
<script lang="ts">
  import { open } from '@tauri-apps/plugin-dialog';
  import {
    outputDirectory,
    cookieSource,
    setOutputDirectory,
    setCookieSource,
    type CookieSource,
  } from '$lib/stores/preferences.svelte';

  let { onClose }: { onClose: () => void } = $props();

  let cookieType = $derived(cookieSource.type);
  let cookieFilePath = $state(cookieSource.type === 'file' ? cookieSource.path : '');

  async function pickOutputDirectory() {
    const selected = await open({
      directory: true,
      defaultPath: outputDirectory,
      title: 'Choose output directory',
    });
    if (selected) {
      await setOutputDirectory(selected as string);
    }
  }

  async function handleCookieTypeChange(newType: string) {
    let newSource: CookieSource;
    switch (newType) {
      case 'browser':
        newSource = { type: 'browser', browser: 'firefox' };
        break;
      case 'file':
        newSource = { type: 'file', path: cookieFilePath || '' };
        break;
      case 'none':
        newSource = { type: 'none' };
        break;
      default: {
        const _exhaustive: never = newType as never;
        throw new Error(`Unhandled cookie type: ${_exhaustive}`);
      }
    }
    await setCookieSource(newSource);
  }

  async function pickCookieFile() {
    const selected = await open({
      filters: [{ name: 'Cookie files', extensions: ['txt'] }],
      title: 'Select cookies.txt file',
    });
    if (selected) {
      cookieFilePath = selected as string;
      await setCookieSource({ type: 'file', path: cookieFilePath });
    }
  }
</script>

<div class="overlay" role="presentation" onclick={onClose}>
  <div class="panel" role="dialog" onclick={(e) => e.stopPropagation()}>
    <h2>Preferences</h2>

    <section>
      <h3>Output Directory</h3>
      <div class="row">
        <code class="path">{outputDirectory}</code>
        <button onclick={pickOutputDirectory}>Change…</button>
      </div>
    </section>

    <section>
      <h3>YouTube Cookie Source</h3>
      <div class="radio-group">
        <label>
          <input
            type="radio"
            name="cookie"
            value="browser"
            checked={cookieType === 'browser'}
            onchange={() => handleCookieTypeChange('browser')}
          />
          Firefox (recommended)
        </label>
        <label>
          <input
            type="radio"
            name="cookie"
            value="file"
            checked={cookieType === 'file'}
            onchange={() => handleCookieTypeChange('file')}
          />
          cookies.txt file
          {#if cookieType === 'file'}
            <div class="file-picker">
              <code class="path">{cookieFilePath || 'No file selected'}</code>
              <button onclick={pickCookieFile}>Browse…</button>
            </div>
          {/if}
        </label>
        <label>
          <input
            type="radio"
            name="cookie"
            value="none"
            checked={cookieType === 'none'}
            onchange={() => handleCookieTypeChange('none')}
          />
          None (public content only)
        </label>
      </div>
    </section>

    <div class="actions">
      <button class="primary" onclick={onClose}>Done</button>
    </div>
  </div>
</div>

<style>
  .overlay {
    position: fixed;
    inset: 0;
    background: rgba(0, 0, 0, 0.5);
    display: flex;
    align-items: center;
    justify-content: center;
    z-index: 900;
  }

  .panel {
    background: var(--bg-secondary);
    border: 1px solid var(--border);
    border-radius: 12px;
    padding: 24px 32px;
    max-width: 480px;
    width: 100%;
  }

  h2 {
    margin-bottom: 16px;
  }

  h3 {
    font-size: 14px;
    color: var(--text-secondary);
    margin-bottom: 8px;
  }

  section {
    margin-bottom: 20px;
  }

  .row {
    display: flex;
    align-items: center;
    gap: 12px;
  }

  .path {
    background: var(--bg-primary);
    padding: 4px 8px;
    border-radius: 4px;
    font-size: 13px;
    flex: 1;
    overflow: hidden;
    text-overflow: ellipsis;
    white-space: nowrap;
  }

  .radio-group {
    display: flex;
    flex-direction: column;
    gap: 8px;
  }

  .radio-group label {
    display: flex;
    align-items: flex-start;
    gap: 8px;
    font-size: 14px;
    cursor: pointer;
  }

  .file-picker {
    display: flex;
    align-items: center;
    gap: 8px;
    margin-top: 4px;
    margin-left: 20px;
  }

  .actions {
    display: flex;
    justify-content: flex-end;
  }

  .primary {
    background: var(--accent);
    color: var(--bg-primary);
    font-weight: 600;
  }
</style>
```

- [ ] **Step 3: Wire preferences into App.svelte**

Update `src/App.svelte` to add a ⚙ button in the toolbar and load preferences on mount:

```svelte
<script lang="ts">
  import UrlInput from '$lib/components/UrlInput.svelte';
  import VideoPlayer from '$lib/components/VideoPlayer.svelte';
  import TransportControls from '$lib/components/TransportControls.svelte';
  import Timeline from '$lib/components/Timeline.svelte';
  import ClipList from '$lib/components/ClipList.svelte';
  import StatusBar from '$lib/components/StatusBar.svelte';
  import SetupWizard from '$lib/components/SetupWizard.svelte';
  import PreferencesPanel from '$lib/components/PreferencesPanel.svelte';
  import { loadPreferences } from '$lib/stores/preferences.svelte';

  let showSetupWizard = $state(true);
  let showPreferences = $state(false);

  $effect(() => {
    loadPreferences();
  });
</script>

{#if showSetupWizard}
  <SetupWizard onComplete={() => (showSetupWizard = false)} />
{/if}

{#if showPreferences}
  <PreferencesPanel onClose={() => (showPreferences = false)} />
{/if}

<div id="app">
  <header class="toolbar">
    <UrlInput />
    <button class="prefs-btn" onclick={() => (showPreferences = true)} title="Preferences">⚙</button>
  </header>

  <main class="content">
    <VideoPlayer />
    <TransportControls />
    <Timeline />
    <ClipList />
  </main>

  <StatusBar />
</div>

<style>
  .toolbar {
    display: flex;
    align-items: center;
    padding: 8px 12px;
    background: var(--bg-secondary);
    border-bottom: 1px solid var(--border);
    gap: 8px;
  }

  .content {
    flex: 1;
    display: flex;
    flex-direction: column;
    overflow: hidden;
  }

  .prefs-btn {
    font-size: 18px;
    padding: 4px 8px;
  }
</style>
```

- [ ] **Step 4: Verify preferences panel works**

```bash
cargo tauri dev
```

Expected: ⚙ button in toolbar opens the Preferences panel. Cookie source radio buttons work. Output directory chooser opens a native folder picker. Closing and reopening the app retains the settings.

- [ ] **Step 5: Commit**

```bash
git add -A
git commit -m "feat: add preferences store with cookie source and output directory"
```

---

### Task 4: Video Resolver, URL Input & Video Player

**Files:**
- Create: `src-tauri/src/services/video_resolver.rs`
- Modify: `src-tauri/src/commands/video.rs`
- Modify: `src-tauri/src/lib.rs` (register commands)
- Create: `src/lib/bindings/video.ts`
- Create: `src/lib/stores/videoSession.svelte.ts`
- Modify: `src/lib/components/UrlInput.svelte`
- Modify: `src/lib/components/VideoPlayer.svelte`

**Interfaces:**
- Consumes: `CookieSource` from `models.rs`, `cookieSource` from preferences store
- Produces:
  - Tauri command `resolve_url(url: String, cookie_source: CookieSource) -> Result<VideoMetadata, String>`
  - TypeScript `resolveUrl(url: string): Promise<VideoMetadata>`
  - `videoSession` store with `url`, `title`, `duration`, `fps`, `streamUrl`, `currentTime`, `isPlaying`, etc.
  - `VideoPlayer` component that plays a stream URL and exposes seek/play/pause to the store

- [ ] **Step 1: Write Rust tests for yt-dlp output parsing**

Write `src-tauri/src/services/video_resolver.rs`:

```rust
use crate::models::{CookieSource, VideoMetadata};
use serde::Deserialize;
use std::process::Command;

#[derive(Deserialize)]
struct YtDlpJson {
    title: String,
    duration: Option<f64>,
    fps: Option<f64>,
    thumbnail: Option<String>,
}

pub fn parse_ytdlp_json(json_str: &str) -> Result<YtDlpJson, String> {
    serde_json::from_str::<YtDlpJson>(json_str)
        .map_err(|e| format!("Failed to parse yt-dlp JSON: {e}"))
}

pub fn resolve(url: &str, cookie_source: &CookieSource) -> Result<VideoMetadata, String> {
    let cookie_args = cookie_source.to_ytdlp_args();

    // Get metadata
    let mut meta_cmd = Command::new("yt-dlp");
    meta_cmd.arg("--dump-json").arg("--no-download");
    for arg in &cookie_args {
        meta_cmd.arg(arg);
    }
    meta_cmd.arg(url);

    let meta_output = meta_cmd
        .output()
        .map_err(|e| format!("Failed to run yt-dlp: {e}"))?;

    if !meta_output.status.success() {
        let stderr = String::from_utf8_lossy(&meta_output.stderr);
        return Err(format!("yt-dlp metadata failed: {stderr}"));
    }

    let json_str = String::from_utf8_lossy(&meta_output.stdout);
    let meta = parse_ytdlp_json(&json_str)?;

    // Get stream URL
    let mut stream_cmd = Command::new("yt-dlp");
    stream_cmd.arg("-g").arg("--no-download");
    for arg in &cookie_args {
        stream_cmd.arg(arg);
    }
    stream_cmd.arg(url);

    let stream_output = stream_cmd
        .output()
        .map_err(|e| format!("Failed to get stream URL: {e}"))?;

    if !stream_output.status.success() {
        let stderr = String::from_utf8_lossy(&stream_output.stderr);
        return Err(format!("yt-dlp stream URL failed: {stderr}"));
    }

    let stream_url = String::from_utf8_lossy(&stream_output.stdout)
        .lines()
        .next()
        .unwrap_or("")
        .trim()
        .to_string();

    Ok(VideoMetadata {
        url: url.to_string(),
        title: meta.title,
        duration: meta.duration.unwrap_or(0.0),
        fps: meta.fps.unwrap_or(30.0),
        thumbnail_url: meta.thumbnail,
        stream_url,
    })
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_ytdlp_json_valid() {
        let json = r#"{"title": "Test Video", "duration": 125.5, "fps": 29.97, "thumbnail": "https://i.ytimg.com/vi/abc/hqdefault.jpg"}"#;
        let result = parse_ytdlp_json(json).unwrap();
        assert_eq!(result.title, "Test Video");
        assert!((result.duration.unwrap() - 125.5).abs() < 0.001);
        assert!((result.fps.unwrap() - 29.97).abs() < 0.001);
        assert_eq!(
            result.thumbnail.unwrap(),
            "https://i.ytimg.com/vi/abc/hqdefault.jpg"
        );
    }

    #[test]
    fn test_parse_ytdlp_json_missing_optional_fields() {
        let json = r#"{"title": "Minimal Video"}"#;
        let result = parse_ytdlp_json(json).unwrap();
        assert_eq!(result.title, "Minimal Video");
        assert!(result.duration.is_none());
        assert!(result.fps.is_none());
        assert!(result.thumbnail.is_none());
    }

    #[test]
    fn test_parse_ytdlp_json_invalid() {
        let result = parse_ytdlp_json("not json");
        assert!(result.is_err());
    }
}
```

- [ ] **Step 2: Run Rust tests**

```bash
cd src-tauri && cargo test services::video_resolver -- --nocapture
```

Expected: all tests PASS.

- [ ] **Step 3: Write the Tauri command**

Write `src-tauri/src/commands/video.rs`:

```rust
use crate::models::{CookieSource, VideoMetadata};
use crate::services::video_resolver;

#[tauri::command]
pub async fn resolve_url(
    url: String,
    cookie_source: CookieSource,
) -> Result<VideoMetadata, String> {
    tokio::task::spawn_blocking(move || video_resolver::resolve(&url, &cookie_source))
        .await
        .map_err(|e| format!("Task failed: {e}"))?
}
```

Register in `src-tauri/src/lib.rs` — add `commands::video::resolve_url` to the `invoke_handler` macro:

```rust
use commands::{dependencies, video};

// in the builder:
.invoke_handler(tauri::generate_handler![
    dependencies::check_dependencies,
    dependencies::install_dependency,
    video::resolve_url,
])
```

- [ ] **Step 4: Write TypeScript bindings and video session store**

Create `src/lib/bindings/video.ts`:

```typescript
import { invoke } from '@tauri-apps/api/core';
import { cookieSource } from '$lib/stores/preferences.svelte';

export interface VideoMetadata {
  url: string;
  title: string;
  duration: number;
  fps: number;
  thumbnailUrl: string | null;
  streamUrl: string;
}

export async function resolveUrl(url: string): Promise<VideoMetadata> {
  return invoke<VideoMetadata>('resolve_url', {
    url,
    cookieSource,
  });
}
```

Create `src/lib/stores/videoSession.svelte.ts`:

```typescript
import type { VideoMetadata } from '$lib/bindings/video';
import type { ThumbnailSpritesheet } from '$lib/bindings/mediaAnalysis';

export type SessionStatus = 'idle' | 'resolving' | 'ready' | 'error';

export let status = $state<SessionStatus>('idle');
export let error = $state<string | null>(null);

// Video metadata
export let url = $state('');
export let title = $state('');
export let duration = $state(0);
export let fps = $state(30);
export let thumbnailUrl = $state<string | null>(null);
export let streamUrl = $state('');

// Playback state
export let currentTime = $state(0);
export let isPlaying = $state(false);

// Download state
export let localFilePath = $state<string | null>(null);
export let downloadProgress = $state(0);

// Post-download data
export let keyframePositions = $state<number[]>([]);
export let waveformPeaks = $state<number[]>([]);
export let thumbnailSpritesheets = $state<ThumbnailSpritesheet[]>([]);

export function setMetadata(meta: VideoMetadata) {
  url = meta.url;
  title = meta.title;
  duration = meta.duration;
  fps = meta.fps;
  thumbnailUrl = meta.thumbnailUrl;
  streamUrl = meta.streamUrl;
  status = 'ready';
  error = null;

  // Reset download and analysis state
  localFilePath = null;
  downloadProgress = 0;
  keyframePositions = [];
  waveformPeaks = [];
  thumbnailSpritesheets = [];
}

export function setError(msg: string) {
  status = 'error';
  error = msg;
}

export function setResolving() {
  status = 'resolving';
  error = null;
}

export function reset() {
  status = 'idle';
  error = null;
  url = '';
  title = '';
  duration = 0;
  fps = 30;
  thumbnailUrl = null;
  streamUrl = '';
  currentTime = 0;
  isPlaying = false;
  localFilePath = null;
  downloadProgress = 0;
  keyframePositions = [];
  waveformPeaks = [];
  thumbnailSpritesheets = [];
}
```

Create a placeholder for the media analysis types so the import above doesn't break:

Create `src/lib/bindings/mediaAnalysis.ts`:

```typescript
export interface ThumbnailSpritesheet {
  filePath: string;
  startIndex: number;
  count: number;
  thumbWidth: number;
  thumbHeight: number;
  columns: number;
  intervalSeconds: number;
}
```

- [ ] **Step 5: Implement UrlInput with resolve wiring**

Rewrite `src/lib/components/UrlInput.svelte`:

```svelte
<script lang="ts">
  import { resolveUrl } from '$lib/bindings/video';
  import {
    status,
    error as sessionError,
    setMetadata,
    setError,
    setResolving,
  } from '$lib/stores/videoSession.svelte';

  let inputValue = $state('');

  async function handleSubmit() {
    const trimmed = inputValue.trim();
    if (!trimmed) return;

    setResolving();
    try {
      const meta = await resolveUrl(trimmed);
      setMetadata(meta);
    } catch (e) {
      setError(String(e));
    }
  }

  function handleKeydown(e: KeyboardEvent) {
    if (e.key === 'Enter') {
      handleSubmit();
    }
  }

  function handlePaste(e: ClipboardEvent) {
    const text = e.clipboardData?.getData('text')?.trim();
    if (text && (text.startsWith('http://') || text.startsWith('https://'))) {
      inputValue = text;
      setTimeout(handleSubmit, 50);
    }
  }
</script>

<div class="url-input">
  <input
    type="text"
    placeholder="Paste a video URL and press Enter…"
    bind:value={inputValue}
    onkeydown={handleKeydown}
    onpaste={handlePaste}
    disabled={status === 'resolving'}
  />
  {#if status === 'resolving'}
    <span class="spinner">⏳</span>
  {/if}
  {#if sessionError}
    <span class="error" title={sessionError}>⚠</span>
  {/if}
</div>

<style>
  .url-input {
    flex: 1;
    display: flex;
    align-items: center;
    gap: 8px;
  }
  .url-input input {
    width: 100%;
  }
  .spinner {
    animation: pulse 1s ease-in-out infinite;
  }
  .error {
    color: var(--danger);
    cursor: help;
  }
  @keyframes pulse {
    0%,
    100% {
      opacity: 1;
    }
    50% {
      opacity: 0.4;
    }
  }
</style>
```

- [ ] **Step 6: Implement VideoPlayer with stream URL playback**

Rewrite `src/lib/components/VideoPlayer.svelte`:

```svelte
<script lang="ts">
  import {
    streamUrl,
    status,
    currentTime,
    isPlaying,
    duration as sessionDuration,
  } from '$lib/stores/videoSession.svelte';

  let videoElement = $state<HTMLVideoElement | null>(null);

  // Sync video element → store
  function handleTimeUpdate() {
    if (videoElement) {
      currentTime = videoElement.currentTime;
    }
  }

  function handlePlay() {
    isPlaying = true;
  }

  function handlePause() {
    isPlaying = false;
  }

  // Expose seek/play/pause for other components
  export function seek(time: number) {
    if (videoElement) {
      videoElement.currentTime = time;
      currentTime = time;
    }
  }

  export function play() {
    videoElement?.play();
  }

  export function pause() {
    videoElement?.pause();
  }

  export function togglePlayPause() {
    if (!videoElement) return;
    if (videoElement.paused) {
      videoElement.play();
    } else {
      videoElement.pause();
    }
  }

  export function getVideoElement(): HTMLVideoElement | null {
    return videoElement;
  }
</script>

<div class="video-player">
  {#if status === 'ready' && streamUrl}
    <video
      bind:this={videoElement}
      src={streamUrl}
      ontimeupdate={handleTimeUpdate}
      onplay={handlePlay}
      onpause={handlePause}
      preload="auto"
    >
      <track kind="captions" />
    </video>
  {:else if status === 'resolving'}
    <div class="placeholder">Loading video…</div>
  {:else if status === 'error'}
    <div class="placeholder error">Failed to load video. Check the URL and try again.</div>
  {:else}
    <div class="placeholder">Paste a URL above to load a video</div>
  {/if}
</div>

<style>
  .video-player {
    flex: 1;
    display: flex;
    align-items: center;
    justify-content: center;
    background: #000;
    min-height: 200px;
    position: relative;
  }

  video {
    width: 100%;
    height: 100%;
    object-fit: contain;
  }

  .placeholder {
    color: var(--text-muted);
    font-size: 16px;
  }

  .placeholder.error {
    color: var(--danger);
  }
</style>
```

- [ ] **Step 7: Verify URL resolution and video playback**

```bash
cargo tauri dev
```

Paste a YouTube URL into the input. Expected: spinner appears, then the video loads and plays. The video element should be visible and seekable.

Note: This step requires a working yt-dlp + cookies setup. If YouTube requires auth and cookies aren't configured, test with a non-YouTube URL that yt-dlp supports (e.g., a direct video URL).

- [ ] **Step 8: Commit**

```bash
git add -A
git commit -m "feat: add video resolver, URL input, and video player"
```

---

### Task 5: Download Manager & Status Bar

**Files:**
- Create: `src-tauri/src/services/download_manager.rs`
- Modify: `src-tauri/src/commands/video.rs` (add download commands)
- Modify: `src-tauri/src/lib.rs` (register commands)
- Modify: `src/lib/bindings/video.ts` (add download functions)
- Modify: `src/lib/stores/videoSession.svelte.ts` (download state)
- Modify: `src/lib/components/StatusBar.svelte`

**Interfaces:**
- Consumes: `CookieSource`, `VideoMetadata`, `cookieSource` from preferences
- Produces:
  - Tauri command `start_download(url, cookie_source, on_event: Channel) -> Result<String, String>` (returns temp file path)
  - Tauri command `cancel_download(download_id: String) -> Result<(), String>`
  - TypeScript `startDownload(url: string, onProgress: (pct: number) => void): Promise<string>`
  - TypeScript `cancelDownload(id: string): Promise<void>`

- [ ] **Step 1: Write Rust download manager with progress parsing**

Write `src-tauri/src/services/download_manager.rs`:

```rust
use crate::models::CookieSource;
use std::io::{BufRead, BufReader};
use std::process::{Child, Command, Stdio};
use std::sync::{Arc, Mutex};

pub struct DownloadHandle {
    pub child: Arc<Mutex<Option<Child>>>,
    pub output_path: String,
}

pub fn parse_progress_line(line: &str) -> Option<f64> {
    // yt-dlp outputs lines like: [download]  45.2% of ~100.00MiB at 5.00MiB/s
    if !line.contains("[download]") || !line.contains('%') {
        return None;
    }
    let pct_str = line
        .split_whitespace()
        .find(|s| s.ends_with('%'))?;
    pct_str.trim_end_matches('%').parse::<f64>().ok()
        .map(|p| p / 100.0)
}

pub fn start_download(
    url: &str,
    cookie_source: &CookieSource,
    temp_dir: &str,
) -> Result<(Child, String), String> {
    let output_template = format!("{}/%(title)s.%(ext)s", temp_dir);

    let mut cmd = Command::new("yt-dlp");
    cmd.arg("-o").arg(&output_template)
        .arg("--newline")  // Force progress on separate lines
        .arg("--no-part")  // Don't use .part files
        .arg("-c");        // Resume if possible

    for arg in cookie_source.to_ytdlp_args() {
        cmd.arg(arg);
    }

    cmd.arg(url)
        .stdout(Stdio::piped())
        .stderr(Stdio::piped());

    let child = cmd
        .spawn()
        .map_err(|e| format!("Failed to start yt-dlp: {e}"))?;

    Ok((child, output_template))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_progress_percentage() {
        let line = "[download]  45.2% of ~100.00MiB at 5.00MiB/s ETA 00:10";
        assert!((parse_progress_line(line).unwrap() - 0.452).abs() < 0.001);
    }

    #[test]
    fn test_parse_progress_100_percent() {
        let line = "[download] 100% of 50.00MiB in 00:05";
        assert!((parse_progress_line(line).unwrap() - 1.0).abs() < 0.001);
    }

    #[test]
    fn test_parse_progress_non_progress_line() {
        let line = "[youtube] Extracting URL: https://www.youtube.com/watch?v=abc";
        assert!(parse_progress_line(line).is_none());
    }

    #[test]
    fn test_parse_progress_empty_line() {
        assert!(parse_progress_line("").is_none());
    }
}
```

- [ ] **Step 2: Run Rust tests**

```bash
cd src-tauri && cargo test services::download_manager -- --nocapture
```

Expected: all tests PASS.

- [ ] **Step 3: Add download Tauri commands**

Add to `src-tauri/src/commands/video.rs`:

```rust
use crate::models::{CookieSource, VideoMetadata};
use crate::services::{download_manager, video_resolver};
use serde::Serialize;
use std::io::{BufRead, BufReader};
use tauri::ipc::Channel;

#[tauri::command]
pub async fn resolve_url(
    url: String,
    cookie_source: CookieSource,
) -> Result<VideoMetadata, String> {
    tokio::task::spawn_blocking(move || video_resolver::resolve(&url, &cookie_source))
        .await
        .map_err(|e| format!("Task failed: {e}"))?
}

#[derive(Clone, Serialize)]
#[serde(rename_all = "camelCase", tag = "event", content = "data")]
pub enum DownloadEvent {
    Progress { percent: f64 },
    FilePath { path: String },
    Finished { success: bool, path: String },
    Error { message: String },
}

#[tauri::command]
pub async fn start_download(
    url: String,
    cookie_source: CookieSource,
    on_event: Channel<DownloadEvent>,
) -> Result<(), String> {
    tokio::task::spawn_blocking(move || {
        let temp_dir = std::env::temp_dir()
            .join("video-clipper")
            .to_string_lossy()
            .to_string();
        std::fs::create_dir_all(&temp_dir)
            .map_err(|e| format!("Failed to create temp dir: {e}"))?;

        let (mut child, _template) = download_manager::start_download(&url, &cookie_source, &temp_dir)?;

        // Read stderr for progress (yt-dlp writes progress to stderr with --newline)
        if let Some(stderr) = child.stderr.take() {
            let reader = BufReader::new(stderr);
            let mut last_file_path: Option<String> = None;

            for line in reader.lines().map_while(Result::ok) {
                if let Some(pct) = download_manager::parse_progress_line(&line) {
                    let _ = on_event.send(DownloadEvent::Progress { percent: pct });
                }

                // yt-dlp prints: [download] Destination: /path/to/file.mp4
                if line.contains("[download] Destination:") || line.contains("[Merger] Merging formats into") {
                    if let Some(path) = line.split(": ").nth(1) {
                        let trimmed = path.trim().trim_matches('"').to_string();
                        let _ = on_event.send(DownloadEvent::FilePath { path: trimmed.clone() });
                        last_file_path = Some(trimmed);
                    }
                }
            }

            let status = child.wait().map_err(|e| format!("Download failed: {e}"))?;
            let path = last_file_path.unwrap_or_default();
            let _ = on_event.send(DownloadEvent::Finished {
                success: status.success(),
                path,
            });
        }

        Ok(())
    })
    .await
    .map_err(|e| format!("Task failed: {e}"))?
}
```

Register `start_download` in `lib.rs`:

```rust
.invoke_handler(tauri::generate_handler![
    dependencies::check_dependencies,
    dependencies::install_dependency,
    video::resolve_url,
    video::start_download,
])
```

- [ ] **Step 4: Write TypeScript bindings and update store**

Update `src/lib/bindings/video.ts`:

```typescript
import { invoke, Channel } from '@tauri-apps/api/core';
import { cookieSource } from '$lib/stores/preferences.svelte';

export interface VideoMetadata {
  url: string;
  title: string;
  duration: number;
  fps: number;
  thumbnailUrl: string | null;
  streamUrl: string;
}

type DownloadEvent =
  | { event: 'progress'; data: { percent: number } }
  | { event: 'filePath'; data: { path: string } }
  | { event: 'finished'; data: { success: boolean; path: string } }
  | { event: 'error'; data: { message: string } };

export async function resolveUrl(url: string): Promise<VideoMetadata> {
  return invoke<VideoMetadata>('resolve_url', {
    url,
    cookieSource,
  });
}

export async function startDownload(
  url: string,
  onProgress: (percent: number) => void,
  onFilePath: (path: string) => void,
  onFinished: (success: boolean, path: string) => void,
  onError: (message: string) => void
): Promise<void> {
  const onEvent = new Channel<DownloadEvent>();
  onEvent.onmessage = (message) => {
    switch (message.event) {
      case 'progress':
        onProgress(message.data.percent);
        break;
      case 'filePath':
        onFilePath(message.data.path);
        break;
      case 'finished':
        onFinished(message.data.success, message.data.path);
        break;
      case 'error':
        onError(message.data.message);
        break;
      default: {
        const _exhaustive: never = message;
        throw new Error(`Unhandled download event: ${(_exhaustive as DownloadEvent).event}`);
      }
    }
  };
  await invoke('start_download', { url, cookieSource, onEvent });
}
```

Update `src/lib/stores/videoSession.svelte.ts` — add a function to start the download after metadata is loaded. Add this after the existing exports:

```typescript
import { startDownload } from '$lib/bindings/video';

export async function beginDownload() {
  if (!url) return;

  await startDownload(
    url,
    (percent) => {
      downloadProgress = percent;
    },
    (path) => {
      localFilePath = path;
    },
    (success, path) => {
      if (success) {
        downloadProgress = 1.0;
        localFilePath = path;
      }
    },
    (message) => {
      console.error('Download error:', message);
    }
  );
}
```

- [ ] **Step 5: Update StatusBar to show download progress**

Rewrite `src/lib/components/StatusBar.svelte`:

```svelte
<script lang="ts">
  import {
    status,
    downloadProgress,
    localFilePath,
    title,
  } from '$lib/stores/videoSession.svelte';

  let progressPercent = $derived(Math.round(downloadProgress * 100));
  let isDownloading = $derived(
    status === 'ready' && downloadProgress > 0 && downloadProgress < 1
  );
  let isDownloaded = $derived(localFilePath !== null && downloadProgress >= 1);
</script>

<div class="status-bar">
  {#if isDownloading}
    <div class="progress-bar">
      <div class="progress-fill" style="width: {progressPercent}%"></div>
    </div>
    <span class="status-text">Downloading: {progressPercent}%</span>
  {:else if isDownloaded}
    <span class="status-text success">✓ Downloaded: {title}</span>
  {:else if status === 'resolving'}
    <span class="status-text">Resolving URL…</span>
  {:else if status === 'ready'}
    <span class="status-text">Starting download…</span>
  {:else}
    <span class="status-text">Ready</span>
  {/if}
</div>

<style>
  .status-bar {
    display: flex;
    align-items: center;
    padding: 4px 12px;
    background: var(--bg-tertiary);
    border-top: 1px solid var(--border);
    font-size: 12px;
    color: var(--text-secondary);
    min-height: 24px;
    gap: 8px;
  }

  .progress-bar {
    flex: 1;
    height: 4px;
    background: var(--bg-primary);
    border-radius: 2px;
    overflow: hidden;
    max-width: 200px;
  }

  .progress-fill {
    height: 100%;
    background: var(--accent);
    transition: width 0.3s ease;
  }

  .success {
    color: var(--success);
  }
</style>
```

- [ ] **Step 6: Wire auto-download into UrlInput after resolve**

Update `src/lib/components/UrlInput.svelte` — trigger `beginDownload()` after `setMetadata`:

In the `handleSubmit` function, after `setMetadata(meta)`:

```typescript
import { beginDownload } from '$lib/stores/videoSession.svelte';

// Inside handleSubmit, after setMetadata:
setMetadata(meta);
beginDownload(); // Fire-and-forget background download
```

- [ ] **Step 7: Verify download works end-to-end**

```bash
cargo tauri dev
```

Paste a URL. Expected: Video streams immediately. Status bar shows download progress (0% → 100%). After completion, status bar shows "✓ Downloaded."

- [ ] **Step 8: Commit**

```bash
git add -A
git commit -m "feat: add background download manager with progress reporting"
```

---

### Task 6: Timeline Core

**Files:**
- Create: `src/lib/timeline/renderer.ts`
- Create: `src/lib/timeline/interactions.ts`
- Modify: `src/lib/components/Timeline.svelte`
- Test: `tests/lib/timeline/renderer.test.ts`
- Test: `tests/lib/timeline/interactions.test.ts`

**Interfaces:**
- Consumes: `currentTime`, `duration`, `isPlaying` from videoSession store
- Produces:
  - `TimelineState` type: `{ visibleStart, visibleEnd, zoom, width, height }`
  - `timeToX(time: number, state: TimelineState): number`
  - `xToTime(x: number, state: TimelineState): number`
  - `drawTimeline(ctx, state, currentTime, clips, waveform, thumbnails)` — main draw function
  - `handleTimelineClick(x, state): number` — returns target time
  - Canvas element synced with video playhead, clickable, scrollable zoom

- [ ] **Step 1: Write failing tests for coordinate mapping**

Create `tests/lib/timeline/renderer.test.ts`:

```typescript
import { describe, it, expect } from 'vitest';
import { timeToX, xToTime, type TimelineState } from '$lib/timeline/renderer';

function makeState(overrides: Partial<TimelineState> = {}): TimelineState {
  return {
    visibleStart: 0,
    visibleEnd: 60,
    zoom: 1,
    width: 600,
    height: 160,
    ...overrides,
  };
}

describe('timeToX', () => {
  it('maps start of visible range to 0', () => {
    const state = makeState();
    expect(timeToX(0, state)).toBe(0);
  });

  it('maps end of visible range to width', () => {
    const state = makeState();
    expect(timeToX(60, state)).toBe(600);
  });

  it('maps midpoint correctly', () => {
    const state = makeState();
    expect(timeToX(30, state)).toBe(300);
  });

  it('handles zoomed-in view', () => {
    const state = makeState({ visibleStart: 10, visibleEnd: 20 });
    expect(timeToX(15, state)).toBe(300);
  });
});

describe('xToTime', () => {
  it('maps 0 to visible start', () => {
    const state = makeState();
    expect(xToTime(0, state)).toBe(0);
  });

  it('maps width to visible end', () => {
    const state = makeState();
    expect(xToTime(600, state)).toBe(60);
  });

  it('maps midpoint correctly', () => {
    const state = makeState();
    expect(xToTime(300, state)).toBe(30);
  });

  it('inverse of timeToX', () => {
    const state = makeState({ visibleStart: 10, visibleEnd: 20 });
    expect(xToTime(timeToX(15, state), state)).toBeCloseTo(15);
  });
});
```

Create `tests/lib/timeline/interactions.test.ts`:

```typescript
import { describe, it, expect } from 'vitest';
import { clampZoom, computeZoom, type TimelineState } from '$lib/timeline/interactions';

describe('clampZoom', () => {
  it('clamps zoom above minimum', () => {
    expect(clampZoom(0.5, 60)).toBeGreaterThanOrEqual(1);
  });

  it('clamps zoom below maximum', () => {
    expect(clampZoom(10000, 60)).toBeLessThanOrEqual(600);
  });
});

describe('computeZoom', () => {
  it('zooming in narrows the visible range', () => {
    const state: TimelineState = {
      visibleStart: 0,
      visibleEnd: 60,
      zoom: 1,
      width: 600,
      height: 160,
    };
    const result = computeZoom(state, 30, 1.1, 60);
    const newRange = result.visibleEnd - result.visibleStart;
    expect(newRange).toBeLessThan(60);
  });

  it('zooming out widens the visible range', () => {
    const state: TimelineState = {
      visibleStart: 10,
      visibleEnd: 20,
      zoom: 6,
      width: 600,
      height: 160,
    };
    const result = computeZoom(state, 15, 0.9, 60);
    const newRange = result.visibleEnd - result.visibleStart;
    expect(newRange).toBeGreaterThan(10);
  });
});
```

- [ ] **Step 2: Run tests to verify they fail**

```bash
npx vitest run tests/lib/timeline/
```

Expected: FAIL — modules not found.

- [ ] **Step 3: Implement timeline renderer**

Create `src/lib/timeline/renderer.ts`:

```typescript
export interface TimelineState {
  visibleStart: number;
  visibleEnd: number;
  zoom: number;
  width: number;
  height: number;
}

export function timeToX(time: number, state: TimelineState): number {
  const range = state.visibleEnd - state.visibleStart;
  if (range <= 0) return 0;
  return ((time - state.visibleStart) / range) * state.width;
}

export function xToTime(x: number, state: TimelineState): number {
  const range = state.visibleEnd - state.visibleStart;
  return state.visibleStart + (x / state.width) * range;
}

const THUMB_LANE_HEIGHT = 50;
const WAVEFORM_LANE_HEIGHT = 40;
const CLIP_LANE_HEIGHT = 30;
const CONTROLS_LANE_HEIGHT = 30;
const TICK_HEIGHT = 10;

export function drawTimeline(
  ctx: CanvasRenderingContext2D,
  state: TimelineState,
  currentTime: number,
  duration: number
): void {
  const { width, height } = state;
  ctx.clearRect(0, 0, width, height);

  // Background
  ctx.fillStyle = '#181825';
  ctx.fillRect(0, 0, width, height);

  // Draw time ticks
  drawTimeTicks(ctx, state, duration);

  // Draw placeholder lanes
  drawPlaceholderLane(ctx, state, 0, THUMB_LANE_HEIGHT, 'Thumbnails');
  drawPlaceholderLane(ctx, state, THUMB_LANE_HEIGHT, WAVEFORM_LANE_HEIGHT, 'Waveform');

  // Draw playhead
  drawPlayhead(ctx, state, currentTime);
}

function drawTimeTicks(
  ctx: CanvasRenderingContext2D,
  state: TimelineState,
  duration: number
): void {
  const range = state.visibleEnd - state.visibleStart;
  const tickInterval = getTickInterval(range, state.width);
  const startTick = Math.floor(state.visibleStart / tickInterval) * tickInterval;

  ctx.fillStyle = '#6c7086';
  ctx.font = '10px -apple-system, sans-serif';
  ctx.textAlign = 'center';

  for (let t = startTick; t <= state.visibleEnd; t += tickInterval) {
    if (t < 0 || t > duration) continue;
    const x = timeToX(t, state);
    ctx.strokeStyle = '#45475a';
    ctx.beginPath();
    ctx.moveTo(x, state.height - CONTROLS_LANE_HEIGHT);
    ctx.lineTo(x, state.height - CONTROLS_LANE_HEIGHT + TICK_HEIGHT);
    ctx.stroke();

    const label = formatTickLabel(t);
    ctx.fillText(label, x, state.height - CONTROLS_LANE_HEIGHT + TICK_HEIGHT + 12);
  }
}

function getTickInterval(visibleRange: number, width: number): number {
  const minPixelsPerTick = 80;
  const maxTicks = width / minPixelsPerTick;
  const rawInterval = visibleRange / maxTicks;

  const intervals = [0.1, 0.25, 0.5, 1, 2, 5, 10, 15, 30, 60, 120, 300, 600];
  for (const interval of intervals) {
    if (interval >= rawInterval) return interval;
  }
  return 600;
}

function formatTickLabel(seconds: number): string {
  const m = Math.floor(seconds / 60);
  const s = Math.floor(seconds % 60);
  return `${m}:${String(s).padStart(2, '0')}`;
}

function drawPlaceholderLane(
  ctx: CanvasRenderingContext2D,
  state: TimelineState,
  y: number,
  height: number,
  label: string
): void {
  ctx.fillStyle = '#2a2a3e';
  ctx.fillRect(0, y, state.width, height);
  ctx.strokeStyle = '#353550';
  ctx.strokeRect(0, y, state.width, height);
  ctx.fillStyle = '#6c7086';
  ctx.font = '11px -apple-system, sans-serif';
  ctx.textAlign = 'center';
  ctx.fillText(`Generating ${label}…`, state.width / 2, y + height / 2 + 4);
}

export function drawPlayhead(
  ctx: CanvasRenderingContext2D,
  state: TimelineState,
  currentTime: number
): void {
  const x = timeToX(currentTime, state);
  ctx.strokeStyle = '#ffffff';
  ctx.lineWidth = 2;
  ctx.beginPath();
  ctx.moveTo(x, 0);
  ctx.lineTo(x, state.height);
  ctx.stroke();
  ctx.lineWidth = 1;

  // Playhead triangle at top
  ctx.fillStyle = '#ffffff';
  ctx.beginPath();
  ctx.moveTo(x - 5, 0);
  ctx.lineTo(x + 5, 0);
  ctx.lineTo(x, 8);
  ctx.closePath();
  ctx.fill();
}
```

- [ ] **Step 4: Implement timeline interactions**

Create `src/lib/timeline/interactions.ts`:

```typescript
import { type TimelineState, xToTime } from './renderer';

export { type TimelineState };

const MIN_VISIBLE_RANGE = 0.1; // seconds
const MIN_ZOOM = 1;

export function clampZoom(zoom: number, duration: number): number {
  const maxZoom = duration / MIN_VISIBLE_RANGE;
  return Math.max(MIN_ZOOM, Math.min(zoom, maxZoom));
}

export function computeZoom(
  state: TimelineState,
  anchorTime: number,
  factor: number,
  duration: number
): { visibleStart: number; visibleEnd: number; zoom: number } {
  const currentRange = state.visibleEnd - state.visibleStart;
  const newRange = currentRange / factor;
  const clampedRange = Math.max(MIN_VISIBLE_RANGE, Math.min(newRange, duration));

  const anchorRatio = (anchorTime - state.visibleStart) / currentRange;
  let newStart = anchorTime - anchorRatio * clampedRange;
  let newEnd = newStart + clampedRange;

  if (newStart < 0) {
    newStart = 0;
    newEnd = clampedRange;
  }
  if (newEnd > duration) {
    newEnd = duration;
    newStart = Math.max(0, newEnd - clampedRange);
  }

  const newZoom = clampZoom(duration / clampedRange, duration);

  return { visibleStart: newStart, visibleEnd: newEnd, zoom: newZoom };
}

export function handleClick(
  x: number,
  state: TimelineState,
  duration: number
): number {
  const time = xToTime(x, state);
  return Math.max(0, Math.min(time, duration));
}
```

- [ ] **Step 5: Run tests to verify they pass**

```bash
npx vitest run tests/lib/timeline/
```

Expected: all tests PASS.

- [ ] **Step 6: Implement the Timeline Svelte component**

Rewrite `src/lib/components/Timeline.svelte`:

```svelte
<script lang="ts">
  import {
    currentTime,
    duration,
    isPlaying,
  } from '$lib/stores/videoSession.svelte';
  import {
    drawTimeline,
    drawPlayhead,
    type TimelineState,
  } from '$lib/timeline/renderer';
  import {
    computeZoom,
    handleClick as computeClickTime,
  } from '$lib/timeline/interactions';

  let canvas = $state<HTMLCanvasElement | null>(null);
  let containerEl = $state<HTMLDivElement | null>(null);
  let animFrameId = $state(0);

  let timelineState = $state<TimelineState>({
    visibleStart: 0,
    visibleEnd: 60,
    zoom: 1,
    width: 600,
    height: 160,
  });

  let isDragging = $state(false);

  // Update visible range when duration changes
  $effect(() => {
    if (duration > 0) {
      timelineState.visibleEnd = duration;
    }
  });

  // Resize observer
  $effect(() => {
    if (!containerEl) return;
    const observer = new ResizeObserver((entries) => {
      for (const entry of entries) {
        timelineState.width = entry.contentRect.width;
        timelineState.height = entry.contentRect.height;
        if (canvas) {
          canvas.width = entry.contentRect.width * window.devicePixelRatio;
          canvas.height = entry.contentRect.height * window.devicePixelRatio;
          canvas.style.width = `${entry.contentRect.width}px`;
          canvas.style.height = `${entry.contentRect.height}px`;
        }
      }
    });
    observer.observe(containerEl);
    return () => observer.disconnect();
  });

  // Animation loop
  $effect(() => {
    if (!canvas) return;
    const ctx = canvas.getContext('2d');
    if (!ctx) return;

    function draw() {
      if (!ctx || !canvas) return;
      ctx.save();
      ctx.scale(window.devicePixelRatio, window.devicePixelRatio);
      drawTimeline(ctx, timelineState, currentTime, duration);
      ctx.restore();
      animFrameId = requestAnimationFrame(draw);
    }

    draw();
    return () => cancelAnimationFrame(animFrameId);
  });

  function getCanvasX(e: MouseEvent): number {
    if (!canvas) return 0;
    const rect = canvas.getBoundingClientRect();
    return e.clientX - rect.left;
  }

  function handleMouseDown(e: MouseEvent) {
    isDragging = true;
    const x = getCanvasX(e);
    const targetTime = computeClickTime(x, timelineState, duration);
    seekTo(targetTime);
  }

  function handleMouseMove(e: MouseEvent) {
    if (!isDragging) return;
    const x = getCanvasX(e);
    const targetTime = computeClickTime(x, timelineState, duration);
    seekTo(targetTime);
  }

  function handleMouseUp() {
    isDragging = false;
  }

  function handleWheel(e: WheelEvent) {
    e.preventDefault();
    const x = getCanvasX(e);
    const anchorTime = computeClickTime(x, timelineState, duration);
    const factor = e.deltaY < 0 ? 1.15 : 0.87;
    const result = computeZoom(timelineState, anchorTime, factor, duration);
    timelineState.visibleStart = result.visibleStart;
    timelineState.visibleEnd = result.visibleEnd;
    timelineState.zoom = result.zoom;
  }

  function seekTo(time: number) {
    currentTime = time;
    // The VideoPlayer will pick this up via store reactivity
    const videoEl = document.querySelector('video');
    if (videoEl) {
      videoEl.currentTime = time;
    }
  }
</script>

<div
  class="timeline-container"
  bind:this={containerEl}
>
  <canvas
    bind:this={canvas}
    onmousedown={handleMouseDown}
    onmousemove={handleMouseMove}
    onmouseup={handleMouseUp}
    onmouseleave={handleMouseUp}
    onwheel={handleWheel}
  ></canvas>
</div>

<style>
  .timeline-container {
    height: 160px;
    background: var(--timeline-bg);
    position: relative;
    cursor: crosshair;
  }

  canvas {
    display: block;
    width: 100%;
    height: 100%;
  }
</style>
```

- [ ] **Step 7: Verify timeline renders and interacts correctly**

```bash
cargo tauri dev
```

Load a video. Expected: Timeline shows with time ticks, placeholder lanes ("Generating Thumbnails…", "Generating Waveform…"), and a white playhead that tracks the video position. Clicking the timeline seeks the video. Scrolling zooms in/out centered on the cursor.

- [ ] **Step 8: Commit**

```bash
git add -A
git commit -m "feat: add canvas-based timeline with playhead, scrubbing, and zoom"
```

---

### Task 7: Clip Management

**Files:**
- Create: `src/lib/stores/clips.svelte.ts`
- Create: `src/lib/timeline/clipRenderer.ts`
- Modify: `src/lib/components/ClipList.svelte`
- Modify: `src/lib/timeline/renderer.ts` (call clip renderer)
- Modify: `src/lib/components/Timeline.svelte` (clip drag interactions)
- Test: `tests/lib/stores/clips.test.ts`

**Interfaces:**
- Consumes: `currentTime` from videoSession store, `TimelineState` from renderer, `getClipColor` from colors util
- Produces:
  - `clips` store: array of `Clip` with CRUD operations
  - `selectedClipId`, `pendingInPoint`
  - `markInPoint(time)`, `markOutPoint(time)`, `addClip(start, end)`, `removeClip(id)`, `updateClip(id, changes)`
  - `drawClips(ctx, state, clips, selectedId)` — renders clip regions on canvas
  - `hitTestClipHandle(x, y, state, clips): { clipId, edge } | null` — for drag detection

- [ ] **Step 1: Write failing tests for clip store**

Create `tests/lib/stores/clips.test.ts`:

```typescript
import { describe, it, expect, beforeEach } from 'vitest';

// Since Svelte 5 runes only work in .svelte.ts files, we test the pure logic
// by importing the functions and reading the exported $state values.
// For vitest, we need to mock the runes or test the logic directly.
// We'll test the pure functions that clips.svelte.ts exposes.

import {
  addClip,
  removeClip,
  updateClip,
  markInPoint,
  markOutPoint,
  getClips,
  getSelectedClipId,
  getPendingInPoint,
  clearAll,
} from '$lib/stores/clips.svelte';

describe('clip store', () => {
  beforeEach(() => {
    clearAll();
  });

  it('starts with no clips', () => {
    expect(getClips()).toHaveLength(0);
  });

  it('adds a clip', () => {
    addClip(10, 20);
    const clips = getClips();
    expect(clips).toHaveLength(1);
    expect(clips[0].startTime).toBe(10);
    expect(clips[0].endTime).toBe(20);
    expect(clips[0].label).toBe('Clip 1');
  });

  it('removes a clip', () => {
    addClip(10, 20);
    const id = getClips()[0].id;
    removeClip(id);
    expect(getClips()).toHaveLength(0);
  });

  it('updates clip times', () => {
    addClip(10, 20);
    const id = getClips()[0].id;
    updateClip(id, { startTime: 5 });
    expect(getClips()[0].startTime).toBe(5);
    expect(getClips()[0].endTime).toBe(20);
  });

  it('marks in-point and out-point to create a clip', () => {
    markInPoint(15);
    expect(getPendingInPoint()).toBe(15);
    expect(getClips()).toHaveLength(0);

    markOutPoint(25);
    expect(getPendingInPoint()).toBeNull();
    expect(getClips()).toHaveLength(1);
    expect(getClips()[0].startTime).toBe(15);
    expect(getClips()[0].endTime).toBe(25);
  });

  it('updates selected clip start when I is pressed', () => {
    addClip(10, 20);
    const id = getClips()[0].id;
    selectClip(id);

    markInPoint(5);
    expect(getClips()[0].startTime).toBe(5);
    expect(getPendingInPoint()).toBeNull();
  });

  it('swaps start/end if in-point is after out-point', () => {
    markInPoint(30);
    markOutPoint(10);
    const clip = getClips()[0];
    expect(clip.startTime).toBe(10);
    expect(clip.endTime).toBe(30);
  });
});

// We need to also import selectClip
import { selectClip } from '$lib/stores/clips.svelte';
```

- [ ] **Step 2: Run tests to verify they fail**

```bash
npx vitest run tests/lib/stores/clips.test.ts
```

Expected: FAIL — module not found.

- [ ] **Step 3: Implement the clips store**

Create `src/lib/stores/clips.svelte.ts`:

```typescript
import { getClipColor } from '$lib/utils/colors';

export interface Clip {
  id: string;
  startTime: number;
  endTime: number;
  label: string;
  color: string;
}

let clips = $state<Clip[]>([]);
let selectedClipId = $state<string | null>(null);
let pendingInPoint = $state<number | null>(null);
let nextClipNumber = $state(1);

export function getClips(): Clip[] {
  return clips;
}

export function getSelectedClipId(): string | null {
  return selectedClipId;
}

export function getPendingInPoint(): number | null {
  return pendingInPoint;
}

export function selectClip(id: string | null) {
  selectedClipId = id;
  pendingInPoint = null;
}

export function addClip(startTime: number, endTime: number): Clip {
  const start = Math.min(startTime, endTime);
  const end = Math.max(startTime, endTime);

  const clip: Clip = {
    id: crypto.randomUUID(),
    startTime: start,
    endTime: end,
    label: `Clip ${nextClipNumber}`,
    color: getClipColor(nextClipNumber - 1),
  };
  nextClipNumber++;
  clips = [...clips, clip];
  selectedClipId = clip.id;
  return clip;
}

export function removeClip(id: string) {
  clips = clips.filter((c) => c.id !== id);
  if (selectedClipId === id) {
    selectedClipId = null;
  }
}

export function updateClip(id: string, changes: Partial<Pick<Clip, 'startTime' | 'endTime' | 'label'>>) {
  clips = clips.map((c) => {
    if (c.id !== id) return c;
    const updated = { ...c, ...changes };
    if (updated.startTime > updated.endTime) {
      [updated.startTime, updated.endTime] = [updated.endTime, updated.startTime];
    }
    return updated;
  });
}

export function markInPoint(time: number) {
  if (selectedClipId) {
    updateClip(selectedClipId, { startTime: time });
  } else {
    pendingInPoint = time;
  }
}

export function markOutPoint(time: number) {
  if (selectedClipId) {
    updateClip(selectedClipId, { endTime: time });
  } else if (pendingInPoint !== null) {
    addClip(pendingInPoint, time);
    pendingInPoint = null;
  }
}

export function clearAll() {
  clips = [];
  selectedClipId = null;
  pendingInPoint = null;
  nextClipNumber = 1;
}
```

- [ ] **Step 4: Run tests to verify they pass**

```bash
npx vitest run tests/lib/stores/clips.test.ts
```

Expected: all tests PASS. (Note: if Svelte 5 runes don't work in vitest without a preprocessor, you may need to add `@sveltejs/vite-plugin-svelte` to the vitest config's plugins. This should already be handled by the vite.config.ts from Task 1.)

- [ ] **Step 5: Implement clip renderer for the Canvas**

Create `src/lib/timeline/clipRenderer.ts`:

```typescript
import type { Clip } from '$lib/stores/clips.svelte';
import { timeToX, type TimelineState } from './renderer';

const CLIP_LANE_Y = 90; // below thumbnails (50) + waveform (40)
const CLIP_LANE_HEIGHT = 30;
const HANDLE_WIDTH = 6;

export function drawClips(
  ctx: CanvasRenderingContext2D,
  state: TimelineState,
  clips: Clip[],
  selectedId: string | null,
  pendingInPoint: number | null
): void {
  for (const clip of clips) {
    const x1 = timeToX(clip.startTime, state);
    const x2 = timeToX(clip.endTime, state);
    const isSelected = clip.id === selectedId;

    // Clip region
    ctx.fillStyle = clip.color + '66'; // 40% opacity
    ctx.fillRect(x1, CLIP_LANE_Y, x2 - x1, CLIP_LANE_HEIGHT);

    // Border
    ctx.strokeStyle = isSelected ? '#ffffff' : clip.color;
    ctx.lineWidth = isSelected ? 2 : 1;
    ctx.strokeRect(x1, CLIP_LANE_Y, x2 - x1, CLIP_LANE_HEIGHT);
    ctx.lineWidth = 1;

    // Handles
    ctx.fillStyle = isSelected ? '#ffffff' : clip.color;
    ctx.fillRect(x1 - HANDLE_WIDTH / 2, CLIP_LANE_Y, HANDLE_WIDTH, CLIP_LANE_HEIGHT);
    ctx.fillRect(x2 - HANDLE_WIDTH / 2, CLIP_LANE_Y, HANDLE_WIDTH, CLIP_LANE_HEIGHT);

    // Label
    const labelWidth = x2 - x1;
    if (labelWidth > 40) {
      ctx.fillStyle = '#ffffff';
      ctx.font = '11px -apple-system, sans-serif';
      ctx.textAlign = 'center';
      ctx.fillText(clip.label, (x1 + x2) / 2, CLIP_LANE_Y + CLIP_LANE_HEIGHT / 2 + 4, labelWidth - 10);
    }
  }

  // Pending in-point marker
  if (pendingInPoint !== null) {
    const x = timeToX(pendingInPoint, state);
    ctx.strokeStyle = '#f9e2af';
    ctx.lineWidth = 2;
    ctx.setLineDash([4, 4]);
    ctx.beginPath();
    ctx.moveTo(x, CLIP_LANE_Y);
    ctx.lineTo(x, CLIP_LANE_Y + CLIP_LANE_HEIGHT);
    ctx.stroke();
    ctx.setLineDash([]);
    ctx.lineWidth = 1;
  }
}

export interface ClipHitResult {
  clipId: string;
  edge: 'start' | 'end' | 'body';
}

export function hitTestClip(
  x: number,
  y: number,
  state: TimelineState,
  clips: Clip[]
): ClipHitResult | null {
  if (y < CLIP_LANE_Y || y > CLIP_LANE_Y + CLIP_LANE_HEIGHT) {
    return null;
  }

  for (const clip of [...clips].reverse()) {
    const x1 = timeToX(clip.startTime, state);
    const x2 = timeToX(clip.endTime, state);

    if (Math.abs(x - x1) <= HANDLE_WIDTH) {
      return { clipId: clip.id, edge: 'start' };
    }
    if (Math.abs(x - x2) <= HANDLE_WIDTH) {
      return { clipId: clip.id, edge: 'end' };
    }
    if (x >= x1 && x <= x2) {
      return { clipId: clip.id, edge: 'body' };
    }
  }

  return null;
}
```

- [ ] **Step 6: Wire clip rendering into Timeline.svelte and renderer.ts**

Update `src/lib/timeline/renderer.ts` — add a `drawClips` import parameter to `drawTimeline`:

Add to the `drawTimeline` function signature and call `drawClips`:

```typescript
import { drawClips } from './clipRenderer';
import type { Clip } from '$lib/stores/clips.svelte';

// Add to drawTimeline parameters:
export function drawTimeline(
  ctx: CanvasRenderingContext2D,
  state: TimelineState,
  currentTime: number,
  duration: number,
  clips: Clip[] = [],
  selectedClipId: string | null = null,
  pendingInPoint: number | null = null
): void {
  // ... existing code ...

  // After placeholder lanes, before playhead:
  drawClips(ctx, state, clips, selectedClipId, pendingInPoint);

  // Draw playhead (last, so it's on top)
  drawPlayhead(ctx, state, currentTime);
}
```

Update `src/lib/components/Timeline.svelte` to pass clip data to the draw function and handle clip handle dragging. Add imports and wire up the clip store:

```svelte
<script lang="ts">
  import {
    currentTime,
    duration,
  } from '$lib/stores/videoSession.svelte';
  import {
    getClips,
    getSelectedClipId,
    getPendingInPoint,
    selectClip,
    updateClip,
  } from '$lib/stores/clips.svelte';
  import {
    drawTimeline,
    type TimelineState,
  } from '$lib/timeline/renderer';
  import {
    computeZoom,
    handleClick as computeClickTime,
  } from '$lib/timeline/interactions';
  import { hitTestClip, type ClipHitResult } from '$lib/timeline/clipRenderer';

  // ... keep existing canvas/container/state declarations ...

  let dragTarget = $state<ClipHitResult | null>(null);

  // In the draw function, pass clips:
  // drawTimeline(ctx, timelineState, currentTime, duration, getClips(), getSelectedClipId(), getPendingInPoint());

  // In handleMouseDown, check for clip handle hits first:
  function handleMouseDown(e: MouseEvent) {
    const x = getCanvasX(e);
    const y = getCanvasY(e);

    const hit = hitTestClip(x, y, timelineState, getClips());
    if (hit) {
      if (hit.edge === 'body') {
        selectClip(hit.clipId);
      } else {
        dragTarget = hit;
        selectClip(hit.clipId);
      }
      isDragging = true;
      return;
    }

    isDragging = true;
    const targetTime = computeClickTime(x, timelineState, duration);
    seekTo(targetTime);
  }

  function handleMouseMove(e: MouseEvent) {
    if (!isDragging) return;
    const x = getCanvasX(e);

    if (dragTarget) {
      const time = computeClickTime(x, timelineState, duration);
      if (dragTarget.edge === 'start') {
        updateClip(dragTarget.clipId, { startTime: time });
      } else if (dragTarget.edge === 'end') {
        updateClip(dragTarget.clipId, { endTime: time });
      }
      return;
    }

    const targetTime = computeClickTime(x, timelineState, duration);
    seekTo(targetTime);
  }

  function handleMouseUp() {
    isDragging = false;
    dragTarget = null;
  }

  function getCanvasY(e: MouseEvent): number {
    if (!canvas) return 0;
    const rect = canvas.getBoundingClientRect();
    return e.clientY - rect.top;
  }
</script>
```

- [ ] **Step 7: Implement ClipList component**

Rewrite `src/lib/components/ClipList.svelte`:

```svelte
<script lang="ts">
  import {
    getClips,
    getSelectedClipId,
    selectClip,
    removeClip,
    updateClip,
  } from '$lib/stores/clips.svelte';
  import { formatTime, parseTime } from '$lib/utils/time';
  import { currentTime } from '$lib/stores/videoSession.svelte';

  let clips = $derived(getClips());
  let selectedId = $derived(getSelectedClipId());

  function handleSelect(id: string) {
    selectClip(id);
    const clip = clips.find((c) => c.id === id);
    if (clip) {
      currentTime = clip.startTime;
      const videoEl = document.querySelector('video');
      if (videoEl) videoEl.currentTime = clip.startTime;
    }
  }

  function handleTimeEdit(clipId: string, field: 'startTime' | 'endTime', value: string) {
    const parsed = parseTime(value);
    if (parsed !== null) {
      updateClip(clipId, { [field]: parsed });
    }
  }

  function handleLabelEdit(clipId: string, value: string) {
    updateClip(clipId, { label: value });
  }
</script>

<div class="clip-list">
  {#if clips.length === 0}
    <div class="empty">No clips yet — press I to mark in-point, O to mark out-point</div>
  {:else}
    <div class="header">
      <span>CLIPS ({clips.length})</span>
    </div>
    {#each clips as clip (clip.id)}
      <button
        class="clip-row"
        class:selected={clip.id === selectedId}
        onclick={() => handleSelect(clip.id)}
      >
        <span class="color-swatch" style="background: {clip.color}"></span>
        <input
          class="label-input"
          type="text"
          value={clip.label}
          onchange={(e) => handleLabelEdit(clip.id, (e.target as HTMLInputElement).value)}
          onclick={(e) => e.stopPropagation()}
        />
        <input
          class="time-input"
          type="text"
          value={formatTime(clip.startTime)}
          onchange={(e) => handleTimeEdit(clip.id, 'startTime', (e.target as HTMLInputElement).value)}
          onclick={(e) => e.stopPropagation()}
        />
        <span class="arrow">→</span>
        <input
          class="time-input"
          type="text"
          value={formatTime(clip.endTime)}
          onchange={(e) => handleTimeEdit(clip.id, 'endTime', (e.target as HTMLInputElement).value)}
          onclick={(e) => e.stopPropagation()}
        />
        <button
          class="delete-btn"
          onclick={(e) => { e.stopPropagation(); removeClip(clip.id); }}
          title="Delete clip"
        >✕</button>
      </button>
    {/each}
  {/if}
</div>

<style>
  .clip-list {
    padding: 8px 12px;
    background: var(--bg-secondary);
    min-height: 60px;
    max-height: 200px;
    overflow-y: auto;
    border-top: 1px solid var(--border);
  }

  .empty {
    color: var(--text-muted);
    font-size: 13px;
    padding: 8px 0;
  }

  .header {
    font-size: 11px;
    color: var(--text-muted);
    text-transform: uppercase;
    letter-spacing: 0.5px;
    margin-bottom: 4px;
  }

  .clip-row {
    display: flex;
    align-items: center;
    gap: 8px;
    padding: 6px 8px;
    border-radius: 4px;
    width: 100%;
    text-align: left;
    background: transparent;
    border: 1px solid transparent;
  }

  .clip-row:hover {
    background: var(--bg-tertiary);
    color: var(--text-primary);
  }

  .clip-row.selected {
    border-color: var(--accent);
    background: var(--bg-tertiary);
  }

  .color-swatch {
    width: 12px;
    height: 12px;
    border-radius: 2px;
    flex-shrink: 0;
  }

  .label-input {
    background: transparent;
    border: none;
    color: var(--text-primary);
    font-size: 13px;
    width: 80px;
    padding: 2px 4px;
  }

  .label-input:focus {
    background: var(--bg-primary);
    outline: 1px solid var(--accent);
    border-radius: 2px;
  }

  .time-input {
    background: transparent;
    border: none;
    color: var(--text-secondary);
    font-family: var(--font-mono);
    font-size: 12px;
    width: 85px;
    padding: 2px 4px;
    text-align: center;
  }

  .time-input:focus {
    background: var(--bg-primary);
    outline: 1px solid var(--accent);
    border-radius: 2px;
  }

  .arrow {
    color: var(--text-muted);
    font-size: 12px;
  }

  .delete-btn {
    font-size: 14px;
    padding: 2px 6px;
    color: var(--text-muted);
    background: transparent;
  }

  .delete-btn:hover {
    color: var(--danger);
    background: transparent;
  }
</style>
```

- [ ] **Step 8: Verify clip creation and management**

```bash
cargo tauri dev
```

Load a video. Expected: Press I at one point, O at another → a colored clip appears on the timeline and in the clip list. Drag clip handles to adjust. Click a clip row to select it. Press ✕ to delete. Edit timestamps by clicking the time values.

- [ ] **Step 9: Commit**

```bash
git add -A
git commit -m "feat: add clip management with I/O marking, timeline markers, and clip list"
```

---

### Task 8: Transport Controls & Keyboard Shortcuts

**Files:**
- Modify: `src/lib/components/TransportControls.svelte`
- Modify: `src/App.svelte` (global keydown handler)

**Interfaces:**
- Consumes: `currentTime`, `isPlaying`, `fps`, `duration`, `keyframePositions` from videoSession store; `markInPoint`, `markOutPoint`, `getSelectedClipId`, `removeClip`, `selectClip`, `getClips` from clips store
- Produces: Full transport control bar with buttons and all keyboard shortcuts from the spec

- [ ] **Step 1: Implement TransportControls component**

Rewrite `src/lib/components/TransportControls.svelte`:

```svelte
<script lang="ts">
  import {
    currentTime,
    isPlaying,
    fps,
    duration,
    keyframePositions,
  } from '$lib/stores/videoSession.svelte';
  import { markInPoint, markOutPoint } from '$lib/stores/clips.svelte';
  import { formatTime } from '$lib/utils/time';

  let shuttleSpeed = $state(0); // -2, -1, 0, 1, 2

  function seekTo(time: number) {
    const clamped = Math.max(0, Math.min(time, duration));
    currentTime = clamped;
    const videoEl = document.querySelector('video');
    if (videoEl) videoEl.currentTime = clamped;
  }

  function togglePlayPause() {
    const videoEl = document.querySelector('video');
    if (!videoEl) return;
    if (videoEl.paused) {
      videoEl.play();
    } else {
      videoEl.pause();
    }
  }

  function stepFrame(direction: 1 | -1) {
    const videoEl = document.querySelector('video');
    if (videoEl && !videoEl.paused) videoEl.pause();
    seekTo(currentTime + direction * (1 / fps));
  }

  function jumpKeyframe(direction: 1 | -1) {
    if (keyframePositions.length === 0) return;
    const positions = keyframePositions;

    if (direction > 0) {
      const next = positions.find((p) => p > currentTime + 0.01);
      if (next !== undefined) seekTo(next);
    } else {
      const prev = [...positions].reverse().find((p) => p < currentTime - 0.01);
      if (prev !== undefined) seekTo(prev);
    }
  }

  let hasKeyframes = $derived(keyframePositions.length > 0);

  export function handleKeyAction(action: string) {
    switch (action) {
      case 'play-pause':
        togglePlayPause();
        break;
      case 'frame-back':
        stepFrame(-1);
        break;
      case 'frame-forward':
        stepFrame(1);
        break;
      case 'keyframe-back':
        jumpKeyframe(-1);
        break;
      case 'keyframe-forward':
        jumpKeyframe(1);
        break;
      case 'seek-back-5':
        seekTo(currentTime - 5);
        break;
      case 'seek-forward-5':
        seekTo(currentTime + 5);
        break;
      case 'seek-back-1':
        seekTo(currentTime - 1);
        break;
      case 'seek-forward-1':
        seekTo(currentTime + 1);
        break;
      case 'mark-in':
        markInPoint(currentTime);
        break;
      case 'mark-out':
        markOutPoint(currentTime);
        break;
      default:
        break;
    }
  }
</script>

<div class="transport-controls">
  <div class="buttons">
    <button
      onclick={() => jumpKeyframe(-1)}
      disabled={!hasKeyframes}
      title="Previous keyframe (Shift+,)"
    >◄K</button>
    <button onclick={() => stepFrame(-1)} title="Previous frame (,)">◄|</button>
    <button onclick={togglePlayPause} title="Play/Pause (Space)">
      {isPlaying ? '❚❚' : '▶'}
    </button>
    <button onclick={() => stepFrame(1)} title="Next frame (.)">|►</button>
    <button
      onclick={() => jumpKeyframe(1)}
      disabled={!hasKeyframes}
      title="Next keyframe (Shift+.)"
    >K►</button>
  </div>

  <div class="time-display">
    <span class="current">{formatTime(currentTime)}</span>
    <span class="separator">/</span>
    <span class="total">{formatTime(duration)}</span>
  </div>

  <div class="mark-buttons">
    <button class="mark-btn" onclick={() => markInPoint(currentTime)} title="Set in-point (I)">
      I
    </button>
    <button class="mark-btn" onclick={() => markOutPoint(currentTime)} title="Set out-point (O)">
      O
    </button>
  </div>
</div>

<style>
  .transport-controls {
    display: flex;
    align-items: center;
    padding: 8px 12px;
    background: var(--bg-secondary);
    border-top: 1px solid var(--border);
    border-bottom: 1px solid var(--border);
    gap: 16px;
  }

  .buttons {
    display: flex;
    gap: 4px;
  }

  .buttons button {
    font-size: 13px;
    padding: 4px 8px;
    min-width: 32px;
  }

  .time-display {
    font-family: var(--font-mono);
    font-size: 14px;
  }

  .current {
    color: var(--text-primary);
  }

  .separator {
    color: var(--text-muted);
    margin: 0 4px;
  }

  .total {
    color: var(--text-secondary);
  }

  .mark-buttons {
    margin-left: auto;
    display: flex;
    gap: 4px;
  }

  .mark-btn {
    font-weight: 700;
    font-size: 14px;
    padding: 4px 12px;
    background: var(--bg-tertiary);
    border: 1px solid var(--border);
  }
</style>
```

- [ ] **Step 2: Add global keyboard handler in App.svelte**

Add to `src/App.svelte` `<script>` block:

```svelte
<script lang="ts">
  // ... existing imports ...
  import {
    getSelectedClipId,
    removeClip,
    selectClip,
    getClips,
    markInPoint,
    markOutPoint,
  } from '$lib/stores/clips.svelte';
  import { currentTime, duration, fps, keyframePositions } from '$lib/stores/videoSession.svelte';

  function handleGlobalKeydown(e: KeyboardEvent) {
    // Don't capture when typing in an input
    const target = e.target as HTMLElement;
    if (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA') return;

    switch (e.key) {
      case ' ':
        e.preventDefault();
        toggleVideo();
        break;
      case ',':
        e.preventDefault();
        if (e.shiftKey) {
          jumpKeyframe(-1);
        } else {
          stepFrame(-1);
        }
        break;
      case '.':
        e.preventDefault();
        if (e.shiftKey) {
          jumpKeyframe(1);
        } else {
          stepFrame(1);
        }
        break;
      case 'ArrowLeft':
        e.preventDefault();
        seekBy(e.shiftKey ? -1 : -5);
        break;
      case 'ArrowRight':
        e.preventDefault();
        seekBy(e.shiftKey ? 1 : 5);
        break;
      case 'i':
      case 'I':
        e.preventDefault();
        markInPoint(currentTime);
        break;
      case 'o':
      case 'O':
        e.preventDefault();
        markOutPoint(currentTime);
        break;
      case 'j':
      case 'J':
        e.preventDefault();
        // Shuttle reverse — decrease playback rate
        adjustShuttle(-1);
        break;
      case 'k':
      case 'K':
        e.preventDefault();
        toggleVideo();
        break;
      case 'l':
      case 'L':
        e.preventDefault();
        // Shuttle forward — increase playback rate
        adjustShuttle(1);
        break;
      case 'Delete':
      case 'Backspace':
        e.preventDefault();
        const selectedId = getSelectedClipId();
        if (selectedId) removeClip(selectedId);
        break;
      case 'a':
        if (e.metaKey) {
          e.preventDefault();
          // Select all — not directly applicable with single selection,
          // but could highlight all clips in future
        }
        break;
      case 'e':
        if (e.metaKey) {
          e.preventDefault();
          showExportDialog = true;
        }
        break;
      default:
        break;
    }
  }

  let showExportDialog = $state(false);
  let shuttleRate = $state(1);

  function toggleVideo() {
    const videoEl = document.querySelector('video');
    if (!videoEl) return;
    if (videoEl.paused) videoEl.play();
    else videoEl.pause();
  }

  function stepFrame(dir: 1 | -1) {
    const videoEl = document.querySelector('video');
    if (videoEl && !videoEl.paused) videoEl.pause();
    seekTo(currentTime + dir * (1 / fps));
  }

  function jumpKeyframe(dir: 1 | -1) {
    if (keyframePositions.length === 0) return;
    if (dir > 0) {
      const next = keyframePositions.find((p) => p > currentTime + 0.01);
      if (next !== undefined) seekTo(next);
    } else {
      const prev = [...keyframePositions].reverse().find((p) => p < currentTime - 0.01);
      if (prev !== undefined) seekTo(prev);
    }
  }

  function seekBy(seconds: number) {
    seekTo(currentTime + seconds);
  }

  function seekTo(time: number) {
    const clamped = Math.max(0, Math.min(time, duration));
    currentTime = clamped;
    const videoEl = document.querySelector('video');
    if (videoEl) videoEl.currentTime = clamped;
  }

  function adjustShuttle(dir: 1 | -1) {
    const videoEl = document.querySelector('video');
    if (!videoEl) return;
    shuttleRate = Math.max(0.25, Math.min(4, shuttleRate + dir * 0.5));
    videoEl.playbackRate = shuttleRate;
    if (videoEl.paused) videoEl.play();
  }
</script>

<svelte:window onkeydown={handleGlobalKeydown} />
```

- [ ] **Step 3: Verify all shortcuts work**

```bash
cargo tauri dev
```

Load a video. Test each shortcut: Space (play/pause), I/O (mark clips), comma/period (frame step), arrows (seek), Shift+comma/period (keyframe jump — disabled until download completes), Delete (remove selected clip), J/K/L (shuttle).

- [ ] **Step 4: Commit**

```bash
git add -A
git commit -m "feat: add transport controls and keyboard shortcuts"
```

---

### Task 9: Keyframe Index & Frame Navigation

**Files:**
- Modify: `src-tauri/src/services/keyframe_index.rs`
- Modify: `src-tauri/src/commands/media_analysis.rs`
- Modify: `src-tauri/src/lib.rs` (register command)
- Modify: `src/lib/bindings/mediaAnalysis.ts`
- Modify: `src/lib/stores/videoSession.svelte.ts` (auto-trigger after download)

**Interfaces:**
- Consumes: `localFilePath` from videoSession store
- Produces:
  - Tauri command `extract_keyframes(file_path: String) -> Result<Vec<f64>, String>`
  - TypeScript `extractKeyframes(filePath: string): Promise<number[]>`
  - `keyframePositions` populated in the store after download

- [ ] **Step 1: Write Rust tests for ffprobe output parsing**

Write `src-tauri/src/services/keyframe_index.rs`:

```rust
use std::process::Command;

pub fn parse_ffprobe_output(output: &str) -> Vec<f64> {
    output
        .lines()
        .filter_map(|line| {
            let parts: Vec<&str> = line.split(',').collect();
            // Format: media_type,pts_time,flags
            // We want lines where flags contain 'K' (keyframe)
            if parts.len() >= 3 && parts[2].contains('K') {
                parts[1].parse::<f64>().ok()
            } else {
                None
            }
        })
        .collect()
}

pub fn extract_keyframes(file_path: &str) -> Result<Vec<f64>, String> {
    let output = Command::new("ffprobe")
        .args([
            "-select_streams", "v",
            "-show_entries", "frame=pts_time,flags",
            "-of", "csv=p=0",
            "-skip_frame", "nokey",
            file_path,
        ])
        .output()
        .map_err(|e| format!("Failed to run ffprobe: {e}"))?;

    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        return Err(format!("ffprobe failed: {stderr}"));
    }

    let stdout = String::from_utf8_lossy(&output.stdout);
    let mut positions = parse_ffprobe_output(&stdout);
    positions.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
    Ok(positions)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_ffprobe_keyframes() {
        let output = "video,0.000000,K__\nvideo,0.500000,___\nvideo,1.000000,K__\nvideo,1.500000,___\nvideo,2.000000,K__\n";
        let result = parse_ffprobe_output(output);
        assert_eq!(result.len(), 3);
        assert!((result[0] - 0.0).abs() < 0.001);
        assert!((result[1] - 1.0).abs() < 0.001);
        assert!((result[2] - 2.0).abs() < 0.001);
    }

    #[test]
    fn test_parse_ffprobe_empty() {
        assert!(parse_ffprobe_output("").is_empty());
    }

    #[test]
    fn test_parse_ffprobe_no_keyframes() {
        let output = "video,0.500000,___\nvideo,1.500000,___\n";
        assert!(parse_ffprobe_output(output).is_empty());
    }
}
```

- [ ] **Step 2: Run Rust tests**

```bash
cd src-tauri && cargo test services::keyframe_index -- --nocapture
```

Expected: all tests PASS.

- [ ] **Step 3: Write Tauri command and TypeScript binding**

Add to `src-tauri/src/commands/media_analysis.rs`:

```rust
use crate::services::keyframe_index;

#[tauri::command]
pub async fn extract_keyframes(file_path: String) -> Result<Vec<f64>, String> {
    tokio::task::spawn_blocking(move || keyframe_index::extract_keyframes(&file_path))
        .await
        .map_err(|e| format!("Task failed: {e}"))?
}
```

Register in `lib.rs`:

```rust
use commands::{dependencies, media_analysis, video};

.invoke_handler(tauri::generate_handler![
    dependencies::check_dependencies,
    dependencies::install_dependency,
    video::resolve_url,
    video::start_download,
    media_analysis::extract_keyframes,
])
```

Add to `src/lib/bindings/mediaAnalysis.ts`:

```typescript
import { invoke } from '@tauri-apps/api/core';

export interface ThumbnailSpritesheet {
  filePath: string;
  startIndex: number;
  count: number;
  thumbWidth: number;
  thumbHeight: number;
  columns: number;
  intervalSeconds: number;
}

export async function extractKeyframes(filePath: string): Promise<number[]> {
  return invoke<number[]>('extract_keyframes', { filePath });
}
```

- [ ] **Step 4: Auto-trigger keyframe extraction after download**

Update `src/lib/stores/videoSession.svelte.ts` — in the `beginDownload` function, after the download finishes trigger keyframe extraction:

```typescript
import { extractKeyframes } from '$lib/bindings/mediaAnalysis';

// Add to the onFinished callback inside beginDownload:
(success, path) => {
  if (success) {
    downloadProgress = 1.0;
    localFilePath = path;
    // Trigger post-download processing
    triggerPostDownloadProcessing(path);
  }
}

async function triggerPostDownloadProcessing(filePath: string) {
  try {
    keyframePositions = await extractKeyframes(filePath);
  } catch (e) {
    console.error('Keyframe extraction failed:', e);
  }
  // Waveform and thumbnails will be added in Tasks 10 and 11
}
```

- [ ] **Step 5: Verify keyframe navigation works**

```bash
cargo tauri dev
```

Load a video, wait for download to complete. Expected: After download, keyframe jump buttons become enabled. Shift+comma/Shift+period jumps to the nearest keyframe.

- [ ] **Step 6: Commit**

```bash
git add -A
git commit -m "feat: add keyframe index extraction and frame/keyframe navigation"
```

---

### Task 10: Waveform Generation & Display

**Files:**
- Modify: `src-tauri/src/services/waveform_generator.rs`
- Modify: `src-tauri/src/commands/media_analysis.rs`
- Modify: `src-tauri/src/lib.rs` (register command)
- Modify: `src/lib/bindings/mediaAnalysis.ts`
- Create: `src/lib/timeline/waveformRenderer.ts`
- Modify: `src/lib/timeline/renderer.ts` (draw waveform layer)
- Modify: `src/lib/stores/videoSession.svelte.ts` (trigger after download)

**Interfaces:**
- Consumes: `localFilePath` from videoSession store, `TimelineState` from renderer
- Produces:
  - Tauri command `extract_waveform(file_path: String, sample_count: usize) -> Result<Vec<f64>, String>`
  - `drawWaveform(ctx, state, peaks, y, height)` — renders waveform on canvas
  - `waveformPeaks` populated in store after download

- [ ] **Step 1: Write Rust waveform extraction with tests**

Write `src-tauri/src/services/waveform_generator.rs`:

```rust
use std::process::Command;

pub fn extract_waveform(file_path: &str, sample_count: usize) -> Result<Vec<f64>, String> {
    // Use ffmpeg to extract raw audio samples, then compute peaks
    // Pipeline: decode audio → mono → output raw PCM → read samples → compute peaks
    let output = Command::new("ffmpeg")
        .args([
            "-i", file_path,
            "-ac", "1",              // mono
            "-filter:a", &format!("aresample={sample_count}"), // resample to desired count
            "-f", "f32le",           // 32-bit float little-endian
            "-vn",                   // no video
            "-",                     // output to stdout
        ])
        .output()
        .map_err(|e| format!("Failed to run ffmpeg: {e}"))?;

    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        return Err(format!("ffmpeg waveform extraction failed: {stderr}"));
    }

    let samples = parse_f32_samples(&output.stdout);
    let peaks = compute_peaks(&samples, sample_count);
    Ok(peaks)
}

fn parse_f32_samples(data: &[u8]) -> Vec<f32> {
    data.chunks_exact(4)
        .map(|chunk| f32::from_le_bytes([chunk[0], chunk[1], chunk[2], chunk[3]]))
        .collect()
}

fn compute_peaks(samples: &[f32], target_count: usize) -> Vec<f64> {
    if samples.is_empty() || target_count == 0 {
        return vec![0.0; target_count];
    }

    let chunk_size = (samples.len() as f64 / target_count as f64).ceil() as usize;
    let chunk_size = chunk_size.max(1);

    let mut peaks: Vec<f64> = samples
        .chunks(chunk_size)
        .map(|chunk| {
            chunk.iter().map(|s| s.abs() as f64).fold(0.0_f64, f64::max)
        })
        .collect();

    // Normalize to 0.0-1.0
    let max_peak = peaks.iter().cloned().fold(0.0_f64, f64::max);
    if max_peak > 0.0 {
        for peak in &mut peaks {
            *peak /= max_peak;
        }
    }

    // Pad or truncate to exact target count
    peaks.resize(target_count, 0.0);
    peaks
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_compute_peaks_basic() {
        let samples = vec![0.5, -0.8, 0.3, -0.1, 0.9, -0.2];
        let peaks = compute_peaks(&samples, 3);
        assert_eq!(peaks.len(), 3);
        assert!(peaks[0] > 0.0); // max of [0.5, -0.8] → 0.8
        assert!(peaks[1] > 0.0); // max of [0.3, -0.1] → 0.3
        assert!(peaks[2] > 0.0); // max of [0.9, -0.2] → 0.9
        // Normalized: peak[2] should be 1.0 (it's the max)
        assert!((peaks[2] - 1.0).abs() < 0.001);
    }

    #[test]
    fn test_compute_peaks_empty() {
        let peaks = compute_peaks(&[], 5);
        assert_eq!(peaks.len(), 5);
        assert!(peaks.iter().all(|p| *p == 0.0));
    }

    #[test]
    fn test_parse_f32_samples() {
        let val: f32 = 0.5;
        let bytes = val.to_le_bytes();
        let samples = parse_f32_samples(&bytes);
        assert_eq!(samples.len(), 1);
        assert!((samples[0] - 0.5).abs() < 0.001);
    }
}
```

- [ ] **Step 2: Run Rust tests**

```bash
cd src-tauri && cargo test services::waveform_generator -- --nocapture
```

Expected: all tests PASS.

- [ ] **Step 3: Add Tauri command and binding**

Add to `src-tauri/src/commands/media_analysis.rs`:

```rust
use crate::services::{keyframe_index, waveform_generator};

#[tauri::command]
pub async fn extract_waveform(
    file_path: String,
    sample_count: usize,
) -> Result<Vec<f64>, String> {
    tokio::task::spawn_blocking(move || {
        waveform_generator::extract_waveform(&file_path, sample_count)
    })
    .await
    .map_err(|e| format!("Task failed: {e}"))?
}
```

Register in `lib.rs` — add `media_analysis::extract_waveform`.

Add to `src/lib/bindings/mediaAnalysis.ts`:

```typescript
export async function extractWaveform(
  filePath: string,
  sampleCount: number
): Promise<number[]> {
  return invoke<number[]>('extract_waveform', { filePath, sampleCount });
}
```

- [ ] **Step 4: Create waveform renderer**

Create `src/lib/timeline/waveformRenderer.ts`:

```typescript
import { timeToX, type TimelineState } from './renderer';

export function drawWaveform(
  ctx: CanvasRenderingContext2D,
  state: TimelineState,
  peaks: number[],
  duration: number,
  y: number,
  height: number
): void {
  if (peaks.length === 0) return;

  const { width, visibleStart, visibleEnd } = state;
  const visibleRange = visibleEnd - visibleStart;

  ctx.fillStyle = '#89b4fa44';
  ctx.strokeStyle = '#89b4fa88';
  ctx.lineWidth = 1;

  ctx.beginPath();
  ctx.moveTo(0, y + height);

  for (let px = 0; px < width; px++) {
    const time = visibleStart + (px / width) * visibleRange;
    const sampleIndex = Math.floor((time / duration) * peaks.length);
    const clampedIndex = Math.max(0, Math.min(sampleIndex, peaks.length - 1));

    // Aggregate nearby samples for this pixel
    const startSample = Math.floor(
      ((visibleStart + ((px - 0.5) / width) * visibleRange) / duration) * peaks.length
    );
    const endSample = Math.floor(
      ((visibleStart + ((px + 0.5) / width) * visibleRange) / duration) * peaks.length
    );

    let maxPeak = 0;
    for (let i = Math.max(0, startSample); i <= Math.min(endSample, peaks.length - 1); i++) {
      maxPeak = Math.max(maxPeak, peaks[i]);
    }

    const barHeight = maxPeak * height;
    ctx.lineTo(px, y + height - barHeight);
  }

  ctx.lineTo(width, y + height);
  ctx.closePath();
  ctx.fill();
  ctx.stroke();
}
```

- [ ] **Step 5: Wire waveform into the timeline renderer**

Update `src/lib/timeline/renderer.ts` — replace the waveform placeholder with real rendering when data is available:

```typescript
import { drawWaveform } from './waveformRenderer';

// Update drawTimeline to accept waveformPeaks parameter and conditionally draw:
export function drawTimeline(
  ctx: CanvasRenderingContext2D,
  state: TimelineState,
  currentTime: number,
  duration: number,
  clips: Clip[] = [],
  selectedClipId: string | null = null,
  pendingInPoint: number | null = null,
  waveformPeaks: number[] = [],
  thumbnailSpritesheets: any[] = []  // Will be typed in Task 11
): void {
  // ... existing clear + background ...

  drawTimeTicks(ctx, state, duration);

  // Thumbnail lane
  drawPlaceholderLane(ctx, state, 0, THUMB_LANE_HEIGHT, 'Thumbnails');

  // Waveform lane
  if (waveformPeaks.length > 0) {
    drawWaveform(ctx, state, waveformPeaks, duration, THUMB_LANE_HEIGHT, WAVEFORM_LANE_HEIGHT);
  } else {
    drawPlaceholderLane(ctx, state, THUMB_LANE_HEIGHT, WAVEFORM_LANE_HEIGHT, 'Waveform');
  }

  // Clips
  drawClips(ctx, state, clips, selectedClipId, pendingInPoint);

  // Playhead
  drawPlayhead(ctx, state, currentTime);
}
```

- [ ] **Step 6: Trigger waveform extraction after download**

Update `triggerPostDownloadProcessing` in `src/lib/stores/videoSession.svelte.ts`:

```typescript
import { extractKeyframes, extractWaveform } from '$lib/bindings/mediaAnalysis';

async function triggerPostDownloadProcessing(filePath: string) {
  // Run keyframe extraction and waveform in parallel
  const [keyframes, waveform] = await Promise.allSettled([
    extractKeyframes(filePath),
    extractWaveform(filePath, 8000),
  ]);

  if (keyframes.status === 'fulfilled') {
    keyframePositions = keyframes.value;
  } else {
    console.error('Keyframe extraction failed:', keyframes.reason);
  }

  if (waveform.status === 'fulfilled') {
    waveformPeaks = waveform.value;
  } else {
    console.error('Waveform extraction failed:', waveform.reason);
  }

  // Thumbnails will be added in Task 11
}
```

- [ ] **Step 7: Verify waveform appears after download**

```bash
cargo tauri dev
```

Load a video, wait for download to complete. Expected: After download, the "Generating Waveform…" placeholder is replaced by a real blue waveform visualization. Zooming in shows more detail.

- [ ] **Step 8: Commit**

```bash
git add -A
git commit -m "feat: add waveform generation and timeline display"
```

---

### Task 11: Thumbnail Extraction & Display

**Files:**
- Modify: `src-tauri/src/services/thumbnail_extractor.rs`
- Modify: `src-tauri/src/commands/media_analysis.rs`
- Modify: `src-tauri/src/lib.rs` (register command)
- Modify: `src/lib/bindings/mediaAnalysis.ts`
- Create: `src/lib/timeline/thumbnailRenderer.ts`
- Modify: `src/lib/timeline/renderer.ts` (draw thumbnail layer)
- Modify: `src/lib/stores/videoSession.svelte.ts` (trigger after download)

**Interfaces:**
- Consumes: `localFilePath`, `duration` from videoSession store, `TimelineState` from renderer, `ThumbnailSpritesheet` type
- Produces:
  - Tauri command `extract_thumbnails(file_path, duration, temp_dir) -> Result<Vec<ThumbnailSpritesheet>, String>`
  - `drawThumbnails(ctx, state, spritesheets, duration, y, height, loadedImages)` — renders thumbnail strip
  - `thumbnailSpritesheets` populated in store after download

- [ ] **Step 1: Write Rust thumbnail extraction with tests**

Write `src-tauri/src/services/thumbnail_extractor.rs`:

```rust
use crate::models::ThumbnailSpritesheet;
use std::path::Path;
use std::process::Command;

pub fn compute_interval(duration: f64) -> f64 {
    if duration < 600.0 {
        1.0
    } else if duration < 3600.0 {
        2.0
    } else {
        5.0
    }
}

pub fn extract_thumbnails(
    file_path: &str,
    duration: f64,
    output_dir: &str,
) -> Result<Vec<ThumbnailSpritesheet>, String> {
    std::fs::create_dir_all(output_dir)
        .map_err(|e| format!("Failed to create thumbnail dir: {e}"))?;

    let interval = compute_interval(duration);
    let total_frames = (duration / interval).ceil() as usize;
    let thumb_width = 160u32;
    let thumb_height = 90u32;
    let columns = 10u32;
    let rows_per_sheet = 10u32;
    let frames_per_sheet = (columns * rows_per_sheet) as usize;

    // Extract individual frames first
    let frames_pattern = format!("{}/frame_%06d.jpg", output_dir);
    let status = Command::new("ffmpeg")
        .args([
            "-i", file_path,
            "-vf", &format!("fps=1/{interval},scale={thumb_width}:{thumb_height}"),
            "-q:v", "5",
            &frames_pattern,
        ])
        .output()
        .map_err(|e| format!("Failed to extract thumbnails: {e}"))?;

    if !status.status.success() {
        let stderr = String::from_utf8_lossy(&status.stderr);
        return Err(format!("Thumbnail extraction failed: {stderr}"));
    }

    // Count actual extracted frames
    let actual_frames = std::fs::read_dir(output_dir)
        .map_err(|e| format!("Failed to read thumbnail dir: {e}"))?
        .filter_map(|e| e.ok())
        .filter(|e| {
            e.path()
                .file_name()
                .map(|n| n.to_string_lossy().starts_with("frame_"))
                .unwrap_or(false)
        })
        .count();

    // Build sprite sheet metadata (individual frames for now)
    // A production version would combine into actual sprite sheets
    let mut sheets = Vec::new();
    let mut frame_index = 0;

    while frame_index < actual_frames {
        let count = std::cmp::min(frames_per_sheet, actual_frames - frame_index);
        sheets.push(ThumbnailSpritesheet {
            file_path: output_dir.to_string(),
            start_index: frame_index,
            count,
            thumb_width,
            thumb_height,
            columns,
            interval_seconds: interval,
        });
        frame_index += count;
    }

    Ok(sheets)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_compute_interval_short_video() {
        assert!((compute_interval(120.0) - 1.0).abs() < 0.001);
    }

    #[test]
    fn test_compute_interval_medium_video() {
        assert!((compute_interval(1800.0) - 2.0).abs() < 0.001);
    }

    #[test]
    fn test_compute_interval_long_video() {
        assert!((compute_interval(7200.0) - 5.0).abs() < 0.001);
    }
}
```

- [ ] **Step 2: Run Rust tests**

```bash
cd src-tauri && cargo test services::thumbnail_extractor -- --nocapture
```

Expected: all tests PASS.

- [ ] **Step 3: Add Tauri command and TypeScript binding**

Add to `src-tauri/src/commands/media_analysis.rs`:

```rust
use crate::services::{keyframe_index, thumbnail_extractor, waveform_generator};
use crate::models::ThumbnailSpritesheet;

#[tauri::command]
pub async fn extract_thumbnails(
    file_path: String,
    duration: f64,
) -> Result<Vec<ThumbnailSpritesheet>, String> {
    tokio::task::spawn_blocking(move || {
        let temp_dir = std::env::temp_dir()
            .join("video-clipper-thumbs")
            .join(uuid::Uuid::new_v4().to_string());
        let temp_dir_str = temp_dir.to_string_lossy().to_string();
        thumbnail_extractor::extract_thumbnails(&file_path, duration, &temp_dir_str)
    })
    .await
    .map_err(|e| format!("Task failed: {e}"))?
}
```

Register in `lib.rs`.

Add to `src/lib/bindings/mediaAnalysis.ts`:

```typescript
export async function extractThumbnails(
  filePath: string,
  duration: number
): Promise<ThumbnailSpritesheet[]> {
  return invoke<ThumbnailSpritesheet[]>('extract_thumbnails', {
    filePath,
    duration,
  });
}
```

- [ ] **Step 4: Create thumbnail renderer**

Create `src/lib/timeline/thumbnailRenderer.ts`:

```typescript
import { timeToX, xToTime, type TimelineState } from './renderer';
import type { ThumbnailSpritesheet } from '$lib/bindings/mediaAnalysis';
import { convertFileSrc } from '@tauri-apps/api/core';

const imageCache = new Map<string, HTMLImageElement>();

function getImagePath(dir: string, frameIndex: number): string {
  const paddedIndex = String(frameIndex + 1).padStart(6, '0');
  return `${dir}/frame_${paddedIndex}.jpg`;
}

function loadImage(path: string): HTMLImageElement | null {
  if (imageCache.has(path)) {
    return imageCache.get(path)!;
  }

  const img = new Image();
  img.src = convertFileSrc(path);
  img.onload = () => imageCache.set(path, img);
  imageCache.set(path, img); // Store immediately (may not be loaded yet)
  return null; // Return null until loaded
}

export function drawThumbnails(
  ctx: CanvasRenderingContext2D,
  state: TimelineState,
  spritesheets: ThumbnailSpritesheet[],
  duration: number,
  y: number,
  height: number
): void {
  if (spritesheets.length === 0) return;

  const sheet = spritesheets[0]; // Use first sheet's interval
  const interval = sheet.intervalSeconds;
  const thumbWidth = Math.max(
    height * (sheet.thumbWidth / sheet.thumbHeight),
    20
  );

  // Calculate how many thumbnails fit at ~100px spacing
  const targetSpacing = 100;
  const step = Math.max(1, Math.round(targetSpacing / thumbWidth));

  const startTime = state.visibleStart;
  const endTime = state.visibleEnd;

  const startFrame = Math.floor(startTime / interval);
  const endFrame = Math.ceil(endTime / interval);

  for (let fi = startFrame; fi <= endFrame; fi += step) {
    const time = fi * interval;
    if (time < 0 || time > duration) continue;

    const x = timeToX(time, state);
    if (x < -thumbWidth || x > state.width + thumbWidth) continue;

    // Find which spritesheet contains this frame
    let globalIndex = fi;
    let foundSheet: ThumbnailSpritesheet | null = null;
    for (const s of spritesheets) {
      if (globalIndex >= s.startIndex && globalIndex < s.startIndex + s.count) {
        foundSheet = s;
        break;
      }
    }

    if (!foundSheet) continue;

    const localIndex = globalIndex - foundSheet.startIndex;
    const imgPath = getImagePath(foundSheet.filePath, globalIndex);
    const img = imageCache.get(imgPath);

    if (img && img.complete && img.naturalWidth > 0) {
      ctx.drawImage(img, x - thumbWidth / 2, y, thumbWidth, height);
    } else {
      // Draw placeholder
      ctx.fillStyle = '#353550';
      ctx.fillRect(x - thumbWidth / 2, y, thumbWidth, height);
      // Trigger load
      loadImage(imgPath);
    }

    // Thin border between thumbnails
    ctx.strokeStyle = '#45475a';
    ctx.strokeRect(x - thumbWidth / 2, y, thumbWidth, height);
  }
}
```

- [ ] **Step 5: Wire thumbnails into timeline renderer**

Update `src/lib/timeline/renderer.ts` — replace the thumbnail placeholder when data is available:

```typescript
import { drawThumbnails } from './thumbnailRenderer';
import type { ThumbnailSpritesheet } from '$lib/bindings/mediaAnalysis';

// In drawTimeline, replace thumbnail placeholder:
if (thumbnailSpritesheets.length > 0) {
  drawThumbnails(ctx, state, thumbnailSpritesheets, duration, 0, THUMB_LANE_HEIGHT);
} else {
  drawPlaceholderLane(ctx, state, 0, THUMB_LANE_HEIGHT, 'Thumbnails');
}
```

- [ ] **Step 6: Trigger thumbnail extraction after download**

Update `triggerPostDownloadProcessing` in `src/lib/stores/videoSession.svelte.ts`:

```typescript
import { extractKeyframes, extractWaveform, extractThumbnails } from '$lib/bindings/mediaAnalysis';

async function triggerPostDownloadProcessing(filePath: string) {
  const [keyframes, waveform, thumbnails] = await Promise.allSettled([
    extractKeyframes(filePath),
    extractWaveform(filePath, 8000),
    extractThumbnails(filePath, duration),
  ]);

  if (keyframes.status === 'fulfilled') {
    keyframePositions = keyframes.value;
  } else {
    console.error('Keyframe extraction failed:', keyframes.reason);
  }

  if (waveform.status === 'fulfilled') {
    waveformPeaks = waveform.value;
  } else {
    console.error('Waveform extraction failed:', waveform.reason);
  }

  if (thumbnails.status === 'fulfilled') {
    thumbnailSpritesheets = thumbnails.value;
  } else {
    console.error('Thumbnail extraction failed:', thumbnails.reason);
  }
}
```

- [ ] **Step 7: Verify thumbnails appear after download**

```bash
cargo tauri dev
```

Load a video, wait for download + processing. Expected: Thumbnail strip at the top of the timeline populates with video frames. Zooming in shows more frames at closer intervals.

- [ ] **Step 8: Commit**

```bash
git add -A
git commit -m "feat: add thumbnail extraction and timeline display"
```

---

### Task 12: Clip Export & Export Dialog

**Files:**
- Modify: `src-tauri/src/services/clip_exporter.rs`
- Modify: `src-tauri/src/commands/export.rs`
- Modify: `src-tauri/src/lib.rs` (register command)
- Create: `src/lib/bindings/export.ts`
- Create: `src/lib/components/ExportDialog.svelte`
- Modify: `src/App.svelte` (show export dialog)

**Interfaces:**
- Consumes: `ExportConfig`, `Clip`, `CutMode`, `ExportScope` from models; `localFilePath`, `downloadProgress`, `title` from videoSession store; `getClips`, `getSelectedClipId` from clips store; `outputDirectory` from preferences store
- Produces:
  - Tauri command `export_clips(config: ExportConfig, on_event: Channel) -> Result<Vec<String>, String>` (returns output file paths)
  - `ExportDialog` component with full export configuration
  - Complete export pipeline from UI to exported files

- [ ] **Step 1: Write Rust export service with tests**

Write `src-tauri/src/services/clip_exporter.rs`:

```rust
use crate::models::{Clip, CutMode, ExportConfig, ExportScope};
use std::path::{Path, PathBuf};
use std::process::Command;

pub fn build_ffmpeg_args(
    clip: &Clip,
    source: &str,
    output: &str,
    cut_mode: &CutMode,
) -> Vec<String> {
    let mut args = vec![
        "-y".to_string(),
        "-ss".to_string(),
        format!("{}", clip.start_time),
        "-to".to_string(),
        format!("{}", clip.end_time),
        "-i".to_string(),
        source.to_string(),
    ];

    match cut_mode {
        CutMode::Lossless => {
            args.extend(["-c".to_string(), "copy".to_string()]);
        }
        CutMode::Precise { format } => {
            args.extend([
                "-c:v".to_string(),
                "libx264".to_string(),
                "-c:a".to_string(),
                "aac".to_string(),
            ]);
        }
    }

    args.push(output.to_string());
    args
}

pub fn generate_output_path(
    output_dir: &str,
    video_title: &str,
    clip_label: &str,
    extension: &str,
) -> String {
    let sanitized_title = sanitize_filename(video_title);
    let sanitized_label = sanitize_filename(clip_label);
    let base = format!("{}/{} - {}.{}", output_dir, sanitized_title, sanitized_label, extension);

    if !Path::new(&base).exists() {
        return base;
    }

    for i in 2..100 {
        let candidate = format!(
            "{}/{} - {} ({}).{}",
            output_dir, sanitized_title, sanitized_label, i, extension
        );
        if !Path::new(&candidate).exists() {
            return candidate;
        }
    }

    base
}

fn sanitize_filename(name: &str) -> String {
    name.chars()
        .map(|c| if c == '/' || c == '\\' || c == ':' || c == '"' || c == '|' || c == '?' || c == '*' || c == '<' || c == '>' {
            '_'
        } else {
            c
        })
        .collect()
}

pub fn get_extension(source: &str, cut_mode: &CutMode) -> String {
    match cut_mode {
        CutMode::Lossless => {
            Path::new(source)
                .extension()
                .map(|e| e.to_string_lossy().to_string())
                .unwrap_or_else(|| "mp4".to_string())
        }
        CutMode::Precise { format } => format.clone(),
    }
}

pub fn export_single_clip(
    clip: &Clip,
    source: &str,
    output: &str,
    cut_mode: &CutMode,
) -> Result<(), String> {
    let args = build_ffmpeg_args(clip, source, output, cut_mode);
    let output_result = Command::new("ffmpeg")
        .args(&args)
        .output()
        .map_err(|e| format!("Failed to run ffmpeg: {e}"))?;

    if !output_result.status.success() {
        let stderr = String::from_utf8_lossy(&output_result.stderr);
        return Err(format!("ffmpeg export failed: {stderr}"));
    }

    Ok(())
}

pub fn export_merged(
    clips: &[Clip],
    source: &str,
    output: &str,
    cut_mode: &CutMode,
    temp_dir: &str,
) -> Result<(), String> {
    // First, export each clip to a temp file
    let mut temp_files = Vec::new();
    let ext = get_extension(source, cut_mode);

    for (i, clip) in clips.iter().enumerate() {
        let temp_path = format!("{}/merge_part_{}.{}", temp_dir, i, ext);
        export_single_clip(clip, source, &temp_path, cut_mode)?;
        temp_files.push(temp_path);
    }

    // Create concat file
    let concat_path = format!("{}/concat_list.txt", temp_dir);
    let concat_content: String = temp_files
        .iter()
        .map(|p| format!("file '{}'", p))
        .collect::<Vec<_>>()
        .join("\n");
    std::fs::write(&concat_path, concat_content)
        .map_err(|e| format!("Failed to write concat file: {e}"))?;

    // Run concat
    let result = Command::new("ffmpeg")
        .args([
            "-y",
            "-f", "concat",
            "-safe", "0",
            "-i", &concat_path,
            "-c", "copy",
            output,
        ])
        .output()
        .map_err(|e| format!("Failed to run ffmpeg concat: {e}"))?;

    if !result.status.success() {
        let stderr = String::from_utf8_lossy(&result.stderr);
        return Err(format!("ffmpeg merge failed: {stderr}"));
    }

    // Clean up temp files
    for f in &temp_files {
        let _ = std::fs::remove_file(f);
    }
    let _ = std::fs::remove_file(&concat_path);

    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_build_ffmpeg_args_lossless() {
        let clip = Clip {
            id: "1".to_string(),
            start_time: 10.5,
            end_time: 20.0,
            label: "Clip 1".to_string(),
            color: "#000".to_string(),
        };
        let args = build_ffmpeg_args(&clip, "input.mp4", "output.mp4", &CutMode::Lossless);
        assert!(args.contains(&"-c".to_string()));
        assert!(args.contains(&"copy".to_string()));
        assert!(args.contains(&"10.5".to_string()));
        assert!(args.contains(&"20".to_string()));
    }

    #[test]
    fn test_build_ffmpeg_args_precise() {
        let clip = Clip {
            id: "1".to_string(),
            start_time: 5.0,
            end_time: 15.0,
            label: "Clip 1".to_string(),
            color: "#000".to_string(),
        };
        let mode = CutMode::Precise {
            format: "mp4".to_string(),
        };
        let args = build_ffmpeg_args(&clip, "input.mp4", "output.mp4", &mode);
        assert!(args.contains(&"-c:v".to_string()));
        assert!(args.contains(&"libx264".to_string()));
    }

    #[test]
    fn test_generate_output_path_no_collision() {
        let path = generate_output_path("/tmp", "My Video", "Clip 1", "mp4");
        assert!(path.contains("My Video"));
        assert!(path.contains("Clip 1"));
        assert!(path.ends_with(".mp4"));
    }

    #[test]
    fn test_sanitize_filename() {
        assert_eq!(sanitize_filename("a/b:c"), "a_b_c");
        assert_eq!(sanitize_filename("normal"), "normal");
    }

    #[test]
    fn test_get_extension_lossless() {
        assert_eq!(get_extension("video.webm", &CutMode::Lossless), "webm");
    }

    #[test]
    fn test_get_extension_precise() {
        let mode = CutMode::Precise {
            format: "mkv".to_string(),
        };
        assert_eq!(get_extension("video.webm", &mode), "mkv");
    }
}
```

- [ ] **Step 2: Run Rust tests**

```bash
cd src-tauri && cargo test services::clip_exporter -- --nocapture
```

Expected: all tests PASS.

- [ ] **Step 3: Add Tauri command**

Write `src-tauri/src/commands/export.rs`:

```rust
use crate::models::{ExportConfig, ExportScope};
use crate::services::clip_exporter;
use serde::Serialize;
use tauri::ipc::Channel;

#[derive(Clone, Serialize)]
#[serde(rename_all = "camelCase", tag = "event", content = "data")]
pub enum ExportEvent {
    Progress {
        current: usize,
        total: usize,
        label: String,
    },
    Finished {
        paths: Vec<String>,
    },
    Error {
        message: String,
    },
}

#[tauri::command]
pub async fn export_clips(
    config: ExportConfig,
    on_event: Channel<ExportEvent>,
) -> Result<Vec<String>, String> {
    tokio::task::spawn_blocking(move || {
        let ext = clip_exporter::get_extension(&config.source_file_path, &config.cut_mode);

        match config.export_scope {
            ExportScope::Individual => {
                let total = config.clips.len();
                let mut output_paths = Vec::new();

                for (i, clip) in config.clips.iter().enumerate() {
                    let _ = on_event.send(ExportEvent::Progress {
                        current: i + 1,
                        total,
                        label: clip.label.clone(),
                    });

                    let output = clip_exporter::generate_output_path(
                        &config.output_directory,
                        &config.video_title,
                        &clip.label,
                        &ext,
                    );

                    clip_exporter::export_single_clip(
                        clip,
                        &config.source_file_path,
                        &output,
                        &config.cut_mode,
                    )?;

                    output_paths.push(output);
                }

                let _ = on_event.send(ExportEvent::Finished {
                    paths: output_paths.clone(),
                });
                Ok(output_paths)
            }
            ExportScope::Merged => {
                let _ = on_event.send(ExportEvent::Progress {
                    current: 1,
                    total: 1,
                    label: "Merging clips".to_string(),
                });

                let output = clip_exporter::generate_output_path(
                    &config.output_directory,
                    &config.video_title,
                    "Merged",
                    &ext,
                );

                let temp_dir = std::env::temp_dir()
                    .join("video-clipper-merge")
                    .join(uuid::Uuid::new_v4().to_string());
                std::fs::create_dir_all(&temp_dir)
                    .map_err(|e| format!("Failed to create temp dir: {e}"))?;

                let mut sorted_clips = config.clips.clone();
                sorted_clips.sort_by(|a, b| {
                    a.start_time
                        .partial_cmp(&b.start_time)
                        .unwrap_or(std::cmp::Ordering::Equal)
                });

                clip_exporter::export_merged(
                    &sorted_clips,
                    &config.source_file_path,
                    &output,
                    &config.cut_mode,
                    &temp_dir.to_string_lossy(),
                )?;

                let _ = std::fs::remove_dir_all(&temp_dir);

                let paths = vec![output];
                let _ = on_event.send(ExportEvent::Finished {
                    paths: paths.clone(),
                });
                Ok(paths)
            }
        }
    })
    .await
    .map_err(|e| format!("Task failed: {e}"))?
}
```

Register in `lib.rs`:

```rust
use commands::{dependencies, export, media_analysis, video};

.invoke_handler(tauri::generate_handler![
    dependencies::check_dependencies,
    dependencies::install_dependency,
    video::resolve_url,
    video::start_download,
    media_analysis::extract_keyframes,
    media_analysis::extract_waveform,
    media_analysis::extract_thumbnails,
    export::export_clips,
])
```

- [ ] **Step 4: Write TypeScript bindings**

Create `src/lib/bindings/export.ts`:

```typescript
import { invoke, Channel } from '@tauri-apps/api/core';

export interface ExportConfig {
  clips: Array<{
    id: string;
    startTime: number;
    endTime: number;
    label: string;
    color: string;
  }>;
  cutMode: { mode: 'lossless' } | { mode: 'precise'; format: string };
  exportScope: { scope: 'individual' } | { scope: 'merged' };
  outputDirectory: string;
  videoTitle: string;
  sourceFilePath: string;
}

type ExportEvent =
  | { event: 'progress'; data: { current: number; total: number; label: string } }
  | { event: 'finished'; data: { paths: string[] } }
  | { event: 'error'; data: { message: string } };

export async function exportClips(
  config: ExportConfig,
  onProgress: (current: number, total: number, label: string) => void,
  onFinished: (paths: string[]) => void,
  onError: (message: string) => void
): Promise<void> {
  const onEvent = new Channel<ExportEvent>();
  onEvent.onmessage = (message) => {
    switch (message.event) {
      case 'progress':
        onProgress(message.data.current, message.data.total, message.data.label);
        break;
      case 'finished':
        onFinished(message.data.paths);
        break;
      case 'error':
        onError(message.data.message);
        break;
      default: {
        const _exhaustive: never = message;
        throw new Error(`Unhandled export event: ${(_exhaustive as ExportEvent).event}`);
      }
    }
  };
  await invoke('export_clips', { config, onEvent });
}
```

- [ ] **Step 5: Implement ExportDialog component**

Create `src/lib/components/ExportDialog.svelte`:

```svelte
<script lang="ts">
  import { open } from '@tauri-apps/plugin-dialog';
  import { exportClips, type ExportConfig } from '$lib/bindings/export';
  import {
    localFilePath,
    downloadProgress,
    title,
  } from '$lib/stores/videoSession.svelte';
  import {
    getClips,
    getSelectedClipId,
  } from '$lib/stores/clips.svelte';
  import { outputDirectory, setOutputDirectory } from '$lib/stores/preferences.svelte';

  let { onClose }: { onClose: () => void } = $props();

  let clipScope = $state<'selected' | 'all'>('all');
  let exportScope = $state<'individual' | 'merged'>('individual');
  let cutMode = $state<'lossless' | 'precise'>('lossless');
  let preciseFormat = $state('mp4');
  let isExporting = $state(false);
  let exportProgress = $state('');
  let exportError = $state<string | null>(null);
  let exportedPaths = $state<string[]>([]);

  let clips = $derived(getClips());
  let selectedId = $derived(getSelectedClipId());
  let isDownloadComplete = $derived(downloadProgress >= 1 && localFilePath !== null);
  let downloadPercent = $derived(Math.round(downloadProgress * 100));

  let clipsToExport = $derived(
    clipScope === 'selected' && selectedId
      ? clips.filter((c) => c.id === selectedId)
      : clips
  );

  async function pickOutputDir() {
    const selected = await open({
      directory: true,
      defaultPath: outputDirectory,
      title: 'Choose export directory',
    });
    if (selected) {
      await setOutputDirectory(selected as string);
    }
  }

  async function handleExport() {
    if (!localFilePath || clipsToExport.length === 0) return;

    isExporting = true;
    exportError = null;
    exportedPaths = [];

    const config: ExportConfig = {
      clips: clipsToExport.map((c) => ({
        id: c.id,
        startTime: c.startTime,
        endTime: c.endTime,
        label: c.label,
        color: c.color,
      })),
      cutMode:
        cutMode === 'lossless'
          ? { mode: 'lossless' }
          : { mode: 'precise', format: preciseFormat },
      exportScope:
        exportScope === 'individual'
          ? { scope: 'individual' }
          : { scope: 'merged' },
      outputDirectory,
      videoTitle: title,
      sourceFilePath: localFilePath,
    };

    await exportClips(
      config,
      (current, total, label) => {
        exportProgress = `Exporting ${current}/${total}: ${label}`;
      },
      (paths) => {
        exportedPaths = paths;
        isExporting = false;
      },
      (message) => {
        exportError = message;
        isExporting = false;
      }
    );
  }
</script>

<div class="overlay" role="presentation" onclick={onClose}>
  <div class="dialog" role="dialog" onclick={(e) => e.stopPropagation()}>
    <h2>Export Clips</h2>

    {#if !isDownloadComplete}
      <div class="waiting">
        <p>Download at {downloadPercent}% — export will start when ready.</p>
        <div class="progress-bar">
          <div class="progress-fill" style="width: {downloadPercent}%"></div>
        </div>
      </div>
    {:else if exportedPaths.length > 0}
      <div class="success">
        <h3>✓ Export complete</h3>
        {#each exportedPaths as path}
          <code class="path">{path}</code>
        {/each}
        <button class="primary" onclick={onClose}>Done</button>
      </div>
    {:else}
      <section>
        <h3>Clips to export</h3>
        <label>
          <input type="radio" bind:group={clipScope} value="all" />
          All clips ({clips.length})
        </label>
        {#if selectedId}
          <label>
            <input type="radio" bind:group={clipScope} value="selected" />
            Selected clip only
          </label>
        {/if}
      </section>

      <section>
        <h3>Output mode</h3>
        <label>
          <input type="radio" bind:group={exportScope} value="individual" />
          Individual files
        </label>
        <label>
          <input type="radio" bind:group={exportScope} value="merged" />
          Merged into one video
        </label>
      </section>

      <section>
        <h3>Cut mode</h3>
        <label>
          <input type="radio" bind:group={cutMode} value="lossless" />
          Lossless (fast, keyframe-aligned)
        </label>
        <label>
          <input type="radio" bind:group={cutMode} value="precise" />
          Precise (re-encode, exact frames)
        </label>
        {#if cutMode === 'precise'}
          <div class="format-select">
            <label>
              Format:
              <select bind:value={preciseFormat}>
                <option value="mp4">MP4 (H.264)</option>
                <option value="mkv">MKV</option>
                <option value="webm">WebM</option>
              </select>
            </label>
          </div>
        {/if}
      </section>

      <section>
        <h3>Save to</h3>
        <div class="row">
          <code class="path">{outputDirectory}</code>
          <button onclick={pickOutputDir}>Change…</button>
        </div>
      </section>

      {#if exportError}
        <div class="error">{exportError}</div>
      {/if}

      {#if isExporting}
        <div class="exporting">{exportProgress}</div>
      {/if}

      <div class="actions">
        <button onclick={onClose}>Cancel</button>
        <button
          class="primary"
          onclick={handleExport}
          disabled={isExporting || clipsToExport.length === 0}
        >
          Export
        </button>
      </div>
    {/if}
  </div>
</div>

<style>
  .overlay {
    position: fixed;
    inset: 0;
    background: rgba(0, 0, 0, 0.6);
    display: flex;
    align-items: center;
    justify-content: center;
    z-index: 900;
  }

  .dialog {
    background: var(--bg-secondary);
    border: 1px solid var(--border);
    border-radius: 12px;
    padding: 24px 32px;
    max-width: 480px;
    width: 100%;
  }

  h2 { margin-bottom: 16px; }
  h3 { font-size: 13px; color: var(--text-secondary); margin-bottom: 8px; }

  section { margin-bottom: 16px; }

  label {
    display: flex;
    align-items: center;
    gap: 8px;
    font-size: 14px;
    cursor: pointer;
    margin-bottom: 4px;
  }

  .row { display: flex; align-items: center; gap: 12px; }

  .path {
    background: var(--bg-primary);
    padding: 4px 8px;
    border-radius: 4px;
    font-size: 13px;
    flex: 1;
    overflow: hidden;
    text-overflow: ellipsis;
    white-space: nowrap;
  }

  .format-select {
    margin-top: 4px;
    margin-left: 24px;
  }

  select {
    background: var(--bg-tertiary);
    color: var(--text-primary);
    border: 1px solid var(--border);
    border-radius: 4px;
    padding: 4px 8px;
  }

  .actions { display: flex; justify-content: flex-end; gap: 12px; margin-top: 16px; }
  .primary { background: var(--accent); color: var(--bg-primary); font-weight: 600; }
  .error { color: var(--danger); font-size: 13px; margin-bottom: 8px; }
  .exporting { color: var(--accent); font-size: 13px; margin-bottom: 8px; }

  .waiting p { color: var(--text-secondary); margin-bottom: 8px; }
  .progress-bar { height: 4px; background: var(--bg-primary); border-radius: 2px; overflow: hidden; }
  .progress-fill { height: 100%; background: var(--accent); transition: width 0.3s; }

  .success h3 { color: var(--success); margin-bottom: 12px; }
  .success .path { display: block; margin-bottom: 8px; }
  .success .primary { margin-top: 12px; }
</style>
```

- [ ] **Step 6: Wire ExportDialog into App.svelte**

Add to `src/App.svelte`:

```svelte
<script lang="ts">
  import ExportDialog from '$lib/components/ExportDialog.svelte';
  // ... existing imports ...
</script>

<!-- Add alongside other modals: -->
{#if showExportDialog}
  <ExportDialog onClose={() => (showExportDialog = false)} />
{/if}
```

Also add export buttons to the ClipList component — update `src/lib/components/ClipList.svelte` bottom section:

```svelte
{#if clips.length > 0}
  <div class="export-buttons">
    <button onclick={() => { /* emit export event */ }}>Export All</button>
  </div>
{/if}
```

(The Cmd+E shortcut was already wired in Task 8.)

- [ ] **Step 7: Verify full export pipeline**

```bash
cargo tauri dev
```

Load a video, wait for download, mark some clips, press Cmd+E. Expected: Export dialog opens. Choose lossless/individual, click Export. Files appear in the output directory. Test merged export and precise export as well.

- [ ] **Step 8: Commit**

```bash
git add -A
git commit -m "feat: add clip export with lossless/precise modes and export dialog"
```

---

## Self-Review

### Spec Coverage Check

| Spec Section | Task |
|---|---|
| Core User Flow (paste → resolve → stream → download → clip → export) | Tasks 4, 5, 7, 12 |
| DependencyManager | Task 2 |
| VideoResolver | Task 4 |
| DownloadManager | Task 5 |
| KeyframeIndex | Task 9 |
| ClipExporter | Task 12 |
| WaveformGenerator | Task 10 |
| ThumbnailExtractor | Task 11 |
| PreferencesStore | Task 3 |
| UrlInput | Task 4 |
| VideoPlayer | Task 4 |
| Timeline (4-layer canvas) | Tasks 6, 7, 10, 11 |
| TransportControls | Task 8 |
| ClipList | Task 7 |
| ExportDialog | Task 12 |
| StatusBar | Task 5 |
| SetupWizard | Task 2 |
| Cookie/Auth | Task 3 (preferences), Task 4 (yt-dlp integration) |
| Keyboard shortcuts | Task 8 |
| Frame stepping | Task 8, 9 |
| Keyframe jumping | Task 9 |
| Waveform visualization | Task 10 |
| Thumbnail strip (adaptive) | Task 11 |
| Export: lossless/precise/merged/individual | Task 12 |
| Filename collision avoidance | Task 12 |
| Output directory persistence | Task 3 |
| Edge: stream URL expiry | Not explicitly in a task — add a note |
| Edge: download not complete on export | Task 12 (dialog handles it) |
| Edge: waveform/thumb generation fails | Tasks 10, 11 (Promise.allSettled + console.error) |

**Gap found:** Stream URL re-resolution on playback error is not covered. This is an edge case that should be handled in the VideoPlayer component. Adding a note:

> **Note for implementer (Task 4):** In VideoPlayer.svelte, add an `onerror` handler on the `<video>` element that detects playback failure (e.g., 403 from expired stream URL), calls `resolveUrl` again to get a fresh stream URL, and resumes playback at the same `currentTime`. This handles the "stream URL expires during preview" edge case from the spec.

### Placeholder Scan

- No TBDs or TODOs found.
- All code steps include actual code.
- All test steps include actual test code with assertions.
- All commands include expected output descriptions.

### Type Consistency Check

- `VideoMetadata` — consistent across Rust (`models.rs`) and TypeScript (`video.ts`)
- `Clip` — Rust uses `start_time`/`end_time`, serde converts to `startTime`/`endTime` for TS ✓
- `CookieSource` — consistent between Rust (tagged enum) and TypeScript (discriminated union) ✓
- `ThumbnailSpritesheet` — consistent across Rust and TypeScript ✓
- `TimelineState` — used consistently in renderer, interactions, and component ✓
- `ExportConfig` — Rust and TypeScript both use same structure with serde rename ✓
- `DependencyStatus` — consistent ✓