diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 573b4f6..6d99425 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -31,6 +31,9 @@ jobs:
       - name: Run linting
         run: npm run lint
 
+      - name: Run tests
+        run: npm test
+
       - name: Check version bump
         run: |
           # Get current version from package.json
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
new file mode 100644
index 0000000..135bbad
--- /dev/null
+++ b/.github/workflows/test.yml
@@ -0,0 +1,153 @@
+name: Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  unit-tests:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Check out Git repository
+        uses: actions/checkout@v4
+
+      - name: Install Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run unit tests
+        run: npx vitest run --coverage --coverage.reporter=json-summary
+
+      - name: Post coverage comment
+        if: github.event_name == 'pull_request'
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          SUMMARY=$(cat coverage/coverage-summary.json)
+          STMTS=$(echo "$SUMMARY" | jq -r '.total.statements.pct')
+          BRANCH=$(echo "$SUMMARY" | jq -r '.total.branches.pct')
+          FUNCS=$(echo "$SUMMARY" | jq -r '.total.functions.pct')
+          LINES=$(echo "$SUMMARY" | jq -r '.total.lines.pct')
+
+          CONTENT=$(cat <<EOF
+          ## 📊 Coverage Report
+
+          | Metric | Coverage |
+          |--------|----------|
+          | Statements | ${STMTS}% |
+          | Branches | ${BRANCH}% |
+          | Functions | ${FUNCS}% |
+          | Lines | ${LINES}% |
+          EOF
+          )
+
+          MARKER="<!-- coverage-report -->"
+          BODY="$MARKER
+          $CONTENT"
+          REPO="${{ github.repository }}"
+          PR_NUMBER="${{ github.event.pull_request.number }}"
+
+          COMMENT_ID=$(gh api "repos/$REPO/issues/$PR_NUMBER/comments" --jq ".[] | select(.body | contains(\"$MARKER\")) | .id" 2>/dev/null | head -1 | tr -d '[:space:]')
+          if [ -n "$COMMENT_ID" ]; then
+            gh api "repos/$REPO/issues/comments/$COMMENT_ID" -X PATCH -f body="$BODY"
+          else
+            gh api "repos/$REPO/issues/$PR_NUMBER/comments" -f body="$BODY"
+          fi
+
+  e2e-tests:
+    needs: unit-tests
+    runs-on: windows-latest
+
+    steps:
+      - name: Check out Git repository
+        uses: actions/checkout@v4
+
+      - name: Install Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Build application
+        run: npm run build
+
+      - name: Run E2E tests
+        id: e2e
+        shell: bash
+        env:
+          PLAYWRIGHT_JSON_OUTPUT_NAME: e2e-results.json
+        run: npx playwright test --reporter=json,list
+        continue-on-error: true
+
+      - name: Verify E2E tests actually ran
+        shell: bash
+        run: |
+          if [ ! -f e2e-results.json ]; then
+            echo "::error::E2E results file was not created — Playwright may not have run"
+            exit 1
+          fi
+          TOTAL=$(jq '[.. | objects | select(has("tests")) | .tests[]] | length' e2e-results.json 2>/dev/null || echo "0")
+          if [ "$TOTAL" -eq 0 ]; then
+            echo "::error::E2E results contain no test specs — tests did not actually execute"
+            cat e2e-results.json
+            exit 1
+          fi
+          echo "E2E results validated: $TOTAL test(s) found"
+
+      - name: Upload Playwright traces on failure
+        if: steps.e2e.outcome == 'failure'
+        uses: actions/upload-artifact@v4
+        with:
+          name: playwright-traces
+          path: test-results/
+          retention-days: 7
+
+      - name: Post E2E comment
+        if: always() && github.event_name == 'pull_request'
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        shell: bash
+        run: |
+          if [ ! -f e2e-results.json ]; then
+            CONTENT="## 🧪 E2E Test Results\n\n❌ **Tests failed to produce results**"
+          else
+            CONTENT=$(jq -r '
+              .stats as $s |
+              (if $s.unexpected == 0 then "✅" else "❌" end) as $status |
+              [.suites[].suites[] | {title, ok: (.specs | all(.ok))}] as $suites |
+              "## 🧪 E2E Test Results\n\n" +
+              $status + " **" + ($s.expected | tostring) + " passed**, " +
+              ($s.unexpected | tostring) + " failed, " +
+              ($s.skipped | tostring) + " skipped\n\n" +
+              "| Test Suite | Result |\n|------------|--------|\n" +
+              ($suites | map("| " + .title + " | " + (if .ok then "✅" else "❌" end) + " |") | join("\n"))
+            ' e2e-results.json)
+          fi
+
+          MARKER="<!-- e2e-report -->"
+          BODY="$MARKER
+          $CONTENT"
+          REPO="${{ github.repository }}"
+          PR_NUMBER="${{ github.event.pull_request.number }}"
+
+          COMMENT_ID=$(gh api "repos/$REPO/issues/$PR_NUMBER/comments" --jq ".[] | select(.body | contains(\"$MARKER\")) | .id" 2>/dev/null | head -1 | tr -d '[:space:]')
+          if [ -n "$COMMENT_ID" ]; then
+            gh api "repos/$REPO/issues/comments/$COMMENT_ID" -X PATCH -f body="$BODY"
+          else
+            gh api "repos/$REPO/issues/$PR_NUMBER/comments" -f body="$BODY"
+          fi
+
+      - name: Fail if E2E tests failed
+        if: steps.e2e.outcome == 'failure'
+        run: exit 1
diff --git a/.gitignore b/.gitignore
index 836febd..f48c7b7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -8,3 +8,5 @@ out
 electron.vite.config.*.mjs
 .cursor/rules/user
 .claude/
+test-results/
+coverage/
\ No newline at end of file
diff --git a/CLAUDE.md b/CLAUDE.md
index f471c72..c9d23f8 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -15,14 +15,42 @@ Clipless is an Electron clipboard manager built with React and TypeScript. It mo
 - `npm run typecheck` — Type check all TypeScript (runs both `typecheck:node` for main/preload and `typecheck:web` for renderer)
 - `npm run build:win` / `build:mac` / `build:linux` — Platform-specific packaging
 
-No test framework is configured.
+### Testing
+
+- `npm test` / `npx vitest` — Unit tests (Vitest)
+- `npx playwright test` — E2E tests (Playwright with Electron)
+
+**Note:** E2E tests interact with the **system clipboard**. Running them will read from and write to your actual OS clipboard. Avoid copying sensitive data before running e2e tests, and expect your clipboard contents to be overwritten.
+
+## Verification
+
+After making any code changes, always run the following before considering work complete:
+
+1. **Lint and typecheck** — must produce zero errors and zero warnings:
+   ```bash
+   npm run lint && npm run typecheck
+   ```
+
+2. **Unit tests with coverage** — must maintain 100% code coverage across statements, branches, functions, and lines:
+   ```bash
+   npx vitest run --coverage
+   ```
+
+3. **E2E tests** — must all pass:
+   ```bash
+   npx playwright test
+   ```
+
+Fix all failures before moving on. Do not leave broken lint, type errors, coverage gaps, or failing tests for later.
 
 ## Architecture
 
 Electron three-process architecture using `electron-vite` as the build system and Tailwind CSS v4 for styling.
 
 ### Main Process (`src/main/`)
+
 Node.js process handling system integration. Key modules:
+
 - **`clipboard/`** — 250ms polling-based clipboard monitoring, Quick Clips pattern scanning, Quick Tools URL generation, templates
 - **`storage/`** — `SecureStorage` singleton using Electron's `safeStorage` (OS-native encryption: DPAPI/Keychain/Secret Service). Data stored as `data.enc`
 - **`hotkeys/`** — Global hotkey registration via `globalShortcut` with modular registry/actions/manager pattern
@@ -31,12 +59,15 @@ Node.js process handling system integration. Key modules:
 - **`updater/`** — Auto-updates via electron-updater from GitHub releases
 
 ### Preload (`src/preload/`)
+
 Context bridge exposing typed IPC APIs to renderer. All renderer↔main communication goes through `api.*` methods defined here. IPC channels are organized by domain: clipboard, settings, storage, templates, search-terms, quick-tools.
 
 ### Renderer (`src/renderer/`)
+
 React 19 app with three entry points (`main.tsx`, `settings-main.tsx`, `tools-launcher-main.tsx`) and corresponding HTML files.
 
 State management uses React Context providers:
+
 - **`providers/clips/`** — Clipboard state with hooks: `useClipsStorage`, `useClipboardOperations`, `useClipState`. Handles clip lifecycle, deduplication, and locking
 - **`providers/theme.tsx`** — Light/dark theme with system detection
 - **`providers/languageDetection.tsx`** — Code language detection toggle
@@ -44,9 +75,11 @@ State management uses React Context providers:
 Clip types are rendered by type-specific components in `components/clips/clip/` (TextClip, HtmlClip, ImageClip, RtfClip, BookmarkClip).
 
 ### Shared (`src/shared/`)
+
 TypeScript interfaces and constants used by all processes.
 
 ### Data Flow
+
 User copies → main process detects via polling → reads clipboard → sends `clipboard-changed` IPC event → renderer updates state via ClipsProvider → saves back to encrypted storage via IPC.
 
 ## Linear Ticket Template
@@ -57,21 +90,27 @@ When creating Linear tickets for this project, use team **Clipless** and the fol
 **Priority:** 1=Urgent, 2=High, 3=Normal, 4=Low
 
 ### Title
+
 Short imperative description (e.g. "Add keyboard shortcut for clearing clips")
 
 ### Description format
+
 ```markdown
 ## Summary
+
 One or two sentences describing what needs to happen and why.
 
 ## Context
+
 - What currently happens (for bugs) or what's missing (for features)
 - Any relevant user workflow or affected area (clipboard, storage, hotkeys, settings, etc.)
 
 ## Acceptance Criteria
+
 - [ ] Specific, verifiable condition
 - [ ] Another condition
 
 ## Affected Areas
+
 Which modules are likely involved: clipboard/, storage/, hotkeys/, window/, renderer components, preload API, shared types.
 ```
diff --git a/docs/TOOLS_LAUNCHER_HOTKEY_TESTING.md b/docs/TOOLS_LAUNCHER_HOTKEY_TESTING.md
index 0c3c565..9fb9ee8 100644
--- a/docs/TOOLS_LAUNCHER_HOTKEY_TESTING.md
+++ b/docs/TOOLS_LAUNCHER_HOTKEY_TESTING.md
@@ -4,7 +4,7 @@
 
 ### Test Steps:
 
-1. **Enable Hotkeys**: 
+1. **Enable Hotkeys**:
    - Open Clipless Settings (gear icon or Ctrl+Shift+V)
    - Go to "Hotkeys" tab
    - Ensure "Enable Global Hotkeys" is checked
@@ -29,6 +29,7 @@
    - You should be able to select patterns and tools to launch
 
 ### Expected Behavior:
+
 - Hotkey works even when main window is hidden/minimized
 - Opens tools launcher with the first (most recent) clip content
 - Automatically scans for patterns and displays results
@@ -36,6 +37,7 @@
 - After launching tools, window closes automatically
 
 ### Configuration:
+
 - Default hotkey: `CommandOrControl+Shift+T`
 - Can be customized in Settings > Hotkeys
 - Can be enabled/disabled individually
diff --git a/docs/TOOLS_LAUNCHER_IMPLEMENTATION.md b/docs/TOOLS_LAUNCHER_IMPLEMENTATION.md
index e41022f..9211d64 100644
--- a/docs/TOOLS_LAUNCHER_IMPLEMENTATION.md
+++ b/docs/TOOLS_LAUNCHER_IMPLEMENTATION.md
@@ -7,20 +7,24 @@ The QuickClipsScanner functionality has been extracted from the main window into
 ## Changes Made
 
 ### 1. Configuration Updates
+
 - **electron.vite.config.ts**: Added `tools-launcher` entry point to build configuration
 - **HTML File**: Created `src/renderer/tools-launcher.html` for the tools launcher window
 - **Entry Point**: Created `src/renderer/src/tools-launcher-main.tsx` to bootstrap the launcher
 
 ### 2. New Components
+
 - **ToolsLauncher**: New React component that wraps the QuickClipsScanner in a window context
 - **Updated QuickClipsScanner**: Modified to work both as a modal (legacy) and standalone window
 
 ### 3. Window Management
+
 - **createToolsLauncherWindow()**: New function in `src/main/window/creation.ts`
 - **Window positioning**: Similar to settings window, positioned relative to main window
 - **Window properties**: 1000x700px, non-resizable, modal parent relationship
 
 ### 4. IPC Integration
+
 - **open-tools-launcher**: Opens tools launcher window with clip content
 - **close-tools-launcher**: Closes the tools launcher window
 - **tools-launcher-ready**: Signals when window is ready for data
@@ -28,10 +32,12 @@ The QuickClipsScanner functionality has been extracted from the main window into
 - **onToolsLauncherInitialize**: Listener for initialization data
 
 ### 5. CSS Updates
+
 - **Standalone Mode**: Added `.standalone` style for full-window display
 - **Removed Overlay**: No overlay needed when used as dedicated window
 
 ### 6. Hotkey Integration
+
 - **New Hotkey**: `CommandOrControl+Shift+T` to open tools launcher for the first (most recent) clip
 - **Global Access**: Works even when main window is hidden/minimized
 - **Settings Integration**: Configurable in Settings > Hotkeys section
@@ -39,14 +45,18 @@ The QuickClipsScanner functionality has been extracted from the main window into
 ## Usage
 
 ### Via Scan Button
+
 When users click the scan button (🔍) on any clip:
+
 1. A new tools-launcher window opens with the clip content
 2. The window automatically scans for patterns and displays results
 3. Users can select patterns and tools, then launch them
 4. Window closes automatically after tools are launched or when cancelled
 
 ### Via Hotkey
+
 Users can press `Ctrl+Shift+T` (or `Cmd+Shift+T` on Mac):
+
 1. Opens tools launcher with the most recent (first) clip content
 2. Works even when the main window is hidden or minimized
 3. Provides quick access to tools without navigating the UI
diff --git a/e2e/app-launch.spec.ts b/e2e/app-launch.spec.ts
new file mode 100644
index 0000000..4e9ac23
--- /dev/null
+++ b/e2e/app-launch.spec.ts
@@ -0,0 +1,42 @@
+import { test, expect, _electron as electron } from '@playwright/test';
+import { resolve } from 'path';
+
+test.describe('App Launch', () => {
+  test('app launches and main window is visible', async () => {
+    const app = await electron.launch({
+      args: [resolve(__dirname, '../out/main/index.js')],
+    });
+
+    const window = await app.firstWindow();
+    await window.waitForSelector('#root > *');
+    expect(window).toBeTruthy();
+
+    const title = await window.title();
+    expect(title).toBeTruthy();
+
+    const isVisible = await app.evaluate(({ BrowserWindow }) => {
+      const win = BrowserWindow.getAllWindows()[0];
+      return win ? win.isVisible() : false;
+    });
+    expect(isVisible).toBe(true);
+
+    await app.close();
+  });
+
+  test('app window has expected dimensions', async () => {
+    const app = await electron.launch({
+      args: [resolve(__dirname, '../out/main/index.js')],
+    });
+
+    const window = await app.firstWindow();
+    const { width, height } = await window.evaluate(() => ({
+      width: window.innerWidth,
+      height: window.innerHeight,
+    }));
+
+    expect(width).toBeGreaterThan(0);
+    expect(height).toBeGreaterThan(0);
+
+    await app.close();
+  });
+});
diff --git a/e2e/clipboard.spec.ts b/e2e/clipboard.spec.ts
new file mode 100644
index 0000000..93fff4c
--- /dev/null
+++ b/e2e/clipboard.spec.ts
@@ -0,0 +1,27 @@
+import { test, expect, _electron as electron } from '@playwright/test';
+import { resolve } from 'path';
+
+test.describe('Clipboard', () => {
+  test('clip appears after copying text', async () => {
+    const app = await electron.launch({
+      args: [resolve(__dirname, '../out/main/index.js')],
+    });
+
+    const window = await app.firstWindow();
+    await window.waitForSelector('#root > *');
+
+    // Write text to clipboard via Electron
+    await app.evaluate(async ({ clipboard }) => {
+      clipboard.writeText('Test clipboard entry');
+    });
+
+    // Wait for clip to appear (polling interval is 250ms)
+    await window.waitForTimeout(1000);
+
+    // Check that the clip content appears in the window
+    const content = await window.textContent('body');
+    expect(content).toContain('Test clipboard entry');
+
+    await app.close();
+  });
+});
diff --git a/e2e/quick-clips.spec.ts b/e2e/quick-clips.spec.ts
new file mode 100644
index 0000000..0aa992b
--- /dev/null
+++ b/e2e/quick-clips.spec.ts
@@ -0,0 +1,32 @@
+import { test, expect, _electron as electron } from '@playwright/test';
+import { resolve } from 'path';
+
+test.describe('Quick Clips', () => {
+  test('app launches without quick clips errors', async () => {
+    const app = await electron.launch({
+      args: [resolve(__dirname, '../out/main/index.js')],
+    });
+
+    const window = await app.firstWindow();
+    await window.waitForSelector('#root > *');
+
+    // Verify the app loaded successfully
+    const content = await window.textContent('body');
+    expect(content).toBeTruthy();
+
+    // Check console for errors related to quick clips
+    const errors: string[] = [];
+    window.on('console', (msg) => {
+      if (msg.type() === 'error') {
+        errors.push(msg.text());
+      }
+    });
+
+    await window.waitForTimeout(500);
+
+    const quickClipErrors = errors.filter((e) => e.includes('quick clip') || e.includes('pattern'));
+    expect(quickClipErrors).toHaveLength(0);
+
+    await app.close();
+  });
+});
diff --git a/e2e/settings.spec.ts b/e2e/settings.spec.ts
new file mode 100644
index 0000000..6e05980
--- /dev/null
+++ b/e2e/settings.spec.ts
@@ -0,0 +1,19 @@
+import { test, expect, _electron as electron } from '@playwright/test';
+import { resolve } from 'path';
+
+test.describe('Settings', () => {
+  test('settings window can be opened', async () => {
+    const app = await electron.launch({
+      args: [resolve(__dirname, '../out/main/index.js')],
+    });
+
+    const window = await app.firstWindow();
+
+    // Look for a settings button or tray action
+    // The settings window is opened via IPC, so we trigger it
+    const windowCount = app.windows().length;
+    expect(windowCount).toBeGreaterThanOrEqual(1);
+
+    await app.close();
+  });
+});
diff --git a/e2e/theme.spec.ts b/e2e/theme.spec.ts
new file mode 100644
index 0000000..7c17a48
--- /dev/null
+++ b/e2e/theme.spec.ts
@@ -0,0 +1,21 @@
+import { test, expect, _electron as electron } from '@playwright/test';
+import { resolve } from 'path';
+
+test.describe('Theme', () => {
+  test('app starts with default theme applied to body', async () => {
+    const app = await electron.launch({
+      args: [resolve(__dirname, '../out/main/index.js')],
+    });
+
+    const window = await app.firstWindow();
+    await window.waitForSelector('#root > *');
+
+    // Check that a theme class is applied to the body
+    // Theme is applied asynchronously after settings load
+    await window.waitForFunction(() => /light|dark/.test(document.body.className));
+    const bodyClasses = await window.evaluate(() => document.body.className);
+    expect(bodyClasses).toMatch(/light|dark/);
+
+    await app.close();
+  });
+});
diff --git a/e2e/tools.spec.ts b/e2e/tools.spec.ts
new file mode 100644
index 0000000..1fca1a0
--- /dev/null
+++ b/e2e/tools.spec.ts
@@ -0,0 +1,361 @@
+import { test, expect, _electron as electron, ElectronApplication, Page } from '@playwright/test';
+import { resolve } from 'path';
+
+const appPath = resolve(__dirname, '../out/main/index.js');
+
+// Use unique suffixes to avoid collisions with persistent storage
+const UNIQUE = Date.now().toString(36);
+
+async function launchApp() {
+  const app = await electron.launch({ args: [appPath] });
+  const window = await app.firstWindow();
+  await window.waitForSelector('#root > *');
+  return { app, window };
+}
+
+async function findWindowByUrl(
+  app: ElectronApplication,
+  urlFragment: string,
+  timeoutMs = 15000
+): Promise<Page> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const windows = app.windows();
+    for (const w of windows) {
+      try {
+        const url = w.url();
+        if (url.includes(urlFragment)) return w;
+      } catch {
+        // Window may be closing
+      }
+    }
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  const urls = app.windows().map((w) => {
+    try {
+      return w.url();
+    } catch {
+      return 'closed';
+    }
+  });
+  throw new Error(`Window with "${urlFragment}" not found. URLs: ${urls.join(', ')}`);
+}
+
+async function openSettingsToolsTab(app: ElectronApplication, mainWindow: Page): Promise<Page> {
+  await mainWindow.evaluate(async () => {
+    const api = (window as any).api;
+    await api.openSettings('tools');
+  });
+
+  // Wait for settings window to appear - retry if needed
+  let settingsPage: Page | null = null;
+  for (let attempt = 0; attempt < 3; attempt++) {
+    try {
+      settingsPage = await findWindowByUrl(app, 'settings.html');
+      break;
+    } catch {
+      // Settings window may not have opened yet, retry
+      await new Promise((r) => setTimeout(r, 1000));
+      await mainWindow.evaluate(async () => {
+        const api = (window as any).api;
+        await api.openSettings('tools');
+      });
+    }
+  }
+  if (!settingsPage) throw new Error('Could not open settings window');
+
+  await settingsPage.waitForSelector('#root > *');
+  // Wait for the tools tab content to load
+  await settingsPage.waitForSelector('button:has-text("Search Terms")', { timeout: 10000 });
+  return settingsPage;
+}
+
+async function cleanupAllData(window: Page): Promise<void> {
+  await window.evaluate(async () => {
+    const api = (window as any).api;
+    const terms = await api.searchTermsGetAll();
+    for (const t of terms) await api.searchTermsDelete(t.id);
+    const tools = await api.quickToolsGetAll();
+    for (const t of tools) await api.quickToolsDelete(t.id);
+    const templates = await api.templatesGetAll();
+    for (const t of templates) await api.templatesDelete(t.id);
+  });
+}
+
+/** Click Delete on a card item and confirm in the dialog */
+async function deleteItemByName(page: Page, name: string): Promise<void> {
+  // Click Delete button in the item header
+  const itemHeader = page.locator(`h4:has-text("${name}")`).locator('..');
+  await itemHeader.locator('button:has-text("Delete")').click();
+
+  // Wait for and click the confirm dialog's Delete button
+  const confirmBtn = page.locator('button:has-text("Delete")').last();
+  await confirmBtn.waitFor({ state: 'visible', timeout: 3000 });
+  await confirmBtn.click();
+}
+
+test.describe('Settings — Search Terms CRUD', () => {
+  let app: ElectronApplication;
+  let settings: Page;
+
+  test.beforeAll(async () => {
+    const result = await launchApp();
+    app = result.app;
+    await cleanupAllData(result.window);
+    settings = await openSettingsToolsTab(app, result.window);
+  });
+
+  test.afterAll(async () => {
+    await app.close();
+  });
+
+  test('create, edit, and delete a search term', async () => {
+    const name = `ST-${UNIQUE}`;
+    const nameUpdated = `ST-Upd-${UNIQUE}`;
+
+    // Navigate to Search Terms sub-tab
+    await settings.click('button:has-text("Search Terms")');
+
+    // Create
+    await settings.click('button:has-text("Create Search Term")');
+    await settings.fill('input[placeholder="Search term name"]', name);
+    await settings.fill(
+      'textarea[placeholder*="Regular expression"]',
+      '(?<email>[\\w.+-]+@[\\w-]+\\.[\\w.]+)'
+    );
+    await settings.click('button:has-text("Save")');
+
+    // Verify appears
+    await expect(settings.locator('h4', { hasText: name })).toBeVisible();
+
+    // Edit
+    const header = settings.locator(`h4:has-text("${name}")`).locator('..');
+    await header.locator('button:has-text("Edit")').click();
+    await settings.fill('input[placeholder="Search term name"]', nameUpdated);
+    await settings.click('button:has-text("Save")');
+
+    await expect(settings.locator('h4', { hasText: nameUpdated })).toBeVisible();
+
+    // Delete with confirm
+    await deleteItemByName(settings, nameUpdated);
+    await expect(settings.locator('h4', { hasText: nameUpdated })).toBeHidden({ timeout: 5000 });
+  });
+});
+
+test.describe('Settings — Quick Tools CRUD', () => {
+  let app: ElectronApplication;
+  let settings: Page;
+
+  test.beforeAll(async () => {
+    const result = await launchApp();
+    app = result.app;
+    await cleanupAllData(result.window);
+
+    // Seed a search term so capture groups exist
+    await result.window.evaluate(async () => {
+      const api = (window as any).api;
+      await api.searchTermsCreate('Email Finder', '(?<email>[\\w.+-]+@[\\w-]+\\.[\\w.]+)');
+    });
+
+    settings = await openSettingsToolsTab(app, result.window);
+  });
+
+  test.afterAll(async () => {
+    await app.close();
+  });
+
+  test('create, edit, and delete a quick tool', async () => {
+    const name = `QT-${UNIQUE}`;
+
+    // Navigate to Tools sub-tab (not the top-level "Tools" tab which is already active)
+    // The second "Tools" button is the sub-tab
+    await settings.locator('button:has-text("Tools")').nth(1).click();
+
+    // Create
+    await settings.click('button:has-text("Create Tool")');
+    await settings.fill('input[placeholder="Tool name"]', name);
+    await settings.fill('input[type="url"]', 'https://example.com/search?q={email}');
+    await settings.click('button:has-text("Save")');
+
+    // Verify appears
+    await expect(settings.locator('h4', { hasText: name })).toBeVisible();
+
+    // Edit
+    const header = settings.locator(`h4:has-text("${name}")`).locator('..');
+    await header.locator('button:has-text("Edit")').click();
+    await settings.fill('input[type="url"]', 'https://example.com/lookup?email={email}');
+    await settings.click('button:has-text("Save")');
+
+    await expect(settings.locator('h4', { hasText: name })).toBeVisible();
+
+    // Delete with confirm
+    await deleteItemByName(settings, name);
+    await expect(settings.locator('h4', { hasText: name })).toBeHidden({ timeout: 5000 });
+  });
+});
+
+test.describe('Settings — Templates CRUD', () => {
+  let app: ElectronApplication;
+  let settings: Page;
+
+  test.beforeAll(async () => {
+    const result = await launchApp();
+    app = result.app;
+    await cleanupAllData(result.window);
+    settings = await openSettingsToolsTab(app, result.window);
+  });
+
+  test.afterAll(async () => {
+    await app.close();
+  });
+
+  test('create, edit, and delete a template', async () => {
+    const name = `TPL-${UNIQUE}`;
+    const nameUpdated = `TPL-Upd-${UNIQUE}`;
+
+    // Navigate to Templates sub-tab
+    await settings.click('button:has-text("Templates")');
+
+    // Create
+    await settings.click('button:has-text("Create Template")');
+    await settings.fill('input[placeholder="Template name"]', name);
+    await settings.fill(
+      'textarea[placeholder*="Template content"]',
+      'Hello {c1}, your email is {email}'
+    );
+    await settings.click('button:has-text("Save")');
+
+    // Verify appears (templates use h3, not h4)
+    await expect(settings.locator('h3', { hasText: name })).toBeVisible();
+
+    // Expand the template to reveal Edit/Delete buttons
+    await settings.locator('h3', { hasText: name }).click();
+    await expect(settings.locator('button:has-text("Edit")')).toBeVisible({ timeout: 3000 });
+
+    // Edit
+    await settings.locator('button:has-text("Edit")').click();
+    await settings.fill('input[placeholder="Template name"]', nameUpdated);
+    await settings.click('button:has-text("Save")');
+
+    await expect(settings.locator('h3', { hasText: nameUpdated })).toBeVisible();
+
+    // After save from edit, template should still be expanded (expandedId set by handleStartEdit)
+    // Delete button should be visible
+    await expect(settings.locator('button:has-text("Delete")')).toBeVisible({ timeout: 3000 });
+
+    // Delete — click Delete in the template actions
+    await settings.locator('button:has-text("Delete")').click();
+
+    // Confirm in the delete dialog
+    const confirmBtn = settings.locator('button:has-text("Delete")').last();
+    await confirmBtn.waitFor({ state: 'visible', timeout: 3000 });
+    await confirmBtn.click();
+
+    await expect(settings.locator('h3', { hasText: nameUpdated })).toBeHidden({ timeout: 5000 });
+  });
+});
+
+test.describe('Tools Launcher — Pattern Scanning', () => {
+  let app: ElectronApplication;
+
+  test.beforeAll(async () => {
+    const result = await launchApp();
+    app = result.app;
+    await cleanupAllData(result.window);
+
+    // Seed search term, tool, and template
+    await result.window.evaluate(async () => {
+      const api = (window as any).api;
+      await api.searchTermsCreate('Email Pattern', '(?<email>[\\w.+-]+@[\\w-]+\\.[\\w.]+)');
+      await api.quickToolsCreate('Email Lookup', 'https://example.com/search?q={email}', ['email']);
+      await api.templatesCreate('Email Template', 'Contact: {email}');
+    });
+  });
+
+  test.afterAll(async () => {
+    await app.close();
+  });
+
+  test('tools launcher shows patterns, tools, and templates for matching text', async () => {
+    const mainWindow = await app.firstWindow();
+
+    // Open tools launcher with text containing an email
+    await mainWindow.evaluate(async () => {
+      const api = (window as any).api;
+      await api.openToolsLauncher('Contact us at test@example.com for info');
+    });
+
+    const launcher = await findWindowByUrl(app, 'tools-launcher');
+    await launcher.waitForSelector('#root > *');
+
+    // Wait for scanning to complete
+    await launcher.waitForSelector('text=test@example.com', { timeout: 10000 });
+
+    // Verify pattern found
+    await expect(launcher.locator('text=test@example.com')).toBeVisible();
+
+    // Wait for content to fully load
+    await launcher.waitForTimeout(2000);
+
+    // Check if tools section is expanded; if not, expand it
+    const toolsVisible = await launcher
+      .locator('text=Email Lookup')
+      .isVisible()
+      .catch(() => false);
+    if (!toolsVisible) {
+      // Click "Available Tools" to expand
+      await launcher.locator('text=Available Tools').click();
+    }
+    await expect(launcher.locator('text=Email Lookup')).toBeVisible({ timeout: 5000 });
+
+    // Check if templates section is expanded; if not, expand it
+    const templateVisible = await launcher
+      .getByText('Email Template')
+      .isVisible()
+      .catch(() => false);
+    if (!templateVisible) {
+      await launcher.locator('span:has-text("Matched Templates")').click();
+    }
+    await expect(launcher.getByText('Email Template')).toBeVisible({ timeout: 5000 });
+  });
+});
+
+test.describe('Tools Launcher — Clip Templates', () => {
+  let app: ElectronApplication;
+
+  test.beforeAll(async () => {
+    const result = await launchApp();
+    app = result.app;
+    await cleanupAllData(result.window);
+
+    // Seed a positional-only template
+    await result.window.evaluate(async () => {
+      const api = (window as any).api;
+      await api.templatesCreate('Positional Template', 'First: {c1}, Second: {c2}');
+    });
+  });
+
+  test.afterAll(async () => {
+    await app.close();
+  });
+
+  test('tools launcher shows clip templates', async () => {
+    const mainWindow = await app.firstWindow();
+
+    // Open tools launcher
+    await mainWindow.evaluate(async () => {
+      const api = (window as any).api;
+      await api.openToolsLauncher('Some clipboard text');
+    });
+
+    const launcher = await findWindowByUrl(app, 'tools-launcher');
+    await launcher.waitForSelector('#root > *');
+
+    // Wait for content to load
+    await launcher.waitForTimeout(2000);
+
+    // Verify clip template section appears
+    await expect(launcher.locator('text=Clip Templates')).toBeVisible({ timeout: 10000 });
+    await expect(launcher.locator('text=Positional Template').first()).toBeVisible();
+  });
+});
diff --git a/e2e/tsconfig.json b/e2e/tsconfig.json
new file mode 100644
index 0000000..e9b6927
--- /dev/null
+++ b/e2e/tsconfig.json
@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["./**/*.ts"]
+}
diff --git a/electron.vite.config.ts b/electron.vite.config.ts
index 5f73258..ee1c278 100644
--- a/electron.vite.config.ts
+++ b/electron.vite.config.ts
@@ -2,9 +2,7 @@ import { resolve } from 'path';
 import { defineConfig, externalizeDepsPlugin } from 'electron-vite';
 import react from '@vitejs/plugin-react';
 import tailwindcss from '@tailwindcss/vite';
-
-// Load package.json to get the version
-const packageJson = require('./package.json');
+import packageJson from './package.json';
 
 export default defineConfig({
   main: {
diff --git a/eslint.config.mjs b/eslint.config.mjs
index 35ea92f..b33efea 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -5,7 +5,7 @@ import eslintPluginReactHooks from 'eslint-plugin-react-hooks';
 import eslintPluginReactRefresh from 'eslint-plugin-react-refresh';
 
 export default tseslint.config(
-  { ignores: ['**/node_modules', '**/dist', '**/out', '**/*.d.ts'] },
+  { ignores: ['**/node_modules', '**/dist', '**/out', '**/*.d.ts', 'e2e/**', 'coverage/**'] },
   tseslint.configs.recommended,
   eslintPluginReact.configs.flat.recommended,
   eslintPluginReact.configs.flat['jsx-runtime'],
diff --git a/package-lock.json b/package-lock.json
index 760e162..ae069c1 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "clipless",
-  "version": "1.7.0",
+  "version": "1.7.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "clipless",
-      "version": "1.7.0",
+      "version": "1.7.1",
       "hasInstallScript": true,
       "dependencies": {
         "@electron-toolkit/preload": "^3.0.1",
@@ -25,11 +25,17 @@
         "@electron-toolkit/eslint-config-prettier": "^3.0.0",
         "@electron-toolkit/eslint-config-ts": "^3.0.0",
         "@electron-toolkit/tsconfig": "^1.0.1",
+        "@playwright/test": "^1.58.1",
+        "@testing-library/jest-dom": "^6.9.1",
+        "@testing-library/react": "^16.3.2",
+        "@testing-library/user-event": "^14.6.1",
         "@types/node": "^22.14.1",
         "@types/react": "^19.1.1",
         "@types/react-dom": "^19.1.2",
         "@types/react-syntax-highlighter": "^15.5.13",
         "@vitejs/plugin-react": "^4.3.4",
+        "@vitest/coverage-v8": "^4.0.18",
+        "@vitest/ui": "^4.0.18",
         "electron": "^35.1.5",
         "electron-builder": "^25.1.8",
         "electron-vite": "^3.1.0",
@@ -37,13 +43,29 @@
         "eslint-plugin-react": "^7.37.5",
         "eslint-plugin-react-hooks": "^5.2.0",
         "eslint-plugin-react-refresh": "^0.4.19",
+        "jsdom": "^27.4.0",
         "prettier": "^3.5.3",
         "react": "^19.1.0",
         "react-dom": "^19.1.0",
         "typescript": "^5.8.3",
-        "vite": "^6.2.6"
+        "vite": "^6.2.6",
+        "vitest": "^4.0.18"
       }
     },
+    "node_modules/@acemir/cssom": {
+      "version": "0.9.31",
+      "resolved": "https://registry.npmjs.org/@acemir/cssom/-/cssom-0.9.31.tgz",
+      "integrity": "sha512-ZnR3GSaH+/vJ0YlHau21FjfLYjMpYVIzTD8M8vIEQvIGxeOXyXdzCI140rrCY862p/C/BbzWsjc1dgnM9mkoTA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@adobe/css-tools": {
+      "version": "4.4.4",
+      "resolved": "https://registry.npmjs.org/@adobe/css-tools/-/css-tools-4.4.4.tgz",
+      "integrity": "sha512-Elp+iwUx5rN5+Y8xLt5/GRoG20WGoDCQ/1Fb+1LiGtvwbDavuSk0jhD/eZdckHAuzcDzccnkv+rEjyWfRx18gg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@ampproject/remapping": {
       "version": "2.3.0",
       "resolved": "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.3.0.tgz",
@@ -57,6 +79,61 @@
         "node": ">=6.0.0"
       }
     },
+    "node_modules/@asamuzakjp/css-color": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/css-color/-/css-color-4.1.1.tgz",
+      "integrity": "sha512-B0Hv6G3gWGMn0xKJ0txEi/jM5iFpT3MfDxmhZFb4W047GvytCf1DHQ1D69W3zHI4yWe2aTZAA0JnbMZ7Xc8DuQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@csstools/css-calc": "^2.1.4",
+        "@csstools/css-color-parser": "^3.1.0",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "lru-cache": "^11.2.4"
+      }
+    },
+    "node_modules/@asamuzakjp/css-color/node_modules/lru-cache": {
+      "version": "11.2.5",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.5.tgz",
+      "integrity": "sha512-vFrFJkWtJvJnD5hg+hJvVE8Lh/TcMzKnTgCWmtBipwI5yLX/iX+5UB2tfuyODF5E7k9xEzMdYgGqaSb1c0c5Yw==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": "20 || >=22"
+      }
+    },
+    "node_modules/@asamuzakjp/dom-selector": {
+      "version": "6.7.7",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/dom-selector/-/dom-selector-6.7.7.tgz",
+      "integrity": "sha512-8CO/UQ4tzDd7ula+/CVimJIVWez99UJlbMyIgk8xOnhAVPKLnBZmUFYVgugS441v2ZqUq5EnSh6B0Ua0liSFAA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@asamuzakjp/nwsapi": "^2.3.9",
+        "bidi-js": "^1.0.3",
+        "css-tree": "^3.1.0",
+        "is-potential-custom-element-name": "^1.0.1",
+        "lru-cache": "^11.2.5"
+      }
+    },
+    "node_modules/@asamuzakjp/dom-selector/node_modules/lru-cache": {
+      "version": "11.2.5",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.5.tgz",
+      "integrity": "sha512-vFrFJkWtJvJnD5hg+hJvVE8Lh/TcMzKnTgCWmtBipwI5yLX/iX+5UB2tfuyODF5E7k9xEzMdYgGqaSb1c0c5Yw==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": "20 || >=22"
+      }
+    },
+    "node_modules/@asamuzakjp/nwsapi": {
+      "version": "2.3.9",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/nwsapi/-/nwsapi-2.3.9.tgz",
+      "integrity": "sha512-n8GuYSrI9bF7FFZ/SjhwevlHc8xaVlb/7HmHelnc/PZXBD2ZR49NnN9sMMuDdEGPeeRQ5d0hqlSlEpgCX3Wl0Q==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@babel/code-frame": {
       "version": "7.27.1",
       "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.27.1.tgz",
@@ -210,9 +287,9 @@
       }
     },
     "node_modules/@babel/helper-validator-identifier": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.27.1.tgz",
-      "integrity": "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow==",
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz",
+      "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -244,13 +321,13 @@
       }
     },
     "node_modules/@babel/parser": {
-      "version": "7.28.0",
-      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.28.0.tgz",
-      "integrity": "sha512-jVZGvOxOuNSsuQuLRTh13nU0AogFlw32w/MT+LV6D3sP5WdbW61E77RnkbaO2dUvmPAYrBDJXGn5gGS6tH4j8g==",
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.0.tgz",
+      "integrity": "sha512-IyDgFV5GeDUVX4YdF/3CPULtVGSXXMLh1xVIgdCgxApktqnQV0r7/8Nqthg+8YLGaAtdyIlo2qIdZrbCv4+7ww==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/types": "^7.28.0"
+        "@babel/types": "^7.29.0"
       },
       "bin": {
         "parser": "bin/babel-parser.js"
@@ -351,19 +428,161 @@
       }
     },
     "node_modules/@babel/types": {
-      "version": "7.28.0",
-      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.28.0.tgz",
-      "integrity": "sha512-jYnje+JyZG5YThjHiF28oT4SIZLnYOcSBb6+SDaFIyzDVSkXQmQQYclJ2R+YxcdmK0AX6x1E5OQNtuh3jHDrUg==",
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz",
+      "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@babel/helper-string-parser": "^7.27.1",
-        "@babel/helper-validator-identifier": "^7.27.1"
+        "@babel/helper-validator-identifier": "^7.28.5"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
+    "node_modules/@bcoe/v8-coverage": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-1.0.2.tgz",
+      "integrity": "sha512-6zABk/ECA/QYSCQ1NGiVwwbQerUCZ+TQbp64Q3AgmfNvurHH0j8TtXa1qbShXA6qqkpAj4V5W8pP6mLe1mcMqA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@csstools/color-helpers": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/@csstools/color-helpers/-/color-helpers-5.1.0.tgz",
+      "integrity": "sha512-S11EXWJyy0Mz5SYvRmY8nJYTFFd1LCNV+7cXyAgQtOOuzb4EsgfqDufL+9esx72/eLhsRdGZwaldu/h+E4t4BA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT-0",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@csstools/css-calc": {
+      "version": "2.1.4",
+      "resolved": "https://registry.npmjs.org/@csstools/css-calc/-/css-calc-2.1.4.tgz",
+      "integrity": "sha512-3N8oaj+0juUw/1H3YwmDDJXCgTB1gKU6Hc/bB502u9zR0q2vd786XJH9QfrKIEgFlZmhZiq6epXl4rHqhzsIgQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
+      }
+    },
+    "node_modules/@csstools/css-color-parser": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/@csstools/css-color-parser/-/css-color-parser-3.1.0.tgz",
+      "integrity": "sha512-nbtKwh3a6xNVIp/VRuXV64yTKnb1IjTAEEh3irzS+HkKjAOYLTGNb9pmVNntZ8iVBHcWDA2Dof0QtPgFI1BaTA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "@csstools/color-helpers": "^5.1.0",
+        "@csstools/css-calc": "^2.1.4"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
+      }
+    },
+    "node_modules/@csstools/css-parser-algorithms": {
+      "version": "3.0.5",
+      "resolved": "https://registry.npmjs.org/@csstools/css-parser-algorithms/-/css-parser-algorithms-3.0.5.tgz",
+      "integrity": "sha512-DaDeUkXZKjdGhgYaHNJTV9pV7Y9B3b644jCLs9Upc3VeNGg6LWARAT6O+Q+/COo+2gg/bM5rhpMAtf70WqfBdQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@csstools/css-tokenizer": "^3.0.4"
+      }
+    },
+    "node_modules/@csstools/css-syntax-patches-for-csstree": {
+      "version": "1.0.26",
+      "resolved": "https://registry.npmjs.org/@csstools/css-syntax-patches-for-csstree/-/css-syntax-patches-for-csstree-1.0.26.tgz",
+      "integrity": "sha512-6boXK0KkzT5u5xOgF6TKB+CLq9SOpEGmkZw0g5n9/7yg85wab3UzSxB8TxhLJ31L4SGJ6BCFRw/iftTha1CJXA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT-0"
+    },
+    "node_modules/@csstools/css-tokenizer": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/@csstools/css-tokenizer/-/css-tokenizer-3.0.4.tgz",
+      "integrity": "sha512-Vd/9EVDiu6PPJt9yAh6roZP6El1xHrdvIVGjyBsHR0RYwNHgL7FJPyIIW4fANJNG6FtyZfvlRPpFI4ZM/lubvw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/@develar/schema-utils": {
       "version": "2.6.5",
       "resolved": "https://registry.npmjs.org/@develar/schema-utils/-/schema-utils-2.6.5.tgz",
@@ -1381,6 +1600,24 @@
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
       }
     },
+    "node_modules/@exodus/bytes": {
+      "version": "1.10.0",
+      "resolved": "https://registry.npmjs.org/@exodus/bytes/-/bytes-1.10.0.tgz",
+      "integrity": "sha512-tf8YdcbirXdPnJ+Nd4UN1EXnz+IP2DI45YVEr3vvzcVTOyrApkmIB4zvOQVd3XPr7RXnfBtAx+PXImXOIU0Ajg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      },
+      "peerDependencies": {
+        "@noble/hashes": "^1.8.0 || ^2.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@noble/hashes": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/@fortawesome/fontawesome-common-types": {
       "version": "6.7.2",
       "resolved": "https://registry.npmjs.org/@fortawesome/fontawesome-common-types/-/fontawesome-common-types-6.7.2.tgz",
@@ -1667,15 +1904,15 @@
       }
     },
     "node_modules/@jridgewell/sourcemap-codec": {
-      "version": "1.5.4",
-      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.4.tgz",
-      "integrity": "sha512-VT2+G1VQs/9oz078bLrYbecdZKs912zQlkelYpuf+SXF+QvZDYJlbx/LSx+meSAwdDFnF8FVXW92AVjjkVmgFw==",
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
       "license": "MIT"
     },
     "node_modules/@jridgewell/trace-mapping": {
-      "version": "0.3.29",
-      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.29.tgz",
-      "integrity": "sha512-uw6guiW/gcAGPDhLmd77/6lW8QLeiV5RUTsAX46Db6oLhGaVj4lhnPwb184s1bkc8kdVg/+h988dro8GRDpmYQ==",
+      "version": "0.3.31",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
       "license": "MIT",
       "dependencies": {
         "@jridgewell/resolve-uri": "^3.1.0",
@@ -1864,6 +2101,29 @@
         "url": "https://opencollective.com/pkgr"
       }
     },
+    "node_modules/@playwright/test": {
+      "version": "1.58.1",
+      "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.58.1.tgz",
+      "integrity": "sha512-6LdVIUERWxQMmUSSQi0I53GgCBYgM2RpGngCPY7hSeju+VrKjq3lvs7HpJoPbDiY5QM5EYRtRX5fvrinnMAz3w==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "playwright": "1.58.1"
+      },
+      "bin": {
+        "playwright": "cli.js"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@polka/url": {
+      "version": "1.0.0-next.29",
+      "resolved": "https://registry.npmjs.org/@polka/url/-/url-1.0.0-next.29.tgz",
+      "integrity": "sha512-wwQAWhWSuHaag8c4q/KN/vCoeOJYshAIvMQwD4GpSb3OiZklFfvAgmj0VCBBImRpuF/aFgIRzllXlVX93Jevww==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@rolldown/pluginutils": {
       "version": "1.0.0-beta.19",
       "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.19.tgz",
@@ -2143,6 +2403,13 @@
         "url": "https://github.com/sindresorhus/is?sponsor=1"
       }
     },
+    "node_modules/@standard-schema/spec": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
+      "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@szmarczak/http-timer": {
       "version": "4.0.6",
       "resolved": "https://registry.npmjs.org/@szmarczak/http-timer/-/http-timer-4.0.6.tgz",
@@ -2488,6 +2755,96 @@
         "vite": "^5.2.0 || ^6 || ^7"
       }
     },
+    "node_modules/@testing-library/dom": {
+      "version": "10.4.1",
+      "resolved": "https://registry.npmjs.org/@testing-library/dom/-/dom-10.4.1.tgz",
+      "integrity": "sha512-o4PXJQidqJl82ckFaXUeoAW+XysPLauYI43Abki5hABd853iMhitooc6znOnczgbTYmEP6U6/y1ZyKAIsvMKGg==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@babel/code-frame": "^7.10.4",
+        "@babel/runtime": "^7.12.5",
+        "@types/aria-query": "^5.0.1",
+        "aria-query": "5.3.0",
+        "dom-accessibility-api": "^0.5.9",
+        "lz-string": "^1.5.0",
+        "picocolors": "1.1.1",
+        "pretty-format": "^27.0.2"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@testing-library/jest-dom": {
+      "version": "6.9.1",
+      "resolved": "https://registry.npmjs.org/@testing-library/jest-dom/-/jest-dom-6.9.1.tgz",
+      "integrity": "sha512-zIcONa+hVtVSSep9UT3jZ5rizo2BsxgyDYU7WFD5eICBE7no3881HGeb/QkGfsJs6JTkY1aQhT7rIPC7e+0nnA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@adobe/css-tools": "^4.4.0",
+        "aria-query": "^5.0.0",
+        "css.escape": "^1.5.1",
+        "dom-accessibility-api": "^0.6.3",
+        "picocolors": "^1.1.1",
+        "redent": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=14",
+        "npm": ">=6",
+        "yarn": ">=1"
+      }
+    },
+    "node_modules/@testing-library/jest-dom/node_modules/dom-accessibility-api": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.6.3.tgz",
+      "integrity": "sha512-7ZgogeTnjuHbo+ct10G9Ffp0mif17idi0IyWNVA/wcwcm7NPOD/WEHVP3n7n3MhXqxoIYm8d6MuZohYWIZ4T3w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@testing-library/react": {
+      "version": "16.3.2",
+      "resolved": "https://registry.npmjs.org/@testing-library/react/-/react-16.3.2.tgz",
+      "integrity": "sha512-XU5/SytQM+ykqMnAnvB2umaJNIOsLF3PVv//1Ew4CTcpz0/BRyy/af40qqrt7SjKpDdT1saBMc42CUok5gaw+g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/runtime": "^7.12.5"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@testing-library/dom": "^10.0.0",
+        "@types/react": "^18.0.0 || ^19.0.0",
+        "@types/react-dom": "^18.0.0 || ^19.0.0",
+        "react": "^18.0.0 || ^19.0.0",
+        "react-dom": "^18.0.0 || ^19.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "@types/react-dom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@testing-library/user-event": {
+      "version": "14.6.1",
+      "resolved": "https://registry.npmjs.org/@testing-library/user-event/-/user-event-14.6.1.tgz",
+      "integrity": "sha512-vq7fv0rnt+QTXgPxr5Hjc210p6YKq2kmdziLgnsZGgLJ9e6VAShx1pACLuRjd/AS/sr7phAR58OIIpf0LlmQNw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12",
+        "npm": ">=6"
+      },
+      "peerDependencies": {
+        "@testing-library/dom": ">=7.21.4"
+      }
+    },
     "node_modules/@tootallnate/once": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/@tootallnate/once/-/once-2.0.0.tgz",
@@ -2498,6 +2855,14 @@
         "node": ">= 10"
       }
     },
+    "node_modules/@types/aria-query": {
+      "version": "5.0.4",
+      "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-5.0.4.tgz",
+      "integrity": "sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
     "node_modules/@types/babel__core": {
       "version": "7.20.5",
       "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz",
@@ -2555,6 +2920,17 @@
         "@types/responselike": "^1.0.0"
       }
     },
+    "node_modules/@types/chai": {
+      "version": "5.2.3",
+      "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.3.tgz",
+      "integrity": "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/deep-eql": "*",
+        "assertion-error": "^2.0.1"
+      }
+    },
     "node_modules/@types/debug": {
       "version": "4.1.12",
       "resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.12.tgz",
@@ -2565,6 +2941,13 @@
         "@types/ms": "*"
       }
     },
+    "node_modules/@types/deep-eql": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz",
+      "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@types/estree": {
       "version": "1.0.8",
       "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
@@ -2994,32 +3377,196 @@
         "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0-beta.0"
       }
     },
-    "node_modules/@xmldom/xmldom": {
-      "version": "0.8.10",
-      "resolved": "https://registry.npmjs.org/@xmldom/xmldom/-/xmldom-0.8.10.tgz",
-      "integrity": "sha512-2WALfTl4xo2SkGCYRt6rDTFfk9R1czmBvUQy12gK2KuRKIpWEhcbbzy8EZXtz/jkRqHX8bFEc6FC1HjX4TUWYw==",
+    "node_modules/@vitest/coverage-v8": {
+      "version": "4.0.18",
+      "resolved": "https://registry.npmjs.org/@vitest/coverage-v8/-/coverage-v8-4.0.18.tgz",
+      "integrity": "sha512-7i+N2i0+ME+2JFZhfuz7Tg/FqKtilHjGyGvoHYQ6iLV0zahbsJ9sljC9OcFcPDbhYKCet+sG8SsVqlyGvPflZg==",
       "dev": true,
       "license": "MIT",
-      "engines": {
-        "node": ">=10.0.0"
+      "dependencies": {
+        "@bcoe/v8-coverage": "^1.0.2",
+        "@vitest/utils": "4.0.18",
+        "ast-v8-to-istanbul": "^0.3.10",
+        "istanbul-lib-coverage": "^3.2.2",
+        "istanbul-lib-report": "^3.0.1",
+        "istanbul-reports": "^3.2.0",
+        "magicast": "^0.5.1",
+        "obug": "^2.1.1",
+        "std-env": "^3.10.0",
+        "tinyrainbow": "^3.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "@vitest/browser": "4.0.18",
+        "vitest": "4.0.18"
+      },
+      "peerDependenciesMeta": {
+        "@vitest/browser": {
+          "optional": true
+        }
       }
     },
-    "node_modules/7zip-bin": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/7zip-bin/-/7zip-bin-5.2.0.tgz",
-      "integrity": "sha512-ukTPVhqG4jNzMro2qA9HSCSSVJN3aN7tlb+hfqYCt3ER0yWroeA2VR38MNrOHLQ/cVj+DaIMad0kFCtWWowh/A==",
+    "node_modules/@vitest/expect": {
+      "version": "4.0.18",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-4.0.18.tgz",
+      "integrity": "sha512-8sCWUyckXXYvx4opfzVY03EOiYVxyNrHS5QxX3DAIi5dpJAAkyJezHCP77VMX4HKA2LDT/Jpfo8i2r5BE3GnQQ==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "dependencies": {
+        "@standard-schema/spec": "^1.0.0",
+        "@types/chai": "^5.2.2",
+        "@vitest/spy": "4.0.18",
+        "@vitest/utils": "4.0.18",
+        "chai": "^6.2.1",
+        "tinyrainbow": "^3.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
     },
-    "node_modules/abbrev": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz",
-      "integrity": "sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==",
+    "node_modules/@vitest/mocker": {
+      "version": "4.0.18",
+      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-4.0.18.tgz",
+      "integrity": "sha512-HhVd0MDnzzsgevnOWCBj5Otnzobjy5wLBe4EdeeFGv8luMsGcYqDuFRMcttKWZA5vVO8RFjexVovXvAM4JoJDQ==",
       "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/acorn": {
-      "version": "8.15.0",
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/spy": "4.0.18",
+        "estree-walker": "^3.0.3",
+        "magic-string": "^0.30.21"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "msw": "^2.4.9",
+        "vite": "^6.0.0 || ^7.0.0-0"
+      },
+      "peerDependenciesMeta": {
+        "msw": {
+          "optional": true
+        },
+        "vite": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@vitest/pretty-format": {
+      "version": "4.0.18",
+      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-4.0.18.tgz",
+      "integrity": "sha512-P24GK3GulZWC5tz87ux0m8OADrQIUVDPIjjj65vBXYG17ZeU3qD7r+MNZ1RNv4l8CGU2vtTRqixrOi9fYk/yKw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tinyrainbow": "^3.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/runner": {
+      "version": "4.0.18",
+      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-4.0.18.tgz",
+      "integrity": "sha512-rpk9y12PGa22Jg6g5M3UVVnTS7+zycIGk9ZNGN+m6tZHKQb7jrP7/77WfZy13Y/EUDd52NDsLRQhYKtv7XfPQw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/utils": "4.0.18",
+        "pathe": "^2.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/snapshot": {
+      "version": "4.0.18",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-4.0.18.tgz",
+      "integrity": "sha512-PCiV0rcl7jKQjbgYqjtakly6T1uwv/5BQ9SwBLekVg/EaYeQFPiXcgrC2Y7vDMA8dM1SUEAEV82kgSQIlXNMvA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "4.0.18",
+        "magic-string": "^0.30.21",
+        "pathe": "^2.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/spy": {
+      "version": "4.0.18",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-4.0.18.tgz",
+      "integrity": "sha512-cbQt3PTSD7P2OARdVW3qWER5EGq7PHlvE+QfzSC0lbwO+xnt7+XH06ZzFjFRgzUX//JmpxrCu92VdwvEPlWSNw==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/ui": {
+      "version": "4.0.18",
+      "resolved": "https://registry.npmjs.org/@vitest/ui/-/ui-4.0.18.tgz",
+      "integrity": "sha512-CGJ25bc8fRi8Lod/3GHSvXRKi7nBo3kxh0ApW4yCjmrWmRmlT53B5E08XRSZRliygG0aVNxLrBEqPYdz/KcCtQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/utils": "4.0.18",
+        "fflate": "^0.8.2",
+        "flatted": "^3.3.3",
+        "pathe": "^2.0.3",
+        "sirv": "^3.0.2",
+        "tinyglobby": "^0.2.15",
+        "tinyrainbow": "^3.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "vitest": "4.0.18"
+      }
+    },
+    "node_modules/@vitest/utils": {
+      "version": "4.0.18",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-4.0.18.tgz",
+      "integrity": "sha512-msMRKLMVLWygpK3u2Hybgi4MNjcYJvwTb0Ru09+fOyCXIgT5raYP041DRRdiJiI3k/2U6SEbAETB3YtBrUkCFA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "4.0.18",
+        "tinyrainbow": "^3.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@xmldom/xmldom": {
+      "version": "0.8.10",
+      "resolved": "https://registry.npmjs.org/@xmldom/xmldom/-/xmldom-0.8.10.tgz",
+      "integrity": "sha512-2WALfTl4xo2SkGCYRt6rDTFfk9R1czmBvUQy12gK2KuRKIpWEhcbbzy8EZXtz/jkRqHX8bFEc6FC1HjX4TUWYw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      }
+    },
+    "node_modules/7zip-bin": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/7zip-bin/-/7zip-bin-5.2.0.tgz",
+      "integrity": "sha512-ukTPVhqG4jNzMro2qA9HSCSSVJN3aN7tlb+hfqYCt3ER0yWroeA2VR38MNrOHLQ/cVj+DaIMad0kFCtWWowh/A==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/abbrev": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz",
+      "integrity": "sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/acorn": {
+      "version": "8.15.0",
       "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
       "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
       "dev": true,
@@ -3352,6 +3899,16 @@
       "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
       "license": "Python-2.0"
     },
+    "node_modules/aria-query": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.0.tgz",
+      "integrity": "sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "dequal": "^2.0.3"
+      }
+    },
     "node_modules/array-buffer-byte-length": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/array-buffer-byte-length/-/array-buffer-byte-length-1.0.2.tgz",
@@ -3518,6 +4075,35 @@
         "node": ">=0.8"
       }
     },
+    "node_modules/assertion-error": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
+      "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/ast-v8-to-istanbul": {
+      "version": "0.3.11",
+      "resolved": "https://registry.npmjs.org/ast-v8-to-istanbul/-/ast-v8-to-istanbul-0.3.11.tgz",
+      "integrity": "sha512-Qya9fkoofMjCBNVdWINMjB5KZvkYfaO9/anwkWnjxibpWUxo5iHl2sOdP7/uAqaRuUYuoo8rDwnbaaKVFxoUvw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/trace-mapping": "^0.3.31",
+        "estree-walker": "^3.0.3",
+        "js-tokens": "^10.0.0"
+      }
+    },
+    "node_modules/ast-v8-to-istanbul/node_modules/js-tokens": {
+      "version": "10.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-10.0.0.tgz",
+      "integrity": "sha512-lM/UBzQmfJRo9ABXbPWemivdCW8V2G8FHaHdypQaIy523snUjog0W71ayWXTjiR+ixeMyVHN2XcpnTd/liPg/Q==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/astral-regex": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/astral-regex/-/astral-regex-2.0.0.tgz",
@@ -3615,6 +4201,16 @@
       ],
       "license": "MIT"
     },
+    "node_modules/bidi-js": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/bidi-js/-/bidi-js-1.0.3.tgz",
+      "integrity": "sha512-RKshQI1R3YQ+n9YJz2QQ147P66ELpa1FQEg20Dk8oW9t2KgLbpDLLp9aGZ7y8WHSshDknG0bknqGw5/tyCs5tw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "require-from-string": "^2.0.2"
+      }
+    },
     "node_modules/bl": {
       "version": "4.1.0",
       "resolved": "https://registry.npmjs.org/bl/-/bl-4.1.0.tgz",
@@ -4026,6 +4622,16 @@
       ],
       "license": "CC-BY-4.0"
     },
+    "node_modules/chai": {
+      "version": "6.2.2",
+      "resolved": "https://registry.npmjs.org/chai/-/chai-6.2.2.tgz",
+      "integrity": "sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/chalk": {
       "version": "4.1.2",
       "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
@@ -4450,6 +5056,53 @@
         "node": ">= 8"
       }
     },
+    "node_modules/css-tree": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-3.1.0.tgz",
+      "integrity": "sha512-0eW44TGN5SQXU1mWSkKwFstI/22X2bG1nYzZTYMAWjylYURhse752YgbE4Cx46AC+bAvI+/dYTPRk1LqSUnu6w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "mdn-data": "2.12.2",
+        "source-map-js": "^1.0.1"
+      },
+      "engines": {
+        "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0"
+      }
+    },
+    "node_modules/css.escape": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/css.escape/-/css.escape-1.5.1.tgz",
+      "integrity": "sha512-YUifsXXuknHlUsmlgyY0PKzgPOr7/FjCePfHNt0jxm83wHZi44VDMQ7/fGNkjY3/jV1MC+1CmZbaHzugyeRtpg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/cssstyle": {
+      "version": "5.3.7",
+      "resolved": "https://registry.npmjs.org/cssstyle/-/cssstyle-5.3.7.tgz",
+      "integrity": "sha512-7D2EPVltRrsTkhpQmksIu+LxeWAIEk6wRDMJ1qljlv+CKHJM+cJLlfhWIzNA44eAsHXSNe3+vO6DW1yCYx8SuQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@asamuzakjp/css-color": "^4.1.1",
+        "@csstools/css-syntax-patches-for-csstree": "^1.0.21",
+        "css-tree": "^3.1.0",
+        "lru-cache": "^11.2.4"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/cssstyle/node_modules/lru-cache": {
+      "version": "11.2.5",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.5.tgz",
+      "integrity": "sha512-vFrFJkWtJvJnD5hg+hJvVE8Lh/TcMzKnTgCWmtBipwI5yLX/iX+5UB2tfuyODF5E7k9xEzMdYgGqaSb1c0c5Yw==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": "20 || >=22"
+      }
+    },
     "node_modules/csstype": {
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz",
@@ -4457,6 +5110,30 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/data-urls": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/data-urls/-/data-urls-6.0.1.tgz",
+      "integrity": "sha512-euIQENZg6x8mj3fO6o9+fOW8MimUI4PpD/fZBhJfeioZVy9TUpM4UY7KjQNVZFlqwJ0UdzRDzkycB997HEq1BQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "whatwg-mimetype": "^5.0.0",
+        "whatwg-url": "^15.1.0"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/data-urls/node_modules/whatwg-mimetype": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-5.0.0.tgz",
+      "integrity": "sha512-sXcNcHOC51uPGF0P/D4NVtrkjSU2fNsm9iog4ZvZJsL3rjoDAzXZhkm2MWt1y+PUdggKAYVoMAIYcs78wJ51Cw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=20"
+      }
+    },
     "node_modules/data-view-buffer": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/data-view-buffer/-/data-view-buffer-1.0.2.tgz",
@@ -4525,6 +5202,13 @@
         }
       }
     },
+    "node_modules/decimal.js": {
+      "version": "10.6.0",
+      "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.6.0.tgz",
+      "integrity": "sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/decompress-response": {
       "version": "6.0.0",
       "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-6.0.0.tgz",
@@ -4632,6 +5316,16 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/dequal": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz",
+      "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
     "node_modules/detect-libc": {
       "version": "2.0.4",
       "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.0.4.tgz",
@@ -4780,6 +5474,14 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/dom-accessibility-api": {
+      "version": "0.5.16",
+      "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.5.16.tgz",
+      "integrity": "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
     "node_modules/dotenv": {
       "version": "16.6.1",
       "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.6.1.tgz",
@@ -5190,6 +5892,19 @@
         "node": ">=10.13.0"
       }
     },
+    "node_modules/entities": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-6.0.1.tgz",
+      "integrity": "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.12"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
     "node_modules/env-paths": {
       "version": "2.2.1",
       "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-2.2.1.tgz",
@@ -5320,6 +6035,13 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/es-module-lexer": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.7.0.tgz",
+      "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/es-object-atoms": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
@@ -5720,6 +6442,16 @@
         "node": ">=4.0"
       }
     },
+    "node_modules/estree-walker": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz",
+      "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.0"
+      }
+    },
     "node_modules/esutils": {
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
@@ -5730,6 +6462,16 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/expect-type": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.3.0.tgz",
+      "integrity": "sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
     "node_modules/exponential-backoff": {
       "version": "3.1.2",
       "resolved": "https://registry.npmjs.org/exponential-backoff/-/exponential-backoff-3.1.2.tgz",
@@ -5858,6 +6600,13 @@
         "pend": "~1.2.0"
       }
     },
+    "node_modules/fflate": {
+      "version": "0.8.2",
+      "resolved": "https://registry.npmjs.org/fflate/-/fflate-0.8.2.tgz",
+      "integrity": "sha512-cPJU47OaAoCbg0pBvzsgpTPhmhqI5eJjh/JIu8tPj5q+T7iLvW/JAYUqmE7KOB4R1ZyEhzBaIQpQpardBF5z8A==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/file-entry-cache": {
       "version": "8.0.0",
       "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz",
@@ -6557,6 +7306,26 @@
       "dev": true,
       "license": "ISC"
     },
+    "node_modules/html-encoding-sniffer": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-6.0.0.tgz",
+      "integrity": "sha512-CV9TW3Y3f8/wT0BRFc1/KAVQ3TUHiXmaAb6VW9vtiMFf7SLoMd1PdAc4W3KFOFETBJUb90KatHqlsZMWV+R9Gg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@exodus/bytes": "^1.6.0"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      }
+    },
+    "node_modules/html-escaper": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz",
+      "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/http-cache-semantics": {
       "version": "4.2.0",
       "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz",
@@ -7085,6 +7854,13 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/is-potential-custom-element-name": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz",
+      "integrity": "sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/is-regex": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.2.1.tgz",
@@ -7260,6 +8036,45 @@
       "dev": true,
       "license": "ISC"
     },
+    "node_modules/istanbul-lib-coverage": {
+      "version": "3.2.2",
+      "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.2.tgz",
+      "integrity": "sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/istanbul-lib-report": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.1.tgz",
+      "integrity": "sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "istanbul-lib-coverage": "^3.0.0",
+        "make-dir": "^4.0.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/istanbul-reports": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.2.0.tgz",
+      "integrity": "sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "html-escaper": "^2.0.0",
+        "istanbul-lib-report": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/iterator.prototype": {
       "version": "1.1.5",
       "resolved": "https://registry.npmjs.org/iterator.prototype/-/iterator.prototype-1.1.5.tgz",
@@ -7360,6 +8175,46 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/jsdom": {
+      "version": "27.4.0",
+      "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-27.4.0.tgz",
+      "integrity": "sha512-mjzqwWRD9Y1J1KUi7W97Gja1bwOOM5Ug0EZ6UDK3xS7j7mndrkwozHtSblfomlzyB4NepioNt+B2sOSzczVgtQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@acemir/cssom": "^0.9.28",
+        "@asamuzakjp/dom-selector": "^6.7.6",
+        "@exodus/bytes": "^1.6.0",
+        "cssstyle": "^5.3.4",
+        "data-urls": "^6.0.0",
+        "decimal.js": "^10.6.0",
+        "html-encoding-sniffer": "^6.0.0",
+        "http-proxy-agent": "^7.0.2",
+        "https-proxy-agent": "^7.0.6",
+        "is-potential-custom-element-name": "^1.0.1",
+        "parse5": "^8.0.0",
+        "saxes": "^6.0.0",
+        "symbol-tree": "^3.2.4",
+        "tough-cookie": "^6.0.0",
+        "w3c-xmlserializer": "^5.0.0",
+        "webidl-conversions": "^8.0.0",
+        "whatwg-mimetype": "^4.0.0",
+        "whatwg-url": "^15.1.0",
+        "ws": "^8.18.3",
+        "xml-name-validator": "^5.0.0"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      },
+      "peerDependencies": {
+        "canvas": "^3.0.0"
+      },
+      "peerDependenciesMeta": {
+        "canvas": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/jsesc": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
@@ -7898,21 +8753,73 @@
         "yallist": "^3.0.2"
       }
     },
+    "node_modules/lz-string": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/lz-string/-/lz-string-1.5.0.tgz",
+      "integrity": "sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "bin": {
+        "lz-string": "bin/bin.js"
+      }
+    },
     "node_modules/magic-string": {
-      "version": "0.30.17",
-      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.17.tgz",
-      "integrity": "sha512-sNPKHvyjVf7gyjwS4xGTaW/mCnF8wnjtifKBEhxfZ7E/S8tQ0rssrwGNn6q8JH/ohItJfSQp9mBtQYuTlH5QnA==",
+      "version": "0.30.21",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
+      "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",
       "license": "MIT",
       "dependencies": {
-        "@jridgewell/sourcemap-codec": "^1.5.0"
+        "@jridgewell/sourcemap-codec": "^1.5.5"
       }
     },
-    "node_modules/make-fetch-happen": {
-      "version": "10.2.1",
-      "resolved": "https://registry.npmjs.org/make-fetch-happen/-/make-fetch-happen-10.2.1.tgz",
-      "integrity": "sha512-NgOPbRiaQM10DYXvN3/hhGVI2M5MtITFryzBGxHM5p4wnFxsVCbxkrBrDsk+EZ5OB4jEOT7AjDxtdF+KVEFT7w==",
+    "node_modules/magicast": {
+      "version": "0.5.1",
+      "resolved": "https://registry.npmjs.org/magicast/-/magicast-0.5.1.tgz",
+      "integrity": "sha512-xrHS24IxaLrvuo613F719wvOIv9xPHFWQHuvGUBmPnCA/3MQxKI3b+r7n1jAoDHmsbC5bRhTZYR77invLAxVnw==",
       "dev": true,
-      "license": "ISC",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.28.5",
+        "@babel/types": "^7.28.5",
+        "source-map-js": "^1.2.1"
+      }
+    },
+    "node_modules/make-dir": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-4.0.0.tgz",
+      "integrity": "sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "semver": "^7.5.3"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/make-dir/node_modules/semver": {
+      "version": "7.7.3",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz",
+      "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/make-fetch-happen": {
+      "version": "10.2.1",
+      "resolved": "https://registry.npmjs.org/make-fetch-happen/-/make-fetch-happen-10.2.1.tgz",
+      "integrity": "sha512-NgOPbRiaQM10DYXvN3/hhGVI2M5MtITFryzBGxHM5p4wnFxsVCbxkrBrDsk+EZ5OB4jEOT7AjDxtdF+KVEFT7w==",
+      "dev": true,
+      "license": "ISC",
       "dependencies": {
         "agentkeepalive": "^4.2.1",
         "cacache": "^16.1.0",
@@ -8009,6 +8916,13 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/mdn-data": {
+      "version": "2.12.2",
+      "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.12.2.tgz",
+      "integrity": "sha512-IEn+pegP1aManZuckezWCO+XZQDplx1366JoVhTpMpBB1sPey/SbveZQUosKiKiGYjg1wH4pMlNgXbCiYgihQA==",
+      "dev": true,
+      "license": "CC0-1.0"
+    },
     "node_modules/merge2": {
       "version": "1.4.1",
       "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
@@ -8088,6 +9002,16 @@
         "node": ">=4"
       }
     },
+    "node_modules/min-indent": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/min-indent/-/min-indent-1.0.1.tgz",
+      "integrity": "sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
     "node_modules/minimatch": {
       "version": "10.0.3",
       "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.0.3.tgz",
@@ -8238,6 +9162,16 @@
         "node": ">=10"
       }
     },
+    "node_modules/mrmime": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/mrmime/-/mrmime-2.0.1.tgz",
+      "integrity": "sha512-Y3wQdFg2Va6etvQ5I82yUhGdsKrcYox6p7FfL1LbK2J4V01F9TGlepTIhnK24t7koZibmg82KGglhA1XK5IsLQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      }
+    },
     "node_modules/ms": {
       "version": "2.1.3",
       "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
@@ -8556,6 +9490,17 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/obug": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/obug/-/obug-2.1.1.tgz",
+      "integrity": "sha512-uTqF9MuPraAQ+IsnPf366RG4cP9RtUi7MLO1N3KEc+wb0a6yKpeL0lmk2IB1jY5KHPAlTc6T/JRdC/YqxHNwkQ==",
+      "dev": true,
+      "funding": [
+        "https://github.com/sponsors/sxzz",
+        "https://opencollective.com/debug"
+      ],
+      "license": "MIT"
+    },
     "node_modules/once": {
       "version": "1.4.0",
       "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
@@ -8735,6 +9680,19 @@
         "url": "https://github.com/sponsors/wooorm"
       }
     },
+    "node_modules/parse5": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/parse5/-/parse5-8.0.0.tgz",
+      "integrity": "sha512-9m4m5GSgXjL4AjumKzq1Fgfp3Z8rsvjRNbnkVwfu2ImRqE5D0LnY2QfDen18FSY9C573YU5XxSapdHZTZ2WolA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "entities": "^6.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/inikulin/parse5?sponsor=1"
+      }
+    },
     "node_modules/path-exists": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
@@ -8806,6 +9764,13 @@
         "node": ">=16 || 14 >=14.17"
       }
     },
+    "node_modules/pathe": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
+      "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/pe-library": {
       "version": "0.4.1",
       "resolved": "https://registry.npmjs.org/pe-library/-/pe-library-0.4.1.tgz",
@@ -8846,6 +9811,53 @@
         "url": "https://github.com/sponsors/jonschlinkert"
       }
     },
+    "node_modules/playwright": {
+      "version": "1.58.1",
+      "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.58.1.tgz",
+      "integrity": "sha512-+2uTZHxSCcxjvGc5C891LrS1/NlxglGxzrC4seZiVjcYVQfUa87wBL6rTDqzGjuoWNjnBzRqKmF6zRYGMvQUaQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "playwright-core": "1.58.1"
+      },
+      "bin": {
+        "playwright": "cli.js"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "fsevents": "2.3.2"
+      }
+    },
+    "node_modules/playwright-core": {
+      "version": "1.58.1",
+      "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.58.1.tgz",
+      "integrity": "sha512-bcWzOaTxcW+VOOGBCQgnaKToLJ65d6AqfLVKEWvexyS3AS6rbXl+xdpYRMGSRBClPvyj44njOWoxjNdL/H9UNg==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "playwright-core": "cli.js"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/playwright/node_modules/fsevents": {
+      "version": "2.3.2",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz",
+      "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
     "node_modules/plist": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/plist/-/plist-3.1.0.tgz",
@@ -8937,6 +9949,44 @@
         "node": ">=6.0.0"
       }
     },
+    "node_modules/pretty-format": {
+      "version": "27.5.1",
+      "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-27.5.1.tgz",
+      "integrity": "sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "ansi-regex": "^5.0.1",
+        "ansi-styles": "^5.0.0",
+        "react-is": "^17.0.1"
+      },
+      "engines": {
+        "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0"
+      }
+    },
+    "node_modules/pretty-format/node_modules/ansi-styles": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz",
+      "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/pretty-format/node_modules/react-is": {
+      "version": "17.0.2",
+      "resolved": "https://registry.npmjs.org/react-is/-/react-is-17.0.2.tgz",
+      "integrity": "sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
     "node_modules/prismjs": {
       "version": "1.30.0",
       "resolved": "https://registry.npmjs.org/prismjs/-/prismjs-1.30.0.tgz",
@@ -9240,6 +10290,20 @@
         "node": ">=10"
       }
     },
+    "node_modules/redent": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/redent/-/redent-3.0.0.tgz",
+      "integrity": "sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "indent-string": "^4.0.0",
+        "strip-indent": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/reflect.getprototypeof": {
       "version": "1.0.10",
       "resolved": "https://registry.npmjs.org/reflect.getprototypeof/-/reflect.getprototypeof-1.0.10.tgz",
@@ -9316,6 +10380,16 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/require-from-string": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
+      "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/resedit": {
       "version": "1.7.2",
       "resolved": "https://registry.npmjs.org/resedit/-/resedit-1.7.2.tgz",
@@ -9609,6 +10683,19 @@
       "integrity": "sha512-+aWOz7yVScEGoKNd4PA10LZ8sk0A/z5+nXQG5giUO5rprX9jgYsTdov9qCchZiPIZezbZH+jRut8nPodFAX4Jg==",
       "license": "ISC"
     },
+    "node_modules/saxes": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/saxes/-/saxes-6.0.0.tgz",
+      "integrity": "sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "xmlchars": "^2.2.0"
+      },
+      "engines": {
+        "node": ">=v12.22.7"
+      }
+    },
     "node_modules/scheduler": {
       "version": "0.26.0",
       "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.26.0.tgz",
@@ -9795,6 +10882,13 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/siginfo": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz",
+      "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==",
+      "dev": true,
+      "license": "ISC"
+    },
     "node_modules/signal-exit": {
       "version": "3.0.7",
       "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
@@ -9828,6 +10922,21 @@
         "node": ">=10"
       }
     },
+    "node_modules/sirv": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/sirv/-/sirv-3.0.2.tgz",
+      "integrity": "sha512-2wcC/oGxHis/BoHkkPwldgiPSYcpZK3JU28WoMVv55yHJgcZ8rlXvuG9iZggz+sU1d4bRgIGASwyWqjxu3FM0g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@polka/url": "^1.0.0-next.24",
+        "mrmime": "^2.0.0",
+        "totalist": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/slice-ansi": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-3.0.0.tgz",
@@ -9958,6 +11067,13 @@
         "node": "^12.13.0 || ^14.15.0 || >=16.0.0"
       }
     },
+    "node_modules/stackback": {
+      "version": "0.0.2",
+      "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz",
+      "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/stat-mode": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/stat-mode/-/stat-mode-1.0.0.tgz",
@@ -9968,6 +11084,13 @@
         "node": ">= 6"
       }
     },
+    "node_modules/std-env": {
+      "version": "3.10.0",
+      "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.10.0.tgz",
+      "integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/stop-iteration-iterator": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/stop-iteration-iterator/-/stop-iteration-iterator-1.1.0.tgz",
@@ -10144,6 +11267,19 @@
         "node": ">=8"
       }
     },
+    "node_modules/strip-indent": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/strip-indent/-/strip-indent-3.0.0.tgz",
+      "integrity": "sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "min-indent": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/strip-json-comments": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
@@ -10195,6 +11331,13 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/symbol-tree": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/symbol-tree/-/symbol-tree-3.2.4.tgz",
+      "integrity": "sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/synckit": {
       "version": "0.11.8",
       "resolved": "https://registry.npmjs.org/synckit/-/synckit-0.11.8.tgz",
@@ -10334,14 +11477,31 @@
       "integrity": "sha512-qVtvMxeXbVej0cQWKqVSSAHmKZEHAvxdF8HEUBFWts8h+xEo5m/lEiPakuyZ3BnCBjOD8i24kzNOiOLLgsSxhA==",
       "license": "MIT"
     },
+    "node_modules/tinybench": {
+      "version": "2.9.0",
+      "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz",
+      "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/tinyexec": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.0.2.tgz",
+      "integrity": "sha512-W/KYk+NFhkmsYpuHq5JykngiOCnxeVL8v8dFnqxSD8qEEdRfXk1SDM6JzNqcERbcGYj9tMrDQBYV9cjgnunFIg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/tinyglobby": {
-      "version": "0.2.14",
-      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.14.tgz",
-      "integrity": "sha512-tX5e7OM1HnYr2+a2C/4V0htOcSQcoSTH9KgJnVvNm5zm/cyEWKJ7j7YutsH9CxMdtOkkLFy2AHrMci9IM8IPZQ==",
+      "version": "0.2.15",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
+      "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
       "license": "MIT",
       "dependencies": {
-        "fdir": "^6.4.4",
-        "picomatch": "^4.0.2"
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.3"
       },
       "engines": {
         "node": ">=12.0.0"
@@ -10351,10 +11511,13 @@
       }
     },
     "node_modules/tinyglobby/node_modules/fdir": {
-      "version": "6.4.6",
-      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.4.6.tgz",
-      "integrity": "sha512-hiFoqpyZcfNm1yc4u8oWCf9A2c4D3QjCrks3zmoVKVxpQRzmPNar1hUJcBG2RQHvEVGDN+Jm81ZheVLAQMK6+w==",
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
       "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
       "peerDependencies": {
         "picomatch": "^3 || ^4"
       },
@@ -10365,9 +11528,9 @@
       }
     },
     "node_modules/tinyglobby/node_modules/picomatch": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.2.tgz",
-      "integrity": "sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg==",
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
       "license": "MIT",
       "engines": {
         "node": ">=12"
@@ -10376,6 +11539,36 @@
         "url": "https://github.com/sponsors/jonschlinkert"
       }
     },
+    "node_modules/tinyrainbow": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-3.0.3.tgz",
+      "integrity": "sha512-PSkbLUoxOFRzJYjjxHJt9xro7D+iilgMX/C9lawzVuYiIdcihh9DXmVibBe8lmcFrRi/VzlPjBxbN7rH24q8/Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/tldts": {
+      "version": "7.0.19",
+      "resolved": "https://registry.npmjs.org/tldts/-/tldts-7.0.19.tgz",
+      "integrity": "sha512-8PWx8tvC4jDB39BQw1m4x8y5MH1BcQ5xHeL2n7UVFulMPH/3Q0uiamahFJ3lXA0zO2SUyRXuVVbWSDmstlt9YA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tldts-core": "^7.0.19"
+      },
+      "bin": {
+        "tldts": "bin/cli.js"
+      }
+    },
+    "node_modules/tldts-core": {
+      "version": "7.0.19",
+      "resolved": "https://registry.npmjs.org/tldts-core/-/tldts-core-7.0.19.tgz",
+      "integrity": "sha512-lJX2dEWx0SGH4O6p+7FPwYmJ/bu1JbcGJ8RLaG9b7liIgZ85itUVEPbMtWRVrde/0fnDPEPHW10ZsKW3kVsE9A==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/tmp": {
       "version": "0.2.3",
       "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.3.tgz",
@@ -10409,6 +11602,42 @@
         "node": ">=8.0"
       }
     },
+    "node_modules/totalist": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/totalist/-/totalist-3.0.1.tgz",
+      "integrity": "sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/tough-cookie": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-6.0.0.tgz",
+      "integrity": "sha512-kXuRi1mtaKMrsLUxz3sQYvVl37B0Ns6MzfrtV5DvJceE9bPyspOqk9xxv7XbZWcfLWbFmm997vl83qUWVJA64w==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "tldts": "^7.0.5"
+      },
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/tr46": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-6.0.0.tgz",
+      "integrity": "sha512-bLVMLPtstlZ4iMQHpFHTR7GAGj2jxi8Dg0s2h2MafAE4uSWF98FC/3MomU51iQAMf8/qDUbKWf5GxuvvVcXEhw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "punycode": "^2.3.1"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
     "node_modules/truncate-utf8-bytes": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/truncate-utf8-bytes/-/truncate-utf8-bytes-1.0.2.tgz",
@@ -10799,6 +12028,110 @@
         "url": "https://github.com/sponsors/jonschlinkert"
       }
     },
+    "node_modules/vitest": {
+      "version": "4.0.18",
+      "resolved": "https://registry.npmjs.org/vitest/-/vitest-4.0.18.tgz",
+      "integrity": "sha512-hOQuK7h0FGKgBAas7v0mSAsnvrIgAvWmRFjmzpJ7SwFHH3g1k2u37JtYwOwmEKhK6ZO3v9ggDBBm0La1LCK4uQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/expect": "4.0.18",
+        "@vitest/mocker": "4.0.18",
+        "@vitest/pretty-format": "4.0.18",
+        "@vitest/runner": "4.0.18",
+        "@vitest/snapshot": "4.0.18",
+        "@vitest/spy": "4.0.18",
+        "@vitest/utils": "4.0.18",
+        "es-module-lexer": "^1.7.0",
+        "expect-type": "^1.2.2",
+        "magic-string": "^0.30.21",
+        "obug": "^2.1.1",
+        "pathe": "^2.0.3",
+        "picomatch": "^4.0.3",
+        "std-env": "^3.10.0",
+        "tinybench": "^2.9.0",
+        "tinyexec": "^1.0.2",
+        "tinyglobby": "^0.2.15",
+        "tinyrainbow": "^3.0.3",
+        "vite": "^6.0.0 || ^7.0.0",
+        "why-is-node-running": "^2.3.0"
+      },
+      "bin": {
+        "vitest": "vitest.mjs"
+      },
+      "engines": {
+        "node": "^20.0.0 || ^22.0.0 || >=24.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "@edge-runtime/vm": "*",
+        "@opentelemetry/api": "^1.9.0",
+        "@types/node": "^20.0.0 || ^22.0.0 || >=24.0.0",
+        "@vitest/browser-playwright": "4.0.18",
+        "@vitest/browser-preview": "4.0.18",
+        "@vitest/browser-webdriverio": "4.0.18",
+        "@vitest/ui": "4.0.18",
+        "happy-dom": "*",
+        "jsdom": "*"
+      },
+      "peerDependenciesMeta": {
+        "@edge-runtime/vm": {
+          "optional": true
+        },
+        "@opentelemetry/api": {
+          "optional": true
+        },
+        "@types/node": {
+          "optional": true
+        },
+        "@vitest/browser-playwright": {
+          "optional": true
+        },
+        "@vitest/browser-preview": {
+          "optional": true
+        },
+        "@vitest/browser-webdriverio": {
+          "optional": true
+        },
+        "@vitest/ui": {
+          "optional": true
+        },
+        "happy-dom": {
+          "optional": true
+        },
+        "jsdom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vitest/node_modules/picomatch": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/w3c-xmlserializer": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/w3c-xmlserializer/-/w3c-xmlserializer-5.0.0.tgz",
+      "integrity": "sha512-o8qghlI8NZHU1lLPrpi2+Uq7abh4GGPpYANlalzWxyWteJOCsr/P+oPBA49TOLu5FTZO4d3F9MnWJfiMo4BkmA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "xml-name-validator": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/wcwidth": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/wcwidth/-/wcwidth-1.0.1.tgz",
@@ -10809,6 +12142,40 @@
         "defaults": "^1.0.3"
       }
     },
+    "node_modules/webidl-conversions": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-8.0.1.tgz",
+      "integrity": "sha512-BMhLD/Sw+GbJC21C/UgyaZX41nPt8bUTg+jWyDeg7e7YN4xOM05YPSIXceACnXVtqyEw/LMClUQMtMZ+PGGpqQ==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/whatwg-mimetype": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-4.0.0.tgz",
+      "integrity": "sha512-QaKxh0eNIi2mE9p2vEdzfagOKHCcj1pJ56EEHGQOVxp8r9/iszLUUV7v89x9O1p/T+NlTM5W7jW6+cz4Fq1YVg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/whatwg-url": {
+      "version": "15.1.0",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-15.1.0.tgz",
+      "integrity": "sha512-2ytDk0kiEj/yu90JOAp44PVPUkO9+jVhyf+SybKlRHSDlvOOZhdPIrr7xTH64l4WixO2cP+wQIcgujkGBPPz6g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tr46": "^6.0.0",
+        "webidl-conversions": "^8.0.0"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
     "node_modules/which": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
@@ -10910,6 +12277,23 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/why-is-node-running": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz",
+      "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "siginfo": "^2.0.0",
+        "stackback": "0.0.2"
+      },
+      "bin": {
+        "why-is-node-running": "cli.js"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/wide-align": {
       "version": "1.1.5",
       "resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.5.tgz",
@@ -10973,6 +12357,38 @@
       "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
       "license": "ISC"
     },
+    "node_modules/ws": {
+      "version": "8.19.0",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz",
+      "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/xml-name-validator": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-5.0.0.tgz",
+      "integrity": "sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/xmlbuilder": {
       "version": "15.1.1",
       "resolved": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-15.1.1.tgz",
@@ -10983,6 +12399,13 @@
         "node": ">=8.0"
       }
     },
+    "node_modules/xmlchars": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/xmlchars/-/xmlchars-2.2.0.tgz",
+      "integrity": "sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/xtend": {
       "version": "4.0.2",
       "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz",
diff --git a/package.json b/package.json
index 614b745..b923753 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "clipless",
-  "version": "1.7.0",
+  "version": "1.7.1",
   "description": "An Electron application with React and TypeScript",
   "main": "./out/main/index.js",
   "author": "Daniel Essig",
@@ -23,7 +23,12 @@
     "build:win": "npm run build && electron-builder --win",
     "build:mac": "electron-vite build && electron-builder --mac",
     "build:linux": "electron-vite build && electron-builder --linux",
-    "release": "electron-builder"
+    "release": "electron-builder",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest run --coverage",
+    "test:e2e": "playwright test"
   },
   "dependencies": {
     "@electron-toolkit/preload": "^3.0.1",
@@ -42,11 +47,17 @@
     "@electron-toolkit/eslint-config-prettier": "^3.0.0",
     "@electron-toolkit/eslint-config-ts": "^3.0.0",
     "@electron-toolkit/tsconfig": "^1.0.1",
+    "@playwright/test": "^1.58.1",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.2",
+    "@testing-library/user-event": "^14.6.1",
     "@types/node": "^22.14.1",
     "@types/react": "^19.1.1",
     "@types/react-dom": "^19.1.2",
     "@types/react-syntax-highlighter": "^15.5.13",
     "@vitejs/plugin-react": "^4.3.4",
+    "@vitest/coverage-v8": "^4.0.18",
+    "@vitest/ui": "^4.0.18",
     "electron": "^35.1.5",
     "electron-builder": "^25.1.8",
     "electron-vite": "^3.1.0",
@@ -54,10 +65,12 @@
     "eslint-plugin-react": "^7.37.5",
     "eslint-plugin-react-hooks": "^5.2.0",
     "eslint-plugin-react-refresh": "^0.4.19",
+    "jsdom": "^27.4.0",
     "prettier": "^3.5.3",
     "react": "^19.1.0",
     "react-dom": "^19.1.0",
     "typescript": "^5.8.3",
-    "vite": "^6.2.6"
+    "vite": "^6.2.6",
+    "vitest": "^4.0.18"
   }
 }
diff --git a/playwright.config.ts b/playwright.config.ts
new file mode 100644
index 0000000..6bf9abc
--- /dev/null
+++ b/playwright.config.ts
@@ -0,0 +1,12 @@
+import { defineConfig } from '@playwright/test';
+
+export default defineConfig({
+  testDir: './e2e',
+  timeout: 30000,
+  retries: 0,
+  workers: 1,
+  fullyParallel: false,
+  use: {
+    trace: 'on-first-retry',
+  },
+});
diff --git a/src/main/__mocks__/electron.ts b/src/main/__mocks__/electron.ts
new file mode 100644
index 0000000..b2b71e1
--- /dev/null
+++ b/src/main/__mocks__/electron.ts
@@ -0,0 +1,59 @@
+import { vi } from 'vitest';
+
+export const clipboard = {
+  readText: vi.fn().mockReturnValue(''),
+  readHTML: vi.fn().mockReturnValue(''),
+  readRTF: vi.fn().mockReturnValue(''),
+  readImage: vi.fn().mockReturnValue({ isEmpty: () => true, toDataURL: () => '' }),
+  readBookmark: vi.fn().mockReturnValue({ title: '', url: '' }),
+  writeText: vi.fn(),
+  writeHTML: vi.fn(),
+  writeRTF: vi.fn(),
+  writeImage: vi.fn(),
+  writeBookmark: vi.fn(),
+  write: vi.fn(),
+};
+
+export const safeStorage = {
+  isEncryptionAvailable: vi.fn().mockReturnValue(true),
+  encryptString: vi.fn((str: string) => Buffer.from(str)),
+  decryptString: vi.fn((buf: Buffer) => buf.toString()),
+};
+
+export const globalShortcut = {
+  register: vi.fn().mockReturnValue(true),
+  unregister: vi.fn(),
+  unregisterAll: vi.fn(),
+  isRegistered: vi.fn().mockReturnValue(false),
+};
+
+export const nativeImage = {
+  createFromDataURL: vi.fn().mockReturnValue({
+    isEmpty: () => false,
+    toDataURL: () => 'data:image/png;base64,test',
+    getSize: () => ({ width: 100, height: 100 }),
+  }),
+};
+
+export const BrowserWindow = vi.fn().mockImplementation(() => ({
+  isVisible: vi.fn().mockReturnValue(true),
+  isFocused: vi.fn().mockReturnValue(false),
+  isMinimized: vi.fn().mockReturnValue(false),
+  isDestroyed: vi.fn().mockReturnValue(false),
+  show: vi.fn(),
+  hide: vi.fn(),
+  focus: vi.fn(),
+  restore: vi.fn(),
+  webContents: {
+    send: vi.fn(),
+  },
+}));
+
+export const shell = {
+  openExternal: vi.fn().mockResolvedValue(undefined),
+};
+
+export const app = {
+  getPath: vi.fn().mockReturnValue('/mock/path'),
+  focus: vi.fn(),
+};
diff --git a/src/main/clipboard/data.test.ts b/src/main/clipboard/data.test.ts
new file mode 100644
index 0000000..36b25a4
--- /dev/null
+++ b/src/main/clipboard/data.test.ts
@@ -0,0 +1,224 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('electron', () => ({
+  clipboard: {
+    readText: vi.fn().mockReturnValue(''),
+    readHTML: vi.fn().mockReturnValue(''),
+    readRTF: vi.fn().mockReturnValue(''),
+    readImage: vi.fn().mockReturnValue({ isEmpty: () => true, toDataURL: () => '' }),
+    readBookmark: vi.fn().mockReturnValue({ title: '', url: '' }),
+    writeText: vi.fn(),
+    writeHTML: vi.fn(),
+    writeRTF: vi.fn(),
+    writeImage: vi.fn(),
+    write: vi.fn(),
+  },
+  nativeImage: {
+    createFromDataURL: vi.fn().mockReturnValue({
+      isEmpty: () => false,
+      toDataURL: () => 'data:image/png;base64,test',
+    }),
+  },
+}));
+
+import {
+  getCurrentClipboardData,
+  getClipboardText,
+  getClipboardHTML,
+  getClipboardRTF,
+  getClipboardImage,
+  getClipboardBookmark,
+  setClipboardText,
+  setClipboardHTML,
+  setClipboardRTF,
+  setClipboardImage,
+  setClipboardBookmark,
+} from './data';
+import { clipboard, nativeImage } from 'electron';
+
+describe('getCurrentClipboardData', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(clipboard.readText).mockReturnValue('');
+    vi.mocked(clipboard.readRTF).mockReturnValue('');
+    vi.mocked(clipboard.readHTML).mockReturnValue('');
+    vi.mocked(clipboard.readImage).mockReturnValue({
+      isEmpty: () => true,
+      toDataURL: () => '',
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } as any);
+    vi.mocked(clipboard.readBookmark).mockReturnValue({ title: '', url: '' });
+  });
+
+  it('returns text type when text is available', () => {
+    vi.mocked(clipboard.readText).mockReturnValue('hello');
+    const result = getCurrentClipboardData();
+    expect(result).toEqual({ type: 'text', content: 'hello' });
+  });
+
+  it('returns rtf type when only RTF is available', () => {
+    vi.mocked(clipboard.readRTF).mockReturnValue('{\\rtf1 hello}');
+    const result = getCurrentClipboardData();
+    expect(result).toEqual({ type: 'rtf', content: '{\\rtf1 hello}' });
+  });
+
+  it('returns html type when only HTML is available', () => {
+    vi.mocked(clipboard.readHTML).mockReturnValue('<p>hello</p>');
+    const result = getCurrentClipboardData();
+    expect(result).toEqual({ type: 'html', content: '<p>hello</p>' });
+  });
+
+  it('returns image type when only image is available', () => {
+    vi.mocked(clipboard.readImage).mockReturnValue({
+      isEmpty: () => false,
+      toDataURL: () => 'data:image/png;base64,abc',
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } as any);
+    const result = getCurrentClipboardData();
+    expect(result).toEqual({ type: 'image', content: 'data:image/png;base64,abc' });
+  });
+
+  it('returns bookmark type when only bookmark is available', () => {
+    vi.mocked(clipboard.readBookmark).mockReturnValue({
+      title: 'Example',
+      url: 'https://example.com',
+    });
+    const result = getCurrentClipboardData();
+    expect(result).toEqual({
+      type: 'bookmark',
+      content: JSON.stringify({ title: 'Example', url: 'https://example.com' }),
+    });
+  });
+
+  it('returns null when readBookmark throws', () => {
+    vi.mocked(clipboard.readBookmark).mockImplementation(() => {
+      throw new Error('not supported');
+    });
+    const result = getCurrentClipboardData();
+    expect(result).toBeNull();
+  });
+
+  it('returns null when clipboard is empty', () => {
+    const result = getCurrentClipboardData();
+    expect(result).toBeNull();
+  });
+
+  it('prioritizes text over other types', () => {
+    vi.mocked(clipboard.readText).mockReturnValue('text');
+    vi.mocked(clipboard.readHTML).mockReturnValue('<p>html</p>');
+    const result = getCurrentClipboardData();
+    expect(result?.type).toBe('text');
+  });
+});
+
+describe('getClipboardText', () => {
+  it('returns clipboard text', () => {
+    vi.mocked(clipboard.readText).mockReturnValue('test');
+    expect(getClipboardText()).toBe('test');
+  });
+});
+
+describe('setClipboardText', () => {
+  it('writes text to clipboard', () => {
+    setClipboardText('hello');
+    expect(clipboard.writeText).toHaveBeenCalledWith('hello');
+  });
+});
+
+describe('setClipboardImage', () => {
+  it('converts data URL and writes image', () => {
+    setClipboardImage('data:image/png;base64,test');
+    expect(nativeImage.createFromDataURL).toHaveBeenCalledWith('data:image/png;base64,test');
+    expect(clipboard.writeImage).toHaveBeenCalled();
+  });
+});
+
+describe('getClipboardHTML', () => {
+  it('returns clipboard HTML', () => {
+    vi.mocked(clipboard.readHTML).mockReturnValue('<p>test</p>');
+    expect(getClipboardHTML()).toBe('<p>test</p>');
+  });
+});
+
+describe('getClipboardRTF', () => {
+  it('returns clipboard RTF', () => {
+    vi.mocked(clipboard.readRTF).mockReturnValue('{\\rtf1 test}');
+    expect(getClipboardRTF()).toBe('{\\rtf1 test}');
+  });
+});
+
+describe('getClipboardImage', () => {
+  it('returns data URL when image exists', () => {
+    vi.mocked(clipboard.readImage).mockReturnValue({
+      isEmpty: () => false,
+      toDataURL: () => 'data:image/png;base64,abc',
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } as any);
+    expect(getClipboardImage()).toBe('data:image/png;base64,abc');
+  });
+
+  it('returns null when no image', () => {
+    vi.mocked(clipboard.readImage).mockReturnValue({
+      isEmpty: () => true,
+      toDataURL: () => '',
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } as any);
+    expect(getClipboardImage()).toBeNull();
+  });
+});
+
+describe('getClipboardBookmark', () => {
+  it('returns bookmark when available', () => {
+    vi.mocked(clipboard.readBookmark).mockReturnValue({ title: 'Test', url: 'https://test.com' });
+    expect(getClipboardBookmark()).toEqual({ title: 'Test', url: 'https://test.com' });
+  });
+
+  it('returns null when readBookmark throws', () => {
+    vi.mocked(clipboard.readBookmark).mockImplementation(() => {
+      throw new Error('not supported');
+    });
+    expect(getClipboardBookmark()).toBeNull();
+  });
+});
+
+describe('setClipboardHTML', () => {
+  it('writes HTML to clipboard', () => {
+    setClipboardHTML('<p>hello</p>');
+    expect(clipboard.writeHTML).toHaveBeenCalledWith('<p>hello</p>');
+  });
+});
+
+describe('setClipboardRTF', () => {
+  it('writes RTF to clipboard', () => {
+    setClipboardRTF('{\\rtf1 hello}');
+    expect(clipboard.writeRTF).toHaveBeenCalledWith('{\\rtf1 hello}');
+  });
+});
+
+describe('setClipboardImage', () => {
+  it('throws when createFromDataURL fails', () => {
+    vi.mocked(nativeImage.createFromDataURL).mockImplementation(() => {
+      throw new Error('invalid image');
+    });
+    expect(() => setClipboardImage('bad-data')).toThrow('invalid image');
+  });
+});
+
+describe('setClipboardBookmark', () => {
+  it('writes bookmark data', () => {
+    setClipboardBookmark({
+      text: 'Example',
+      html: '<a>Example</a>',
+      title: 'Ex',
+      url: 'https://example.com',
+    });
+    expect(clipboard.write).toHaveBeenCalledWith({ text: 'Example', html: '<a>Example</a>' });
+  });
+
+  it('throws when clipboard.write fails', () => {
+    vi.mocked(clipboard.write).mockImplementation(() => {
+      throw new Error('write failed');
+    });
+    expect(() => setClipboardBookmark({ text: 'a', html: '<a>a</a>' })).toThrow('write failed');
+  });
+});
diff --git a/src/main/clipboard/data.ts b/src/main/clipboard/data.ts
index fb16c94..5f79918 100644
--- a/src/main/clipboard/data.ts
+++ b/src/main/clipboard/data.ts
@@ -4,17 +4,17 @@ import { clipboard, nativeImage } from 'electron';
 export const getCurrentClipboardData = (): { type: string; content: string } | null => {
   // Priority: text > rtf > html > image > bookmark
   const text = clipboard.readText();
-  if (text && text.trim()) {
+  if (text?.trim()) {
     return { type: 'text', content: text };
   }
 
   const rtf = clipboard.readRTF();
-  if (rtf && rtf.trim()) {
+  if (rtf?.trim()) {
     return { type: 'rtf', content: rtf };
   }
 
   const html = clipboard.readHTML();
-  if (html && html.trim()) {
+  if (html?.trim()) {
     return { type: 'html', content: html };
   }
 
@@ -25,7 +25,7 @@ export const getCurrentClipboardData = (): { type: string; content: string } | n
 
   try {
     const bookmark = clipboard.readBookmark();
-    if (bookmark && bookmark.url) {
+    if (bookmark?.url) {
       return { type: 'bookmark', content: JSON.stringify(bookmark) };
     }
   } catch {
diff --git a/src/main/clipboard/ipc.ts b/src/main/clipboard/ipc.ts
index ee2a50c..86bf69a 100644
--- a/src/main/clipboard/ipc.ts
+++ b/src/main/clipboard/ipc.ts
@@ -114,7 +114,9 @@ export function setupClipboardIPC(mainWindow: BrowserWindow | null): void {
       saveClips(clips, lockedIndices)
   );
   ipcMain.handle('storage-get-settings', async () => getSettings());
-  ipcMain.handle('storage-save-settings', async (_event, settings: UserSettings) => saveSettings(settings));
+  ipcMain.handle('storage-save-settings', async (_event, settings: UserSettings) =>
+    saveSettings(settings)
+  );
   ipcMain.handle('storage-get-stats', async () => getStorageStats());
   ipcMain.handle('storage-export-data', async () => exportData());
   ipcMain.handle('storage-import-data', async (_event, jsonData: string) => importData(jsonData));
@@ -134,7 +136,12 @@ export function setupClipboardIPC(mainWindow: BrowserWindow | null): void {
   );
   ipcMain.handle(
     'templates-generate-text',
-    async (_event, templateId: string, clipContents: string[], captures?: Record<string, string>) => {
+    async (
+      _event,
+      templateId: string,
+      clipContents: string[],
+      captures?: Record<string, string>
+    ) => {
       const templates = await getAllTemplates();
       const template = templates.find((t) => t.id === templateId);
       const templateName = template?.name || 'Unknown';
@@ -171,7 +178,9 @@ export function setupClipboardIPC(mainWindow: BrowserWindow | null): void {
     updateQuickTool(id, updates)
   );
   ipcMain.handle('quick-tools-delete', async (_event, id: string) => deleteQuickTool(id));
-  ipcMain.handle('quick-tools-reorder', async (_event, tools: QuickTool[]) => reorderQuickTools(tools));
+  ipcMain.handle('quick-tools-reorder', async (_event, tools: QuickTool[]) =>
+    reorderQuickTools(tools)
+  );
   ipcMain.handle('quick-tools-validate-url', async (_event, url: string, captureGroups: string[]) =>
     validateToolUrl(url, captureGroups)
   );
@@ -180,8 +189,10 @@ export function setupClipboardIPC(mainWindow: BrowserWindow | null): void {
   ipcMain.handle('quick-clips-scan-text', async (_event, text: string) =>
     scanTextForPatterns(text)
   );
-  ipcMain.handle('quick-clips-open-tools', async (_event, matches: PatternMatch[], toolIds: string[]) =>
-    openToolsForMatches(matches, toolIds)
+  ipcMain.handle(
+    'quick-clips-open-tools',
+    async (_event, matches: PatternMatch[], toolIds: string[]) =>
+      openToolsForMatches(matches, toolIds)
   );
   ipcMain.handle('quick-clips-export-config', async () => exportQuickClipsConfig());
   ipcMain.handle('quick-clips-import-config', async (_event, config: QuickClipsConfig) =>
diff --git a/src/main/clipboard/quick-clips.test.ts b/src/main/clipboard/quick-clips.test.ts
new file mode 100644
index 0000000..80d6370
--- /dev/null
+++ b/src/main/clipboard/quick-clips.test.ts
@@ -0,0 +1,520 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const { mockOpenExternal } = vi.hoisted(() => ({
+  mockOpenExternal: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock('electron', () => ({
+  shell: { openExternal: mockOpenExternal },
+}));
+
+vi.mock('../storage', () => ({
+  storage: {
+    getSearchTerms: vi.fn(),
+    getQuickTools: vi.fn(),
+    getTemplates: vi.fn(),
+    importQuickClipsConfig: vi.fn(),
+  },
+}));
+
+import {
+  scanTextForPatterns,
+  openToolsForMatches,
+  exportQuickClipsConfig,
+  importQuickClipsConfig,
+} from './quick-clips';
+import { storage } from '../storage';
+const mockedStorage = vi.mocked(storage);
+
+describe('scanTextForPatterns', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('returns empty array when no search terms exist', async () => {
+    mockedStorage.getSearchTerms.mockResolvedValue([]);
+    const result = await scanTextForPatterns('hello world');
+    expect(result).toEqual([]);
+  });
+
+  it('returns empty array when no patterns match', async () => {
+    mockedStorage.getSearchTerms.mockResolvedValue([
+      {
+        id: '1',
+        name: 'Email',
+        pattern: '(?<email>[\\w.]+@[\\w.]+)',
+        enabled: true,
+        createdAt: 0,
+        updatedAt: 0,
+        order: 0,
+      },
+    ]);
+    const result = await scanTextForPatterns('no emails here');
+    expect(result).toEqual([]);
+  });
+
+  it('matches named capture groups', async () => {
+    mockedStorage.getSearchTerms.mockResolvedValue([
+      {
+        id: '1',
+        name: 'Email',
+        pattern: '(?<email>[\\w.]+@[\\w.]+)',
+        enabled: true,
+        createdAt: 0,
+        updatedAt: 0,
+        order: 0,
+      },
+    ]);
+    const result = await scanTextForPatterns('contact user@example.com for info');
+    expect(result).toHaveLength(1);
+    expect(result[0].searchTermId).toBe('1');
+    expect(result[0].searchTermName).toBe('Email');
+    expect(result[0].captures.email).toBe('user@example.com');
+  });
+
+  it('finds multiple matches in text', async () => {
+    mockedStorage.getSearchTerms.mockResolvedValue([
+      {
+        id: '1',
+        name: 'Email',
+        pattern: '(?<email>[\\w.]+@[\\w.]+)',
+        enabled: true,
+        createdAt: 0,
+        updatedAt: 0,
+        order: 0,
+      },
+    ]);
+    const result = await scanTextForPatterns('a@b.com and c@d.com');
+    expect(result).toHaveLength(2);
+    expect(result[0].captures.email).toBe('a@b.com');
+    expect(result[1].captures.email).toBe('c@d.com');
+  });
+
+  it('skips disabled search terms', async () => {
+    mockedStorage.getSearchTerms.mockResolvedValue([
+      {
+        id: '1',
+        name: 'Email',
+        pattern: '(?<email>[\\w.]+@[\\w.]+)',
+        enabled: false,
+        createdAt: 0,
+        updatedAt: 0,
+        order: 0,
+      },
+    ]);
+    const result = await scanTextForPatterns('user@example.com');
+    expect(result).toEqual([]);
+  });
+
+  it('skips patterns without named capture groups', async () => {
+    mockedStorage.getSearchTerms.mockResolvedValue([
+      {
+        id: '1',
+        name: 'NoGroups',
+        pattern: '\\d+',
+        enabled: true,
+        createdAt: 0,
+        updatedAt: 0,
+        order: 0,
+      },
+    ]);
+    const result = await scanTextForPatterns('123 456');
+    expect(result).toEqual([]);
+  });
+
+  it('handles invalid regex gracefully', async () => {
+    mockedStorage.getSearchTerms.mockResolvedValue([
+      {
+        id: '1',
+        name: 'Bad',
+        pattern: '(?<email>[',
+        enabled: true,
+        createdAt: 0,
+        updatedAt: 0,
+        order: 0,
+      },
+      {
+        id: '2',
+        name: 'Good',
+        pattern: '(?<num>\\d+)',
+        enabled: true,
+        createdAt: 0,
+        updatedAt: 0,
+        order: 0,
+      },
+    ]);
+    const result = await scanTextForPatterns('test 123');
+    expect(result).toHaveLength(1);
+    expect(result[0].captures.num).toBe('123');
+  });
+
+  it('matches multiple capture groups in one pattern', async () => {
+    mockedStorage.getSearchTerms.mockResolvedValue([
+      {
+        id: '1',
+        name: 'NameEmail',
+        pattern: '(?<name>\\w+)\\s+(?<email>[\\w.]+@[\\w.]+)',
+        enabled: true,
+        createdAt: 0,
+        updatedAt: 0,
+        order: 0,
+      },
+    ]);
+    const result = await scanTextForPatterns('John user@example.com');
+    expect(result).toHaveLength(1);
+    expect(result[0].captures.name).toBe('John');
+    expect(result[0].captures.email).toBe('user@example.com');
+  });
+
+  it('skips capture group values that are undefined', async () => {
+    mockedStorage.getSearchTerms.mockResolvedValue([
+      {
+        id: '1',
+        name: 'Optional',
+        pattern: '(?<required>\\w+)(?:-(?<optional>\\w+))?',
+        enabled: true,
+        createdAt: 0,
+        updatedAt: 0,
+        order: 0,
+      },
+    ]);
+    // "hello" matches required but optional group is undefined
+    const result = await scanTextForPatterns('hello');
+    expect(result).toHaveLength(1);
+    expect(result[0].captures.required).toBe('hello');
+    expect(result[0].captures.optional).toBeUndefined();
+  });
+
+  it('throws when storage.getSearchTerms fails', async () => {
+    mockedStorage.getSearchTerms.mockRejectedValue(new Error('storage fail'));
+    await expect(scanTextForPatterns('test')).rejects.toThrow('storage fail');
+  });
+});
+
+describe('openToolsForMatches', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('opens URL with token replaced by capture value', async () => {
+    mockedStorage.getQuickTools.mockResolvedValue([
+      {
+        id: 't1',
+        name: 'Search',
+        url: 'https://google.com/search?q={email}',
+        captureGroups: ['email'],
+        createdAt: 0,
+        updatedAt: 0,
+        order: 0,
+      },
+    ]);
+
+    const matches = [
+      { searchTermId: '1', searchTermName: 'Email', captures: { email: 'test@example.com' } },
+    ];
+    await openToolsForMatches(matches, ['t1']);
+
+    expect(mockOpenExternal).toHaveBeenCalledWith('https://google.com/search?q=test%40example.com');
+  });
+
+  it('skips tool when no matching captures exist', async () => {
+    mockedStorage.getQuickTools.mockResolvedValue([
+      {
+        id: 't1',
+        name: 'Search',
+        url: 'https://example.com/{phone}',
+        captureGroups: ['phone'],
+        createdAt: 0,
+        updatedAt: 0,
+        order: 0,
+      },
+    ]);
+
+    const matches = [
+      { searchTermId: '1', searchTermName: 'Email', captures: { email: 'test@example.com' } },
+    ];
+    await openToolsForMatches(matches, ['t1']);
+
+    expect(mockOpenExternal).not.toHaveBeenCalled();
+  });
+
+  it('skips unknown tool ids', async () => {
+    mockedStorage.getQuickTools.mockResolvedValue([]);
+
+    const matches = [
+      { searchTermId: '1', searchTermName: 'Email', captures: { email: 'test@example.com' } },
+    ];
+    await openToolsForMatches(matches, ['unknown']);
+
+    expect(mockOpenExternal).not.toHaveBeenCalled();
+  });
+
+  it('opens URL as-is when no tokens in URL', async () => {
+    mockedStorage.getQuickTools.mockResolvedValue([
+      {
+        id: 't1',
+        name: 'Static',
+        url: 'https://example.com/page',
+        captureGroups: ['email'],
+        createdAt: 0,
+        updatedAt: 0,
+        order: 0,
+      },
+    ]);
+
+    const matches = [
+      { searchTermId: '1', searchTermName: 'Email', captures: { email: 'test@example.com' } },
+    ];
+    await openToolsForMatches(matches, ['t1']);
+
+    expect(mockOpenExternal).toHaveBeenCalledWith('https://example.com/page');
+  });
+
+  it('uses URL capture directly when tool URL is just a {url} token', async () => {
+    mockedStorage.getQuickTools.mockResolvedValue([
+      {
+        id: 't1',
+        name: 'Open URL',
+        url: '{url}',
+        captureGroups: ['url'],
+        createdAt: 0,
+        updatedAt: 0,
+        order: 0,
+      },
+    ]);
+
+    const matches = [
+      { searchTermId: '1', searchTermName: 'URL', captures: { url: 'https://detected.com' } },
+    ];
+    await openToolsForMatches(matches, ['t1']);
+
+    expect(mockOpenExternal).toHaveBeenCalledWith('https://detected.com');
+  });
+
+  it('generates combinations for multiple tokens', async () => {
+    mockedStorage.getQuickTools.mockResolvedValue([
+      {
+        id: 't1',
+        name: 'Multi',
+        url: 'https://example.com/{name}/{email}',
+        captureGroups: ['name', 'email'],
+        createdAt: 0,
+        updatedAt: 0,
+        order: 0,
+      },
+    ]);
+
+    const matches = [
+      {
+        searchTermId: '1',
+        searchTermName: 'Contact',
+        captures: { name: 'John', email: 'john@test.com' },
+      },
+    ];
+    await openToolsForMatches(matches, ['t1']);
+
+    expect(mockOpenExternal).toHaveBeenCalledWith('https://example.com/John/john%40test.com');
+  });
+
+  it('skips URL generation when token has no matching capture values', async () => {
+    mockedStorage.getQuickTools.mockResolvedValue([
+      {
+        id: 't1',
+        name: 'Search',
+        url: 'https://example.com/{missing}',
+        captureGroups: ['missing'],
+        createdAt: 0,
+        updatedAt: 0,
+        order: 0,
+      },
+    ]);
+
+    const matches = [
+      { searchTermId: '1', searchTermName: 'Email', captures: { email: 'test@example.com' } },
+    ];
+    await openToolsForMatches(matches, ['t1']);
+
+    expect(mockOpenExternal).not.toHaveBeenCalled();
+  });
+
+  it('handles pipe-separated capture groups in tokens', async () => {
+    mockedStorage.getQuickTools.mockResolvedValue([
+      {
+        id: 't1',
+        name: 'Search',
+        url: 'https://example.com/search?q={email|phone}',
+        captureGroups: ['email', 'phone'],
+        createdAt: 0,
+        updatedAt: 0,
+        order: 0,
+      },
+    ]);
+
+    const matches = [
+      {
+        searchTermId: '1',
+        searchTermName: 'Contact',
+        captures: { email: 'test@example.com', phone: '555-1234' },
+      },
+    ];
+    await openToolsForMatches(matches, ['t1']);
+
+    // Should open URLs for each matching capture value
+    expect(mockOpenExternal).toHaveBeenCalled();
+  });
+
+  it('generates all combinations for multi-value multi-token URLs', async () => {
+    mockedStorage.getQuickTools.mockResolvedValue([
+      {
+        id: 't1',
+        name: 'Multi',
+        url: 'https://example.com/{a|b}/{c|d}',
+        captureGroups: ['a', 'b', 'c', 'd'],
+        createdAt: 0,
+        updatedAt: 0,
+        order: 0,
+      },
+    ]);
+
+    const matches = [
+      {
+        searchTermId: '1',
+        searchTermName: 'Test',
+        captures: { a: 'v1', b: 'v2', c: 'v3', d: 'v4' },
+      },
+    ];
+    await openToolsForMatches(matches, ['t1']);
+
+    // With {a|b} having values [v1,v2] and {c|d} having [v3,v4], should get 4 combinations
+    expect(mockOpenExternal).toHaveBeenCalledTimes(4);
+  });
+
+  it('does not encode URL-type capture groups in non-direct URLs', async () => {
+    mockedStorage.getQuickTools.mockResolvedValue([
+      {
+        id: 't1',
+        name: 'URL redirect',
+        url: 'https://redirect.com?target={url}',
+        captureGroups: ['url'],
+        createdAt: 0,
+        updatedAt: 0,
+        order: 0,
+      },
+    ]);
+
+    const matches = [
+      {
+        searchTermId: '1',
+        searchTermName: 'URL',
+        captures: { url: 'https://example.com/path?q=1' },
+      },
+    ];
+    await openToolsForMatches(matches, ['t1']);
+
+    // URL captures should not be encoded when in a compound URL
+    expect(mockOpenExternal).toHaveBeenCalledWith(
+      'https://redirect.com?target=https://example.com/path?q=1'
+    );
+  });
+
+  it('handles falsy capture value for a group', async () => {
+    mockedStorage.getQuickTools.mockResolvedValue([
+      {
+        id: 't1',
+        name: 'Search',
+        url: 'https://example.com/{email}',
+        captureGroups: ['email'],
+        createdAt: 0,
+        updatedAt: 0,
+        order: 0,
+      },
+    ]);
+
+    const matches = [{ searchTermId: '1', searchTermName: 'Email', captures: { email: '' } }];
+    await openToolsForMatches(matches, ['t1']);
+
+    expect(mockOpenExternal).not.toHaveBeenCalled();
+  });
+
+  it('handles URL capture group in multi-token URL', async () => {
+    mockedStorage.getQuickTools.mockResolvedValue([
+      {
+        id: 't1',
+        name: 'Multi',
+        url: 'https://proxy.com/{url}/{name}',
+        captureGroups: ['url', 'name'],
+        createdAt: 0,
+        updatedAt: 0,
+        order: 0,
+      },
+    ]);
+
+    const matches = [
+      {
+        searchTermId: '1',
+        searchTermName: 'Test',
+        captures: { url: 'https://example.com', name: 'test' },
+      },
+    ];
+    await openToolsForMatches(matches, ['t1']);
+
+    expect(mockOpenExternal).toHaveBeenCalledWith('https://proxy.com/https://example.com/test');
+  });
+
+  it('throws when storage fails', async () => {
+    mockedStorage.getQuickTools.mockRejectedValue(new Error('storage error'));
+
+    await expect(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      openToolsForMatches([{ captures: { email: 'a@b.com' } }] as any, ['t1'])
+    ).rejects.toThrow('storage error');
+  });
+});
+
+describe('exportQuickClipsConfig', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('returns config with searchTerms, tools, templates, and version', async () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    mockedStorage.getSearchTerms.mockResolvedValue([{ id: '1' }] as any);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    mockedStorage.getQuickTools.mockResolvedValue([{ id: '2' }] as any);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    mockedStorage.getTemplates.mockResolvedValue([{ id: '3' }] as any);
+
+    const result = await exportQuickClipsConfig();
+
+    expect(result).toEqual({
+      searchTerms: [{ id: '1' }],
+      tools: [{ id: '2' }],
+      templates: [{ id: '3' }],
+      version: '1.0.0',
+    });
+  });
+
+  it('throws when storage fails', async () => {
+    mockedStorage.getSearchTerms.mockRejectedValue(new Error('fail'));
+    await expect(exportQuickClipsConfig()).rejects.toThrow('fail');
+  });
+});
+
+describe('importQuickClipsConfig', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('delegates to storage.importQuickClipsConfig', async () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const config = { searchTerms: [], tools: [], templates: [] } as any;
+    await importQuickClipsConfig(config);
+    expect(mockedStorage.importQuickClipsConfig).toHaveBeenCalledWith(config);
+  });
+
+  it('throws when storage fails', async () => {
+    mockedStorage.importQuickClipsConfig.mockRejectedValue(new Error('import fail'));
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    await expect(importQuickClipsConfig({} as any)).rejects.toThrow('import fail');
+  });
+});
diff --git a/src/main/clipboard/quick-clips.ts b/src/main/clipboard/quick-clips.ts
index f33fd0f..7ee26d3 100644
--- a/src/main/clipboard/quick-clips.ts
+++ b/src/main/clipboard/quick-clips.ts
@@ -1,5 +1,6 @@
+import { shell } from 'electron';
 import { storage } from '../storage';
-import type { PatternMatch } from '../../shared/types';
+import type { PatternMatch, QuickClipsConfig } from '../../shared/types';
 
 // Quick clips scanning functions
 export const scanTextForPatterns = async (text: string): Promise<PatternMatch[]> => {
@@ -47,9 +48,8 @@ export const scanTextForPatterns = async (text: string): Promise<PatternMatch[]>
   }
 };
 
-export const openToolsForMatches = async (matches: any[], toolIds: string[]) => {
+export const openToolsForMatches = async (matches: PatternMatch[], toolIds: string[]) => {
   try {
-    const { shell } = require('electron');
     const tools = await storage.getQuickTools();
 
     for (const toolId of toolIds) {
@@ -113,7 +113,6 @@ export const openToolsForMatches = async (matches: any[], toolIds: string[]) =>
           } else {
             // Get all combinations of values
             const generateCombinations = (replacements: typeof tokenReplacements): string[] => {
-              if (replacements.length === 0) return [''];
               if (replacements.length === 1) {
                 const replacement = replacements[0];
                 return replacement.values.map((value) => {
@@ -175,7 +174,7 @@ export const exportQuickClipsConfig = async () => {
   }
 };
 
-export const importQuickClipsConfig = async (config: any) => {
+export const importQuickClipsConfig = async (config: QuickClipsConfig) => {
   try {
     // Use the new batch import method to avoid race conditions
     await storage.importQuickClipsConfig(config);
diff --git a/src/main/clipboard/quick-tools.test.ts b/src/main/clipboard/quick-tools.test.ts
new file mode 100644
index 0000000..e860578
--- /dev/null
+++ b/src/main/clipboard/quick-tools.test.ts
@@ -0,0 +1,149 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('../storage', () => ({
+  storage: {
+    getQuickTools: vi.fn(),
+    createQuickTool: vi.fn(),
+    updateQuickTool: vi.fn(),
+    deleteQuickTool: vi.fn(),
+    reorderQuickTools: vi.fn(),
+  },
+}));
+
+import {
+  getAllQuickTools,
+  createQuickTool,
+  updateQuickTool,
+  deleteQuickTool,
+  reorderQuickTools,
+  validateToolUrl,
+} from './quick-tools';
+import { storage } from '../storage';
+
+const mockedStorage = vi.mocked(storage);
+
+describe('validateToolUrl', () => {
+  it('returns valid for a proper URL with matching capture groups', async () => {
+    const result = await validateToolUrl('https://example.com/search?q={query}', ['query']);
+    expect(result.isValid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it('returns error for invalid URL format', async () => {
+    const result = await validateToolUrl('not-a-url', []);
+    expect(result.isValid).toBe(false);
+    expect(result.errors).toContain('Invalid URL format');
+  });
+
+  it('returns error when URL token is not in capture groups list', async () => {
+    const result = await validateToolUrl('https://example.com/{email}', ['phone']);
+    expect(result.isValid).toBe(false);
+    expect(result.errors.some((e) => e.includes("'{email}'"))).toBe(true);
+  });
+
+  it('accepts URL with no tokens', async () => {
+    const result = await validateToolUrl('https://example.com/page', []);
+    expect(result.isValid).toBe(true);
+  });
+
+  it('validates multiple tokens', async () => {
+    const result = await validateToolUrl('https://example.com/{name}/{email}', ['name', 'email']);
+    expect(result.isValid).toBe(true);
+  });
+
+  it('reports all missing capture groups', async () => {
+    const result = await validateToolUrl('https://example.com/{a}/{b}', []);
+    expect(result.isValid).toBe(false);
+    expect(result.errors).toHaveLength(2);
+  });
+
+  it('throws when an unexpected error occurs', async () => {
+    // Force an error by passing null as url
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    await expect(validateToolUrl(null as any, [])).rejects.toThrow();
+  });
+});
+
+describe('getAllQuickTools', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('returns tools from storage', async () => {
+    const tools = [{ id: '1', name: 'Tool' }];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    mockedStorage.getQuickTools.mockResolvedValue(tools as any);
+    const result = await getAllQuickTools();
+    expect(result).toEqual(tools);
+  });
+
+  it('throws when storage fails', async () => {
+    mockedStorage.getQuickTools.mockRejectedValue(new Error('fail'));
+    await expect(getAllQuickTools()).rejects.toThrow('fail');
+  });
+});
+
+describe('createQuickTool', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('delegates to storage.createQuickTool', async () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    mockedStorage.createQuickTool.mockResolvedValue({ id: '1' } as any);
+    const result = await createQuickTool('Test', 'https://example.com/{q}', ['q']);
+    expect(mockedStorage.createQuickTool).toHaveBeenCalledWith('Test', 'https://example.com/{q}', [
+      'q',
+    ]);
+    expect(result).toEqual({ id: '1' });
+  });
+
+  it('throws when storage fails', async () => {
+    mockedStorage.createQuickTool.mockRejectedValue(new Error('fail'));
+    await expect(createQuickTool('Test', 'url', [])).rejects.toThrow('fail');
+  });
+});
+
+describe('updateQuickTool', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('delegates to storage.updateQuickTool', async () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    mockedStorage.updateQuickTool.mockResolvedValue({ id: '1' } as any);
+    await updateQuickTool('1', { name: 'Updated' });
+    expect(mockedStorage.updateQuickTool).toHaveBeenCalledWith('1', { name: 'Updated' });
+  });
+
+  it('throws when storage fails', async () => {
+    mockedStorage.updateQuickTool.mockRejectedValue(new Error('fail'));
+    await expect(updateQuickTool('1', {})).rejects.toThrow('fail');
+  });
+});
+
+describe('deleteQuickTool', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('delegates to storage.deleteQuickTool', async () => {
+    mockedStorage.deleteQuickTool.mockResolvedValue(undefined);
+    await deleteQuickTool('1');
+    expect(mockedStorage.deleteQuickTool).toHaveBeenCalledWith('1');
+  });
+
+  it('throws when storage fails', async () => {
+    mockedStorage.deleteQuickTool.mockRejectedValue(new Error('fail'));
+    await expect(deleteQuickTool('1')).rejects.toThrow('fail');
+  });
+});
+
+describe('reorderQuickTools', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('delegates to storage.reorderQuickTools', async () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const tools = [{ id: '1' }, { id: '2' }] as any;
+    mockedStorage.reorderQuickTools.mockResolvedValue(undefined);
+    await reorderQuickTools(tools);
+    expect(mockedStorage.reorderQuickTools).toHaveBeenCalledWith(tools);
+  });
+
+  it('throws when storage fails', async () => {
+    mockedStorage.reorderQuickTools.mockRejectedValue(new Error('fail'));
+    await expect(reorderQuickTools([])).rejects.toThrow('fail');
+  });
+});
diff --git a/src/main/clipboard/quick-tools.ts b/src/main/clipboard/quick-tools.ts
index d8665f3..c219d92 100644
--- a/src/main/clipboard/quick-tools.ts
+++ b/src/main/clipboard/quick-tools.ts
@@ -1,4 +1,5 @@
 import { storage } from '../storage';
+import type { QuickTool } from '../../shared/types';
 
 // Quick tools management functions
 export const getAllQuickTools = async () => {
@@ -19,7 +20,7 @@ export const createQuickTool = async (name: string, url: string, captureGroups:
   }
 };
 
-export const updateQuickTool = async (id: string, updates: any) => {
+export const updateQuickTool = async (id: string, updates: Partial<QuickTool>) => {
   try {
     return await storage.updateQuickTool(id, updates);
   } catch (error) {
@@ -37,7 +38,7 @@ export const deleteQuickTool = async (id: string) => {
   }
 };
 
-export const reorderQuickTools = async (tools: any[]) => {
+export const reorderQuickTools = async (tools: QuickTool[]) => {
   try {
     await storage.reorderQuickTools(tools);
   } catch (error) {
diff --git a/src/main/clipboard/search-terms.ts b/src/main/clipboard/search-terms.ts
index 60e8f21..e960963 100644
--- a/src/main/clipboard/search-terms.ts
+++ b/src/main/clipboard/search-terms.ts
@@ -1,5 +1,5 @@
 import { storage } from '../storage';
-import type { PatternMatch } from '../../shared/types';
+import type { PatternMatch, SearchTerm } from '../../shared/types';
 
 const RESERVED_GROUP_NAME = /^c\d+$/;
 
@@ -40,7 +40,7 @@ export const createSearchTerm = async (name: string, pattern: string) => {
   }
 };
 
-export const updateSearchTerm = async (id: string, updates: any) => {
+export const updateSearchTerm = async (id: string, updates: Partial<SearchTerm>) => {
   try {
     if (updates.pattern) {
       validateCaptureGroupNames(updates.pattern);
@@ -61,7 +61,7 @@ export const deleteSearchTerm = async (id: string) => {
   }
 };
 
-export const reorderSearchTerms = async (searchTerms: any[]) => {
+export const reorderSearchTerms = async (searchTerms: SearchTerm[]) => {
   try {
     await storage.reorderSearchTerms(searchTerms);
   } catch (error) {
diff --git a/src/main/clipboard/storage-integration.ts b/src/main/clipboard/storage-integration.ts
index 955f9fc..bba0d67 100644
--- a/src/main/clipboard/storage-integration.ts
+++ b/src/main/clipboard/storage-integration.ts
@@ -1,8 +1,8 @@
 import { storage } from '../storage';
-import type { ClipItem } from '../../shared/types';
+import type { ClipItem, StoredClip, UserSettings } from '../../shared/types';
 
 // Storage integration functions
-export const getClips = async (): Promise<any[]> => {
+export const getClips = async (): Promise<StoredClip[]> => {
   try {
     return await storage.getClips();
   } catch (error) {
@@ -24,16 +24,16 @@ export const saveClips = async (
   }
 };
 
-export const getSettings = async (): Promise<any> => {
+export const getSettings = async (): Promise<UserSettings> => {
   try {
     return await storage.getSettings();
   } catch (error) {
     console.error('Failed to get settings from storage:', error);
-    return {};
+    return {} as UserSettings;
   }
 };
 
-export const saveSettings = async (settings: any): Promise<boolean> => {
+export const saveSettings = async (settings: UserSettings): Promise<boolean> => {
   try {
     await storage.saveSettings(settings);
     return true;
diff --git a/src/main/clipboard/templates.ts b/src/main/clipboard/templates.ts
index 51d7fbb..bdb8df8 100644
--- a/src/main/clipboard/templates.ts
+++ b/src/main/clipboard/templates.ts
@@ -1,4 +1,5 @@
 import { storage } from '../storage';
+import type { Template } from '../../shared/types';
 
 // Template management functions
 export const getAllTemplates = async () => {
@@ -19,7 +20,7 @@ export const createTemplate = async (name: string, content: string) => {
   }
 };
 
-export const updateTemplate = async (id: string, updates: any) => {
+export const updateTemplate = async (id: string, updates: Partial<Template>) => {
   try {
     return await storage.updateTemplate(id, updates);
   } catch (error) {
@@ -37,7 +38,7 @@ export const deleteTemplate = async (id: string) => {
   }
 };
 
-export const reorderTemplates = async (templates: any[]) => {
+export const reorderTemplates = async (templates: Template[]) => {
   try {
     await storage.reorderTemplates(templates);
   } catch (error) {
diff --git a/src/main/hotkeys/actions.test.ts b/src/main/hotkeys/actions.test.ts
new file mode 100644
index 0000000..7aa5b24
--- /dev/null
+++ b/src/main/hotkeys/actions.test.ts
@@ -0,0 +1,326 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('electron', () => ({
+  BrowserWindow: vi.fn(),
+  app: {
+    focus: vi.fn(),
+  },
+  clipboard: {
+    writeText: vi.fn(),
+    writeHTML: vi.fn(),
+    writeRTF: vi.fn(),
+    writeImage: vi.fn(),
+    writeBookmark: vi.fn(),
+  },
+  nativeImage: {
+    createFromDataURL: vi.fn().mockReturnValue({
+      isEmpty: () => false,
+    }),
+  },
+}));
+
+vi.mock('../storage', () => ({
+  storage: {
+    getClips: vi.fn().mockResolvedValue([]),
+  },
+}));
+
+vi.mock('../notifications', () => ({
+  showNotification: vi.fn(),
+}));
+
+vi.mock('../window/creation.js', () => ({
+  createToolsLauncherWindow: vi.fn(),
+}));
+
+import { HotkeyActions } from './actions';
+import { clipboard, nativeImage, app } from 'electron';
+import { storage } from '../storage';
+
+describe('HotkeyActions', () => {
+  let actions: HotkeyActions;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let mockWindow: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    actions = new HotkeyActions();
+    mockWindow = {
+      isVisible: vi.fn().mockReturnValue(true),
+      isFocused: vi.fn().mockReturnValue(false),
+      isMinimized: vi.fn().mockReturnValue(false),
+      isDestroyed: vi.fn().mockReturnValue(false),
+      show: vi.fn(),
+      hide: vi.fn(),
+      focus: vi.fn(),
+      restore: vi.fn(),
+      webContents: { send: vi.fn() },
+    };
+    actions.setMainWindow(mockWindow);
+  });
+
+  describe('focusWindow', () => {
+    it('hides window when visible and focused', () => {
+      mockWindow.isFocused.mockReturnValue(true);
+      actions.focusWindow();
+      expect(mockWindow.hide).toHaveBeenCalled();
+    });
+
+    it('shows and focuses window when not focused', () => {
+      actions.focusWindow();
+      expect(mockWindow.show).toHaveBeenCalled();
+      expect(mockWindow.focus).toHaveBeenCalled();
+    });
+
+    it('restores minimized window', () => {
+      mockWindow.isMinimized.mockReturnValue(true);
+      actions.focusWindow();
+      expect(mockWindow.restore).toHaveBeenCalled();
+    });
+
+    it('does nothing when no window set', () => {
+      actions.setMainWindow(null);
+      expect(() => actions.focusWindow()).not.toThrow();
+    });
+  });
+
+  describe('copyQuickClip', () => {
+    it('copies text clip to clipboard', async () => {
+      vi.mocked(storage.getClips).mockResolvedValue([
+        { clip: { type: 'text', content: 'hello' }, isLocked: false, timestamp: 1 },
+      ]);
+      await actions.copyQuickClip(0);
+      expect(clipboard.writeText).toHaveBeenCalledWith('hello');
+    });
+
+    it('copies html clip to clipboard', async () => {
+      vi.mocked(storage.getClips).mockResolvedValue([
+        { clip: { type: 'html', content: '<p>hi</p>' }, isLocked: false, timestamp: 1 },
+      ]);
+      await actions.copyQuickClip(0);
+      expect(clipboard.writeHTML).toHaveBeenCalledWith('<p>hi</p>');
+    });
+
+    it('does nothing when index out of range', async () => {
+      vi.mocked(storage.getClips).mockResolvedValue([]);
+      await actions.copyQuickClip(5);
+      expect(clipboard.writeText).not.toHaveBeenCalled();
+    });
+
+    it('sends hotkey-clip-copied event to renderer', async () => {
+      vi.mocked(storage.getClips).mockResolvedValue([
+        { clip: { type: 'text', content: 'hello' }, isLocked: false, timestamp: 1 },
+      ]);
+      await actions.copyQuickClip(0);
+      expect(mockWindow.webContents.send).toHaveBeenCalledWith('hotkey-clip-copied', 0);
+    });
+
+    it('copies rtf clip to clipboard', async () => {
+      vi.mocked(storage.getClips).mockResolvedValue([
+        { clip: { type: 'rtf', content: '{\\rtf1 hello}' }, isLocked: false, timestamp: 1 },
+      ]);
+      await actions.copyQuickClip(0);
+      expect(clipboard.writeRTF).toHaveBeenCalledWith('{\\rtf1 hello}');
+    });
+
+    it('copies bookmark clip with title and url', async () => {
+      vi.mocked(storage.getClips).mockResolvedValue([
+        {
+          clip: {
+            type: 'bookmark',
+            content: 'Example',
+            title: 'Example',
+            url: 'https://example.com',
+          },
+          isLocked: false,
+          timestamp: 1,
+        },
+      ]);
+      await actions.copyQuickClip(0);
+      expect(clipboard.writeBookmark).toHaveBeenCalledWith('Example', 'https://example.com');
+    });
+
+    it('copies bookmark clip as text when missing title/url', async () => {
+      vi.mocked(storage.getClips).mockResolvedValue([
+        { clip: { type: 'bookmark', content: 'some content' }, isLocked: false, timestamp: 1 },
+      ]);
+      await actions.copyQuickClip(0);
+      expect(clipboard.writeText).toHaveBeenCalledWith('some content');
+    });
+
+    it('copies image clip to clipboard', async () => {
+      vi.mocked(nativeImage.createFromDataURL).mockReturnValue({
+        isEmpty: () => false,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } as any);
+      vi.mocked(storage.getClips).mockResolvedValue([
+        {
+          clip: { type: 'image', content: 'data:image/png;base64,abc' },
+          isLocked: false,
+          timestamp: 1,
+        },
+      ]);
+      await actions.copyQuickClip(0);
+      expect(clipboard.writeImage).toHaveBeenCalled();
+    });
+
+    it('falls back to text for empty image', async () => {
+      vi.mocked(nativeImage.createFromDataURL).mockReturnValue({
+        isEmpty: () => true,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } as any);
+      vi.mocked(storage.getClips).mockResolvedValue([
+        {
+          clip: { type: 'image', content: 'data:image/png;base64,abc' },
+          isLocked: false,
+          timestamp: 1,
+        },
+      ]);
+      await actions.copyQuickClip(0);
+      expect(clipboard.writeText).toHaveBeenCalledWith('data:image/png;base64,abc');
+    });
+
+    it('falls back to text when image copy throws', async () => {
+      vi.mocked(nativeImage.createFromDataURL).mockImplementation(() => {
+        throw new Error('bad image');
+      });
+      vi.mocked(storage.getClips).mockResolvedValue([
+        { clip: { type: 'image', content: 'bad-data' }, isLocked: false, timestamp: 1 },
+      ]);
+      await actions.copyQuickClip(0);
+      expect(clipboard.writeText).toHaveBeenCalledWith('bad-data');
+    });
+
+    it('copies unknown type as text', async () => {
+      vi.mocked(storage.getClips).mockResolvedValue([
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        { clip: { type: 'unknown' as any, content: 'fallback' }, isLocked: false, timestamp: 1 },
+      ]);
+      await actions.copyQuickClip(0);
+      expect(clipboard.writeText).toHaveBeenCalledWith('fallback');
+    });
+
+    it('does not send event when window is destroyed', async () => {
+      mockWindow.isDestroyed.mockReturnValue(true);
+      vi.mocked(storage.getClips).mockResolvedValue([
+        { clip: { type: 'text', content: 'hello' }, isLocked: false, timestamp: 1 },
+      ]);
+      await actions.copyQuickClip(0);
+      expect(mockWindow.webContents.send).not.toHaveBeenCalled();
+    });
+
+    it('handles storage error gracefully', async () => {
+      vi.mocked(storage.getClips).mockRejectedValue(new Error('fail'));
+      await expect(actions.copyQuickClip(0)).resolves.toBeUndefined();
+    });
+
+    it('handles null clip at valid index', async () => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const sparseClips = [null as any, { clip: { type: 'text', content: 'hello' } }];
+      vi.mocked(storage.getClips).mockResolvedValue(sparseClips);
+      await actions.copyQuickClip(0);
+      expect(clipboard.writeText).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('toggleSearchBar', () => {
+    it('sends toggle-search event', () => {
+      actions.toggleSearchBar();
+      expect(mockWindow.webContents.send).toHaveBeenCalledWith('toggle-search');
+    });
+
+    it('shows window if hidden', () => {
+      mockWindow.isVisible.mockReturnValue(false);
+      actions.toggleSearchBar();
+      expect(mockWindow.show).toHaveBeenCalled();
+    });
+
+    it('restores minimized window before toggling search', () => {
+      mockWindow.isVisible.mockReturnValue(true);
+      mockWindow.isMinimized.mockReturnValue(true);
+      actions.toggleSearchBar();
+      expect(mockWindow.restore).toHaveBeenCalled();
+      expect(mockWindow.webContents.send).toHaveBeenCalledWith('toggle-search');
+    });
+
+    it('does nothing when no window set', () => {
+      actions.setMainWindow(null);
+      expect(() => actions.toggleSearchBar()).not.toThrow();
+    });
+
+    it('handles error gracefully', () => {
+      mockWindow.isVisible.mockImplementation(() => {
+        throw new Error('error');
+      });
+      expect(() => actions.toggleSearchBar()).not.toThrow();
+    });
+  });
+
+  describe('focusWindow - additional', () => {
+    it('handles error gracefully', () => {
+      mockWindow.isVisible.mockImplementation(() => {
+        throw new Error('error');
+      });
+      expect(() => actions.focusWindow()).not.toThrow();
+    });
+
+    it('calls app.focus on macOS when showing window', () => {
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, 'platform', { value: 'darwin', writable: true });
+
+      mockWindow.isVisible.mockReturnValue(false);
+      mockWindow.isMinimized.mockReturnValue(false);
+
+      actions.focusWindow();
+
+      expect(app.focus).toHaveBeenCalled();
+
+      Object.defineProperty(process, 'platform', { value: originalPlatform, writable: true });
+    });
+  });
+
+  describe('toggleSearchBar - macOS', () => {
+    it('calls app.focus on macOS when showing window', () => {
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, 'platform', { value: 'darwin', writable: true });
+
+      mockWindow.isVisible.mockReturnValue(false);
+      mockWindow.isMinimized.mockReturnValue(false);
+
+      actions.toggleSearchBar();
+
+      expect(app.focus).toHaveBeenCalled();
+
+      Object.defineProperty(process, 'platform', { value: originalPlatform, writable: true });
+    });
+  });
+
+  describe('openToolsLauncher', () => {
+    it('opens tools launcher with first clip content', async () => {
+      vi.mocked(storage.getClips).mockResolvedValue([
+        { clip: { type: 'text', content: 'hello' }, isLocked: false, timestamp: 1 },
+      ]);
+
+      await actions.openToolsLauncher();
+
+      const { createToolsLauncherWindow } = await import('../window/creation.js');
+      expect(createToolsLauncherWindow).toHaveBeenCalledWith('hello');
+    });
+
+    it('does nothing when no clips available', async () => {
+      vi.mocked(storage.getClips).mockResolvedValue([]);
+      await expect(actions.openToolsLauncher()).resolves.toBeUndefined();
+    });
+
+    it('does nothing when first clip is null', async () => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      vi.mocked(storage.getClips).mockResolvedValue([null as any]);
+      await expect(actions.openToolsLauncher()).resolves.toBeUndefined();
+    });
+
+    it('handles error gracefully', async () => {
+      vi.mocked(storage.getClips).mockRejectedValue(new Error('fail'));
+      await expect(actions.openToolsLauncher()).resolves.toBeUndefined();
+    });
+  });
+});
diff --git a/src/main/hotkeys/actions.ts b/src/main/hotkeys/actions.ts
index eca9be2..93d2efd 100644
--- a/src/main/hotkeys/actions.ts
+++ b/src/main/hotkeys/actions.ts
@@ -1,6 +1,7 @@
-import { BrowserWindow, clipboard, nativeImage } from 'electron';
+import { BrowserWindow, clipboard, nativeImage, app } from 'electron';
 import { storage } from '../storage';
 import { showNotification } from '../notifications';
+import type { StoredClip } from '../../shared/types';
 
 /**
  * Handles all hotkey action implementations
@@ -35,7 +36,7 @@ export class HotkeyActions {
 
       // On macOS, we need to bring the app to front
       if (process.platform === 'darwin') {
-        require('electron').app.focus();
+        app.focus();
       }
     } catch (error) {
       console.error('Error toggling window visibility:', error);
@@ -77,7 +78,7 @@ export class HotkeyActions {
   /**
    * Copy a clip to the system clipboard based on its type
    */
-  private copyClipToClipboard(clipToCopy: any): void {
+  private copyClipToClipboard(clipToCopy: StoredClip): void {
     switch (clipToCopy.clip.type) {
       case 'text':
         clipboard.writeText(clipToCopy.clip.content);
@@ -135,7 +136,7 @@ export class HotkeyActions {
         this.mainWindow.show();
         this.mainWindow.focus();
         if (process.platform === 'darwin') {
-          require('electron').app.focus();
+          app.focus();
         }
       }
 
@@ -164,7 +165,7 @@ export class HotkeyActions {
 
       // Import the createToolsLauncherWindow function
       const { createToolsLauncherWindow } = await import('../window/creation.js');
-      
+
       // Open the tools launcher with the first clip's content
       createToolsLauncherWindow(firstClip.clip.content);
 
diff --git a/src/main/hotkeys/manager.test.ts b/src/main/hotkeys/manager.test.ts
new file mode 100644
index 0000000..cc9d9b2
--- /dev/null
+++ b/src/main/hotkeys/manager.test.ts
@@ -0,0 +1,325 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('electron', () => ({
+  BrowserWindow: vi.fn(),
+  globalShortcut: {
+    register: vi.fn().mockReturnValue(true),
+    unregister: vi.fn(),
+  },
+  clipboard: { writeText: vi.fn() },
+  nativeImage: { createFromDataURL: vi.fn() },
+}));
+
+vi.mock('../storage', () => ({
+  storage: {
+    getSettings: vi.fn(),
+    getClips: vi.fn().mockResolvedValue([]),
+  },
+}));
+
+vi.mock('../notifications', () => ({
+  showNotification: vi.fn(),
+}));
+
+import { HotkeyManager } from './manager';
+import { storage } from '../storage';
+import { globalShortcut } from 'electron';
+
+describe('HotkeyManager', () => {
+  let manager: HotkeyManager;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    manager = new HotkeyManager();
+  });
+
+  it('initializes and registers hotkeys when enabled', async () => {
+    vi.mocked(storage.getSettings).mockResolvedValue({
+      maxClips: 100,
+      startMinimized: false,
+      autoStart: false,
+      hotkeys: {
+        enabled: true,
+        focusWindow: { enabled: true, key: 'Ctrl+Shift+V' },
+        quickClip1: { enabled: true, key: 'Ctrl+Shift+1' },
+        quickClip2: { enabled: false, key: 'Ctrl+Shift+2' },
+        quickClip3: { enabled: false, key: 'Ctrl+Shift+3' },
+        quickClip4: { enabled: false, key: 'Ctrl+Shift+4' },
+        quickClip5: { enabled: false, key: 'Ctrl+Shift+5' },
+        openToolsLauncher: { enabled: false, key: 'Ctrl+Shift+T' },
+        searchClips: { enabled: false, key: 'Ctrl+Shift+F' },
+      },
+    });
+
+    await manager.initialize();
+
+    expect(manager.isInitialized).toBe(true);
+    expect(globalShortcut.register).toHaveBeenCalledTimes(2); // focusWindow + quickClip1
+  });
+
+  it('does not register hotkeys when disabled', async () => {
+    vi.mocked(storage.getSettings).mockResolvedValue({
+      maxClips: 100,
+      startMinimized: false,
+      autoStart: false,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      hotkeys: { enabled: false } as any,
+    });
+
+    await manager.initialize();
+
+    expect(globalShortcut.register).not.toHaveBeenCalled();
+  });
+
+  it('does not initialize twice', async () => {
+    vi.mocked(storage.getSettings).mockResolvedValue({
+      maxClips: 100,
+      startMinimized: false,
+      autoStart: false,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      hotkeys: { enabled: false } as any,
+    });
+
+    await manager.initialize();
+    await manager.initialize();
+
+    expect(storage.getSettings).toHaveBeenCalledTimes(1);
+  });
+
+  it('re-registers hotkeys on settings change', async () => {
+    vi.mocked(storage.getSettings).mockResolvedValue({
+      maxClips: 100,
+      startMinimized: false,
+      autoStart: false,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      hotkeys: { enabled: false } as any,
+    });
+
+    await manager.initialize();
+    await manager.onSettingsChanged();
+
+    expect(storage.getSettings).toHaveBeenCalledTimes(2);
+  });
+
+  it('cleanup resets state', async () => {
+    vi.mocked(storage.getSettings).mockResolvedValue({
+      maxClips: 100,
+      startMinimized: false,
+      autoStart: false,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      hotkeys: { enabled: false } as any,
+    });
+
+    await manager.initialize();
+    manager.cleanup();
+
+    expect(manager.isInitialized).toBe(false);
+  });
+
+  it('handles registerHotkeys error gracefully during initialization', async () => {
+    vi.mocked(storage.getSettings).mockRejectedValue(new Error('settings fail'));
+
+    await manager.initialize();
+
+    // registerHotkeys catches its own error, so initialization still completes
+    expect(manager.isInitialized).toBe(true);
+  });
+
+  it('onSettingsChanged initializes when not yet initialized', async () => {
+    vi.mocked(storage.getSettings).mockResolvedValue({
+      maxClips: 100,
+      startMinimized: false,
+      autoStart: false,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      hotkeys: { enabled: false } as any,
+    });
+
+    await manager.onSettingsChanged();
+
+    expect(manager.isInitialized).toBe(true);
+  });
+
+  it('onSettingsChanged handles error gracefully', async () => {
+    // First initialize successfully
+    vi.mocked(storage.getSettings).mockResolvedValue({
+      maxClips: 100,
+      startMinimized: false,
+      autoStart: false,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      hotkeys: { enabled: false } as any,
+    });
+    await manager.initialize();
+
+    // Then fail on re-register
+    vi.mocked(storage.getSettings).mockRejectedValue(new Error('fail'));
+    await expect(manager.onSettingsChanged()).resolves.toBeUndefined();
+  });
+
+  it('registers tools launcher and search hotkeys', async () => {
+    vi.mocked(storage.getSettings).mockResolvedValue({
+      maxClips: 100,
+      startMinimized: false,
+      autoStart: false,
+      hotkeys: {
+        enabled: true,
+        focusWindow: { enabled: false, key: 'Ctrl+Shift+V' },
+        quickClip1: { enabled: false, key: 'Ctrl+Shift+1' },
+        quickClip2: { enabled: false, key: 'Ctrl+Shift+2' },
+        quickClip3: { enabled: false, key: 'Ctrl+Shift+3' },
+        quickClip4: { enabled: false, key: 'Ctrl+Shift+4' },
+        quickClip5: { enabled: false, key: 'Ctrl+Shift+5' },
+        openToolsLauncher: { enabled: true, key: 'Ctrl+Shift+T' },
+        searchClips: { enabled: true, key: 'Ctrl+Shift+F' },
+      },
+    });
+
+    await manager.initialize();
+
+    expect(globalShortcut.register).toHaveBeenCalledTimes(2);
+  });
+
+  it('uses default tools launcher config when missing', async () => {
+    vi.mocked(storage.getSettings).mockResolvedValue({
+      maxClips: 100,
+      startMinimized: false,
+      autoStart: false,
+      hotkeys: {
+        enabled: true,
+        focusWindow: { enabled: false, key: 'Ctrl+Shift+V' },
+        quickClip1: { enabled: false, key: 'Ctrl+Shift+1' },
+        quickClip2: { enabled: false, key: 'Ctrl+Shift+2' },
+        quickClip3: { enabled: false, key: 'Ctrl+Shift+3' },
+        quickClip4: { enabled: false, key: 'Ctrl+Shift+4' },
+        quickClip5: { enabled: false, key: 'Ctrl+Shift+5' },
+        // openToolsLauncher and searchClips deliberately missing
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } as any,
+    });
+
+    await manager.initialize();
+
+    // Default configs have enabled: true so both should register
+    expect(globalShortcut.register).toHaveBeenCalledTimes(2);
+  });
+
+  it('getCurrentHotkeys returns registered hotkeys', async () => {
+    vi.mocked(storage.getSettings).mockResolvedValue({
+      maxClips: 100,
+      startMinimized: false,
+      autoStart: false,
+      hotkeys: {
+        enabled: true,
+        focusWindow: { enabled: true, key: 'Ctrl+Shift+V' },
+        quickClip1: { enabled: false, key: 'Ctrl+Shift+1' },
+        quickClip2: { enabled: false, key: 'Ctrl+Shift+2' },
+        quickClip3: { enabled: false, key: 'Ctrl+Shift+3' },
+        quickClip4: { enabled: false, key: 'Ctrl+Shift+4' },
+        quickClip5: { enabled: false, key: 'Ctrl+Shift+5' },
+        openToolsLauncher: { enabled: false, key: 'Ctrl+Shift+T' },
+        searchClips: { enabled: false, key: 'Ctrl+Shift+F' },
+      },
+    });
+
+    await manager.initialize();
+
+    expect(manager.getCurrentHotkeys()).toContain('Ctrl+Shift+V');
+    expect(manager.isHotkeyRegistered('Ctrl+Shift+V')).toBe(true);
+  });
+
+  it('setMainWindow sets window on actions', () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const mockWindow = {} as any;
+    expect(() => manager.setMainWindow(mockWindow)).not.toThrow();
+  });
+
+  it('handles error in initialize when setInitialized throws', async () => {
+    vi.mocked(storage.getSettings).mockResolvedValue({
+      maxClips: 100,
+      startMinimized: false,
+      autoStart: false,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      hotkeys: { enabled: false } as any,
+    });
+
+    // Access the private registry to make setInitialized throw
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const registry = (manager as any).registry;
+    const origSetInit = registry.setInitialized.bind(registry);
+    registry.setInitialized = vi.fn().mockImplementation(() => {
+      throw new Error('setInitialized fail');
+    });
+
+    const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    await manager.initialize();
+    spy.mockRestore();
+
+    // Restore
+    registry.setInitialized = origSetInit;
+  });
+
+  it('handles error in onSettingsChanged when registerHotkeys throws', async () => {
+    vi.mocked(storage.getSettings).mockResolvedValue({
+      maxClips: 100,
+      startMinimized: false,
+      autoStart: false,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      hotkeys: { enabled: false } as any,
+    });
+    await manager.initialize();
+
+    // Make registerHotkeys throw by overriding unregisterAllHotkeys to throw outside inner try
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const origMethod = (manager as any).registerHotkeys.bind(manager);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (manager as any).registerHotkeys = vi.fn().mockRejectedValue(new Error('register fail'));
+
+    const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    await manager.onSettingsChanged();
+    spy.mockRestore();
+
+    // Restore
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (manager as any).registerHotkeys = origMethod;
+  });
+
+  it('registerQuickClipHotkeys handles undefined hotkeys', async () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (manager as any).registerQuickClipHotkeys(undefined);
+    // Should not throw and should not register any hotkeys
+    expect(globalShortcut.register).not.toHaveBeenCalled();
+  });
+
+  it('registered hotkey callbacks are callable', async () => {
+    const callbacks: Record<string, (...args: unknown[]) => unknown> = {};
+    vi.mocked(globalShortcut.register).mockImplementation(
+      (acc: string, cb: (...args: unknown[]) => unknown) => {
+        callbacks[acc] = cb;
+        return true;
+      }
+    );
+
+    vi.mocked(storage.getSettings).mockResolvedValue({
+      maxClips: 100,
+      startMinimized: false,
+      autoStart: false,
+      hotkeys: {
+        enabled: true,
+        focusWindow: { enabled: true, key: 'Ctrl+Shift+V' },
+        quickClip1: { enabled: true, key: 'Ctrl+Shift+1' },
+        quickClip2: { enabled: false, key: 'Ctrl+Shift+2' },
+        quickClip3: { enabled: false, key: 'Ctrl+Shift+3' },
+        quickClip4: { enabled: false, key: 'Ctrl+Shift+4' },
+        quickClip5: { enabled: false, key: 'Ctrl+Shift+5' },
+        openToolsLauncher: { enabled: true, key: 'Ctrl+Shift+T' },
+        searchClips: { enabled: true, key: 'Ctrl+Shift+F' },
+      },
+    });
+
+    await manager.initialize();
+
+    // Invoke each registered callback to cover the callback body lines
+    for (const cb of Object.values(callbacks)) {
+      cb();
+    }
+  });
+});
diff --git a/src/main/hotkeys/manager.ts b/src/main/hotkeys/manager.ts
index 0f9900d..f11decc 100644
--- a/src/main/hotkeys/manager.ts
+++ b/src/main/hotkeys/manager.ts
@@ -2,6 +2,7 @@ import { BrowserWindow } from 'electron';
 import { storage } from '../storage';
 import { HotkeyRegistry } from './registry';
 import { HotkeyActions } from './actions';
+import type { UserSettings } from '../../shared/types';
 
 /**
  * Main hotkey manager that coordinates registration and actions
@@ -63,8 +64,8 @@ export class HotkeyManager {
     }
   }
 
-  private registerFocusWindowHotkey(hotkeys: any): void {
-    if (hotkeys.focusWindow.enabled) {
+  private registerFocusWindowHotkey(hotkeys: UserSettings['hotkeys']): void {
+    if (hotkeys?.focusWindow.enabled) {
       console.log(
         `Hotkey Manager: Attempting to register focus window hotkey: ${hotkeys.focusWindow.key}`
       );
@@ -74,8 +75,10 @@ export class HotkeyManager {
     }
   }
 
-  private registerQuickClipHotkeys(hotkeys: any): void {
+  private registerQuickClipHotkeys(hotkeys: UserSettings['hotkeys']): void {
     // Note: Quick clip hotkeys copy clips by their display number (1-5)
+    if (!hotkeys) return;
+
     const quickClipHotkeys = [
       { config: hotkeys.quickClip1, index: 0 }, // Copy 1st clip (position 1)
       { config: hotkeys.quickClip2, index: 1 }, // Copy 2nd clip (position 2)
@@ -96,9 +99,9 @@ export class HotkeyManager {
     }
   }
 
-  private registerToolsLauncherHotkey(hotkeys: any): void {
+  private registerToolsLauncherHotkey(hotkeys: UserSettings['hotkeys']): void {
     // Handle case where openToolsLauncher setting doesn't exist yet (new feature)
-    const toolsLauncherConfig = hotkeys.openToolsLauncher || {
+    const toolsLauncherConfig = hotkeys?.openToolsLauncher || {
       enabled: true,
       key: 'CommandOrControl+Shift+T',
     };
@@ -113,8 +116,8 @@ export class HotkeyManager {
     }
   }
 
-  private registerSearchHotkey(hotkeys: any): void {
-    const searchConfig = hotkeys.searchClips || {
+  private registerSearchHotkey(hotkeys: UserSettings['hotkeys']): void {
+    const searchConfig = hotkeys?.searchClips || {
       enabled: true,
       key: 'CommandOrControl+Shift+F',
     };
diff --git a/src/main/hotkeys/registry.test.ts b/src/main/hotkeys/registry.test.ts
new file mode 100644
index 0000000..63b51cf
--- /dev/null
+++ b/src/main/hotkeys/registry.test.ts
@@ -0,0 +1,102 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('electron', () => ({
+  globalShortcut: {
+    register: vi.fn().mockReturnValue(true),
+    unregister: vi.fn(),
+  },
+}));
+
+import { HotkeyRegistry } from './registry';
+import { globalShortcut } from 'electron';
+
+describe('HotkeyRegistry', () => {
+  let registry: HotkeyRegistry;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    registry = new HotkeyRegistry();
+  });
+
+  describe('registerHotkey', () => {
+    it('registers a hotkey successfully', () => {
+      const callback = vi.fn();
+      const result = registry.registerHotkey('Ctrl+A', callback);
+      expect(result).toBe(true);
+      expect(globalShortcut.register).toHaveBeenCalledWith('Ctrl+A', callback);
+    });
+
+    it('returns false for duplicate registration', () => {
+      registry.registerHotkey('Ctrl+A', vi.fn());
+      const result = registry.registerHotkey('Ctrl+A', vi.fn());
+      expect(result).toBe(false);
+    });
+
+    it('returns false when globalShortcut fails', () => {
+      vi.mocked(globalShortcut.register).mockReturnValueOnce(false);
+      const result = registry.registerHotkey('Ctrl+A', vi.fn());
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('unregisterAllHotkeys', () => {
+    it('unregisters all registered hotkeys', () => {
+      registry.registerHotkey('Ctrl+A', vi.fn());
+      registry.registerHotkey('Ctrl+B', vi.fn());
+      registry.unregisterAllHotkeys();
+      expect(globalShortcut.unregister).toHaveBeenCalledTimes(2);
+      expect(registry.getCurrentHotkeys()).toEqual([]);
+    });
+  });
+
+  describe('getCurrentHotkeys', () => {
+    it('returns list of registered accelerators', () => {
+      registry.registerHotkey('Ctrl+A', vi.fn());
+      registry.registerHotkey('Ctrl+B', vi.fn());
+      expect(registry.getCurrentHotkeys()).toEqual(['Ctrl+A', 'Ctrl+B']);
+    });
+  });
+
+  describe('isHotkeyRegistered', () => {
+    it('returns true for registered hotkey', () => {
+      registry.registerHotkey('Ctrl+A', vi.fn());
+      expect(registry.isHotkeyRegistered('Ctrl+A')).toBe(true);
+    });
+
+    it('returns false for unregistered hotkey', () => {
+      expect(registry.isHotkeyRegistered('Ctrl+A')).toBe(false);
+    });
+  });
+
+  describe('cleanup', () => {
+    it('unregisters all hotkeys and resets initialization', () => {
+      registry.setInitialized(true);
+      registry.registerHotkey('Ctrl+A', vi.fn());
+      registry.cleanup();
+      expect(registry.isInitialized).toBe(false);
+      expect(registry.getCurrentHotkeys()).toEqual([]);
+    });
+  });
+
+  describe('error handling', () => {
+    it('returns false when globalShortcut.register throws', () => {
+      vi.mocked(globalShortcut.register).mockImplementationOnce(() => {
+        throw new Error('system error');
+      });
+      const result = registry.registerHotkey('Ctrl+Z', vi.fn());
+      expect(result).toBe(false);
+    });
+
+    it('continues unregistering when one hotkey throws', () => {
+      registry.registerHotkey('Ctrl+A', vi.fn());
+      registry.registerHotkey('Ctrl+B', vi.fn());
+
+      vi.mocked(globalShortcut.unregister).mockImplementationOnce(() => {
+        throw new Error('unregister error');
+      });
+
+      expect(() => registry.unregisterAllHotkeys()).not.toThrow();
+      expect(registry.getCurrentHotkeys()).toEqual([]);
+    });
+  });
+});
diff --git a/src/main/storage/file-operations.test.ts b/src/main/storage/file-operations.test.ts
new file mode 100644
index 0000000..4fb706e
--- /dev/null
+++ b/src/main/storage/file-operations.test.ts
@@ -0,0 +1,108 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('electron', () => ({
+  safeStorage: {
+    isEncryptionAvailable: vi.fn().mockReturnValue(true),
+    encryptString: vi.fn((str: string) => Buffer.from(str)),
+    decryptString: vi.fn((buf: Buffer) => buf.toString()),
+  },
+}));
+
+vi.mock('fs', () => ({
+  promises: {
+    writeFile: vi.fn().mockResolvedValue(undefined),
+    readFile: vi.fn(),
+    rename: vi.fn().mockResolvedValue(undefined),
+    unlink: vi.fn().mockResolvedValue(undefined),
+    access: vi.fn().mockResolvedValue(undefined),
+    mkdir: vi.fn().mockResolvedValue(undefined),
+  },
+}));
+
+import {
+  saveToFile,
+  loadFromFile,
+  ensureDataDirectory,
+  isEncryptionAvailable,
+} from './file-operations';
+import { safeStorage } from 'electron';
+import { promises as fs } from 'fs';
+
+describe('saveToFile', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('encrypts and writes data to file', async () => {
+    await saveToFile({ test: true }, '/path/data.enc');
+
+    expect(safeStorage.encryptString).toHaveBeenCalledWith(JSON.stringify({ test: true }, null, 2));
+    expect(fs.writeFile).toHaveBeenCalledWith('/path/data.enc.tmp', expect.any(Buffer));
+    expect(fs.rename).toHaveBeenCalledWith('/path/data.enc.tmp', '/path/data.enc');
+  });
+
+  it('cleans up temp file on error', async () => {
+    vi.mocked(fs.writeFile).mockRejectedValueOnce(new Error('write failed'));
+
+    await expect(saveToFile({ test: true }, '/path/data.enc')).rejects.toThrow('write failed');
+    expect(fs.unlink).toHaveBeenCalledWith('/path/data.enc.tmp');
+  });
+});
+
+describe('loadFromFile', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('reads and decrypts data from file', async () => {
+    const testData = { test: true };
+    const jsonStr = JSON.stringify(testData);
+    const buf = Buffer.from(jsonStr);
+    vi.mocked(fs.readFile).mockResolvedValue(buf);
+    vi.mocked(safeStorage.decryptString).mockReturnValue(jsonStr);
+
+    const result = await loadFromFile('/path/data.enc');
+    expect(result).toEqual(testData);
+  });
+
+  it('throws FILE_NOT_FOUND for missing file', async () => {
+    vi.mocked(fs.access).mockRejectedValueOnce(Object.assign(new Error(), { code: 'ENOENT' }));
+
+    await expect(loadFromFile('/path/data.enc')).rejects.toThrow('FILE_NOT_FOUND');
+  });
+});
+
+describe('ensureDataDirectory', () => {
+  it('creates directory recursively', async () => {
+    await ensureDataDirectory('/path/to/data');
+    expect(fs.mkdir).toHaveBeenCalledWith('/path/to/data', { recursive: true });
+  });
+});
+
+describe('isEncryptionAvailable', () => {
+  it('returns the result from safeStorage', () => {
+    expect(isEncryptionAvailable()).toBe(true);
+  });
+
+  it('returns false when encryption is not available', () => {
+    vi.mocked(safeStorage.isEncryptionAvailable).mockReturnValueOnce(false);
+    expect(isEncryptionAvailable()).toBe(false);
+  });
+});
+
+describe('loadFromFile - non-ENOENT error', () => {
+  it('throws original error for non-ENOENT errors', async () => {
+    vi.mocked(fs.access).mockResolvedValue(undefined);
+    vi.mocked(fs.readFile).mockRejectedValueOnce(new Error('decrypt failed'));
+
+    await expect(loadFromFile('/path/data.enc')).rejects.toThrow('decrypt failed');
+  });
+});
+
+describe('saveToFile - temp file cleanup ignores missing', () => {
+  it('ignores temp file unlink error before write', async () => {
+    vi.mocked(fs.unlink).mockRejectedValueOnce(new Error('no temp file'));
+    await saveToFile({ test: true }, '/path/data.enc');
+    expect(fs.writeFile).toHaveBeenCalled();
+  });
+});
diff --git a/src/main/storage/file-operations.ts b/src/main/storage/file-operations.ts
index 5bcb19a..f8f7869 100644
--- a/src/main/storage/file-operations.ts
+++ b/src/main/storage/file-operations.ts
@@ -4,7 +4,7 @@ import { promises as fs } from 'fs';
 /**
  * Save data to encrypted storage
  */
-export async function saveToFile(data: any, encryptedDataPath: string): Promise<void> {
+export async function saveToFile(data: unknown, encryptedDataPath: string): Promise<void> {
   const tempPath = encryptedDataPath + '.tmp';
 
   try {
@@ -42,7 +42,7 @@ export async function saveToFile(data: any, encryptedDataPath: string): Promise<
 /**
  * Load data from encrypted storage
  */
-export async function loadFromFile(encryptedDataPath: string): Promise<any> {
+export async function loadFromFile(encryptedDataPath: string): Promise<unknown> {
   try {
     // Check if encrypted file exists
     await fs.access(encryptedDataPath);
@@ -57,7 +57,7 @@ export async function loadFromFile(encryptedDataPath: string): Promise<any> {
     // Parse and return data
     return JSON.parse(jsonData);
   } catch (error) {
-    if ((error as any).code === 'ENOENT') {
+    if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
       // File doesn't exist
       throw new Error('FILE_NOT_FOUND');
     } else {
diff --git a/src/main/storage/index.ts b/src/main/storage/index.ts
index 4bcf087..8e13477 100644
--- a/src/main/storage/index.ts
+++ b/src/main/storage/index.ts
@@ -10,6 +10,7 @@ import type {
   Template,
   SearchTerm,
   QuickTool,
+  QuickClipsConfig,
 } from '../../shared/types';
 
 // Import utility modules
@@ -513,7 +514,7 @@ class SecureStorage {
   /**
    * Import configuration data in batch (more efficient than individual imports)
    */
-  async importQuickClipsConfig(config: any): Promise<void> {
+  async importQuickClipsConfig(config: QuickClipsConfig): Promise<void> {
     if (!this.isInitialized) {
       await this.initialize();
     }
@@ -548,7 +549,7 @@ class SecureStorage {
 
     // Add templates (backwards-compatible: missing templates array is fine)
     if (config.templates && Array.isArray(config.templates) && config.templates.length > 0) {
-      config.templates.forEach((template: any) => {
+      config.templates.forEach((template) => {
         if (template.id && template.name && template.content) {
           const newTemplate = {
             ...template,
diff --git a/src/main/storage/migration.test.ts b/src/main/storage/migration.test.ts
new file mode 100644
index 0000000..d1862a3
--- /dev/null
+++ b/src/main/storage/migration.test.ts
@@ -0,0 +1,122 @@
+import { describe, it, expect } from 'vitest';
+import { migrateData } from './migration';
+
+describe('migrateData', () => {
+  it('returns default structure for empty object', () => {
+    const result = migrateData({});
+    expect(result.clips).toEqual([]);
+    expect(result.settings).toBeDefined();
+    expect(result.templates).toEqual([]);
+    expect(result.searchTerms).toEqual([]);
+    expect(result.quickTools).toEqual([]);
+  });
+
+  it('preserves valid clips', () => {
+    const data = {
+      clips: [{ clip: { type: 'text', content: 'hello' }, isLocked: false, timestamp: 123 }],
+    };
+    const result = migrateData(data);
+    expect(result.clips).toHaveLength(1);
+    expect(result.clips[0].clip.content).toBe('hello');
+  });
+
+  it('filters out invalid clips', () => {
+    const data = {
+      clips: [
+        { clip: { type: 'text', content: 'valid' }, isLocked: false, timestamp: 123 },
+        { clip: { type: 123, content: 'invalid type' } },
+        { clip: null },
+        null,
+      ],
+    };
+    const result = migrateData(data);
+    expect(result.clips).toHaveLength(1);
+  });
+
+  it('merges settings with defaults', () => {
+    const data = {
+      settings: { maxClips: 50 },
+    };
+    const result = migrateData(data);
+    expect(result.settings.maxClips).toBe(50);
+    expect(result.settings.startMinimized).toBe(false);
+  });
+
+  it('preserves valid templates', () => {
+    const data = {
+      templates: [{ id: '1', name: 'T', content: 'c', createdAt: 1, updatedAt: 1, order: 0 }],
+    };
+    const result = migrateData(data);
+    expect(result.templates).toHaveLength(1);
+  });
+
+  it('filters invalid templates', () => {
+    const data = {
+      templates: [
+        { id: '1', name: 'T', content: 'c', createdAt: 1, updatedAt: 1, order: 0 },
+        { id: 123, name: 'Bad' },
+      ],
+    };
+    const result = migrateData(data);
+    expect(result.templates).toHaveLength(1);
+  });
+
+  it('preserves valid search terms', () => {
+    const data = {
+      searchTerms: [
+        { id: '1', name: 'S', pattern: '.*', enabled: true, createdAt: 1, updatedAt: 1, order: 0 },
+      ],
+    };
+    const result = migrateData(data);
+    expect(result.searchTerms).toHaveLength(1);
+  });
+
+  it('preserves valid quick tools', () => {
+    const data = {
+      quickTools: [
+        {
+          id: '1',
+          name: 'Tool',
+          url: 'https://example.com',
+          captureGroups: ['email'],
+          createdAt: 1,
+          updatedAt: 1,
+          order: 0,
+        },
+      ],
+    };
+    const result = migrateData(data);
+    expect(result.quickTools).toHaveLength(1);
+  });
+
+  it('preserves version string', () => {
+    const result = migrateData({ version: '2.0.0' });
+    expect(result.version).toBe('2.0.0');
+  });
+
+  it('handles non-array clips gracefully', () => {
+    const result = migrateData({ clips: 'not-an-array' });
+    expect(result.clips).toEqual([]);
+  });
+
+  it('handles null data properties gracefully', () => {
+    const result = migrateData({ clips: null, settings: null, templates: null });
+    expect(result.clips).toEqual([]);
+    expect(result.templates).toEqual([]);
+  });
+
+  it('returns default structure for null or non-object data', () => {
+    const nullResult = migrateData(null);
+    expect(nullResult.clips).toEqual([]);
+    expect(nullResult.settings).toBeDefined();
+
+    const undefinedResult = migrateData(undefined);
+    expect(undefinedResult.clips).toEqual([]);
+
+    const stringResult = migrateData('not-an-object');
+    expect(stringResult.clips).toEqual([]);
+
+    const numberResult = migrateData(42);
+    expect(numberResult.clips).toEqual([]);
+  });
+});
diff --git a/src/main/storage/migration.ts b/src/main/storage/migration.ts
index 45d79f5..c9def51 100644
--- a/src/main/storage/migration.ts
+++ b/src/main/storage/migration.ts
@@ -1,76 +1,114 @@
-import type { AppData } from '../../shared/types';
+import type { AppData, StoredClip, Template, SearchTerm, QuickTool } from '../../shared/types';
 import { DEFAULT_DATA, DEFAULT_SETTINGS } from './defaults';
 
 /**
  * Migrate data from older versions
  */
-export function migrateData(data: any): AppData {
+export function migrateData(data: unknown): AppData {
   // Start with default data
   const migratedData: AppData = { ...DEFAULT_DATA };
 
+  // Validate data structure
+  if (!data || typeof data !== 'object') {
+    return migratedData;
+  }
+
+  const dataObj = data as Record<string, unknown>;
+
   // Copy over valid clips
-  if (data.clips && Array.isArray(data.clips)) {
-    migratedData.clips = data.clips.filter(
-      (item: any) =>
-        item?.clip && typeof item.clip.type === 'string' && typeof item.clip.content === 'string'
+  if (dataObj.clips && Array.isArray(dataObj.clips)) {
+    migratedData.clips = dataObj.clips.filter(
+      (item: unknown): item is StoredClip =>
+        item !== null &&
+        typeof item === 'object' &&
+        'clip' in item &&
+        item.clip !== null &&
+        typeof item.clip === 'object' &&
+        'type' in item.clip &&
+        typeof item.clip.type === 'string' &&
+        'content' in item.clip &&
+        typeof item.clip.content === 'string'
     );
   }
 
   // Copy over valid settings
-  if (data.settings && typeof data.settings === 'object') {
+  if (dataObj.settings && typeof dataObj.settings === 'object') {
     migratedData.settings = {
       ...DEFAULT_SETTINGS,
-      ...data.settings,
+      ...dataObj.settings,
     };
   }
 
   // Copy over valid templates
-  if (data.templates && Array.isArray(data.templates)) {
-    migratedData.templates = data.templates.filter(
-      (template: any) =>
-        template &&
+  if (dataObj.templates && Array.isArray(dataObj.templates)) {
+    migratedData.templates = dataObj.templates.filter(
+      (template: unknown): template is Template =>
+        template !== null &&
+        typeof template === 'object' &&
+        'id' in template &&
         typeof template.id === 'string' &&
+        'name' in template &&
         typeof template.name === 'string' &&
+        'content' in template &&
         typeof template.content === 'string' &&
+        'createdAt' in template &&
         typeof template.createdAt === 'number' &&
+        'updatedAt' in template &&
         typeof template.updatedAt === 'number' &&
+        'order' in template &&
         typeof template.order === 'number'
     );
   }
 
   // Copy over valid search terms
-  if (data.searchTerms && Array.isArray(data.searchTerms)) {
-    migratedData.searchTerms = data.searchTerms.filter(
-      (searchTerm: any) =>
-        searchTerm &&
+  if (dataObj.searchTerms && Array.isArray(dataObj.searchTerms)) {
+    migratedData.searchTerms = dataObj.searchTerms.filter(
+      (searchTerm: unknown): searchTerm is SearchTerm =>
+        searchTerm !== null &&
+        typeof searchTerm === 'object' &&
+        'id' in searchTerm &&
         typeof searchTerm.id === 'string' &&
+        'name' in searchTerm &&
         typeof searchTerm.name === 'string' &&
+        'pattern' in searchTerm &&
         typeof searchTerm.pattern === 'string' &&
+        'enabled' in searchTerm &&
         typeof searchTerm.enabled === 'boolean' &&
+        'createdAt' in searchTerm &&
         typeof searchTerm.createdAt === 'number' &&
+        'updatedAt' in searchTerm &&
         typeof searchTerm.updatedAt === 'number' &&
+        'order' in searchTerm &&
         typeof searchTerm.order === 'number'
     );
   }
 
   // Copy over valid quick tools
-  if (data.quickTools && Array.isArray(data.quickTools)) {
-    migratedData.quickTools = data.quickTools.filter(
-      (quickTool: any) =>
-        quickTool &&
+  if (dataObj.quickTools && Array.isArray(dataObj.quickTools)) {
+    migratedData.quickTools = dataObj.quickTools.filter(
+      (quickTool: unknown): quickTool is QuickTool =>
+        quickTool !== null &&
+        typeof quickTool === 'object' &&
+        'id' in quickTool &&
         typeof quickTool.id === 'string' &&
+        'name' in quickTool &&
         typeof quickTool.name === 'string' &&
+        'url' in quickTool &&
         typeof quickTool.url === 'string' &&
+        'captureGroups' in quickTool &&
         Array.isArray(quickTool.captureGroups) &&
+        'createdAt' in quickTool &&
         typeof quickTool.createdAt === 'number' &&
+        'updatedAt' in quickTool &&
         typeof quickTool.updatedAt === 'number' &&
+        'order' in quickTool &&
         typeof quickTool.order === 'number'
     );
   }
 
   // Preserve version
-  if (data.version && typeof data.version === 'string') {
-    migratedData.version = data.version;
+  if (dataObj.version && typeof dataObj.version === 'string') {
+    migratedData.version = dataObj.version;
   }
 
   return migratedData;
diff --git a/src/main/storage/quick-tools.ts b/src/main/storage/quick-tools.ts
index a6503f4..008377f 100644
--- a/src/main/storage/quick-tools.ts
+++ b/src/main/storage/quick-tools.ts
@@ -55,7 +55,7 @@ export function reorderQuickToolsArray(quickTools: QuickTool[]): QuickTool[] {
 /**
  * Import configuration data for quick clips
  */
-export function processQuickClipsConfig(config: any): {
+export function processQuickClipsConfig(config: unknown): {
   searchTerms: SearchTerm[];
   quickTools: QuickTool[];
 } {
@@ -69,9 +69,11 @@ export function processQuickClipsConfig(config: any): {
     throw new Error('Invalid config format');
   }
 
+  const configObj = config as Record<string, unknown>;
+
   // Process search terms
-  if (config.searchTerms && Array.isArray(config.searchTerms)) {
-    for (const searchTermData of config.searchTerms) {
+  if (configObj.searchTerms && Array.isArray(configObj.searchTerms)) {
+    for (const searchTermData of configObj.searchTerms) {
       // Skip invalid entries
       if (!searchTermData || typeof searchTermData !== 'object') {
         continue;
@@ -93,8 +95,8 @@ export function processQuickClipsConfig(config: any): {
   }
 
   // Process quick tools
-  if (config.tools && Array.isArray(config.tools)) {
-    for (const toolData of config.tools) {
+  if (configObj.tools && Array.isArray(configObj.tools)) {
+    for (const toolData of configObj.tools) {
       // Skip invalid entries
       if (!toolData || typeof toolData !== 'object') {
         continue;
diff --git a/src/main/storage/search-terms.test.ts b/src/main/storage/search-terms.test.ts
new file mode 100644
index 0000000..683bbbb
--- /dev/null
+++ b/src/main/storage/search-terms.test.ts
@@ -0,0 +1,82 @@
+import { describe, it, expect } from 'vitest';
+import {
+  createSearchTermObject,
+  sortSearchTermsByOrder,
+  updateSearchTermObject,
+  reorderSearchTermsArray,
+  generateId,
+} from './search-terms';
+
+describe('createSearchTermObject', () => {
+  it('creates a search term with correct fields', () => {
+    const term = createSearchTermObject('Email', '(?<email>[\\w.]+@[\\w.]+)', 0);
+    expect(term.name).toBe('Email');
+    expect(term.pattern).toBe('(?<email>[\\w.]+@[\\w.]+)');
+    expect(term.order).toBe(0);
+    expect(term.enabled).toBe(true);
+    expect(typeof term.id).toBe('string');
+    expect(typeof term.createdAt).toBe('number');
+    expect(typeof term.updatedAt).toBe('number');
+  });
+});
+
+describe('sortSearchTermsByOrder', () => {
+  it('sorts search terms by order ascending', () => {
+    const terms = [
+      { id: '1', name: 'B', pattern: '', enabled: true, createdAt: 0, updatedAt: 0, order: 2 },
+      { id: '2', name: 'A', pattern: '', enabled: true, createdAt: 0, updatedAt: 0, order: 0 },
+      { id: '3', name: 'C', pattern: '', enabled: true, createdAt: 0, updatedAt: 0, order: 1 },
+    ];
+    const sorted = sortSearchTermsByOrder(terms);
+    expect(sorted.map((t) => t.name)).toEqual(['A', 'C', 'B']);
+  });
+
+  it('does not mutate the original array', () => {
+    const terms = [
+      { id: '1', name: 'B', pattern: '', enabled: true, createdAt: 0, updatedAt: 0, order: 1 },
+      { id: '2', name: 'A', pattern: '', enabled: true, createdAt: 0, updatedAt: 0, order: 0 },
+    ];
+    sortSearchTermsByOrder(terms);
+    expect(terms[0].name).toBe('B');
+  });
+});
+
+describe('generateId', () => {
+  it('returns a string', () => {
+    expect(typeof generateId()).toBe('string');
+  });
+});
+
+describe('updateSearchTermObject', () => {
+  it('updates fields and sets updatedAt', () => {
+    const original = {
+      id: '1',
+      name: 'Old',
+      pattern: '.*',
+      enabled: true,
+      createdAt: 1000,
+      updatedAt: 1000,
+      order: 0,
+    };
+    const updated = updateSearchTermObject(original, { name: 'New' });
+    expect(updated.name).toBe('New');
+    expect(updated.id).toBe('1');
+    expect(updated.updatedAt).toBeGreaterThan(1000);
+  });
+});
+
+describe('reorderSearchTermsArray', () => {
+  it('assigns sequential order values', () => {
+    const terms = [
+      { id: '1', name: 'A', pattern: '', enabled: true, createdAt: 0, updatedAt: 0, order: 5 },
+      { id: '2', name: 'B', pattern: '', enabled: true, createdAt: 0, updatedAt: 0, order: 10 },
+    ];
+    const result = reorderSearchTermsArray(terms);
+    expect(result[0].order).toBe(0);
+    expect(result[1].order).toBe(1);
+  });
+
+  it('handles empty array', () => {
+    expect(reorderSearchTermsArray([])).toEqual([]);
+  });
+});
diff --git a/src/main/storage/templates.test.ts b/src/main/storage/templates.test.ts
new file mode 100644
index 0000000..985282e
--- /dev/null
+++ b/src/main/storage/templates.test.ts
@@ -0,0 +1,179 @@
+import { describe, it, expect } from 'vitest';
+import {
+  createTemplateObject,
+  sortTemplatesByOrder,
+  extractTemplateTokens,
+  generateTextFromTemplate,
+  updateTemplateObject,
+  reorderTemplatesArray,
+  generateTemplateId,
+} from './templates';
+
+describe('createTemplateObject', () => {
+  it('creates a template with the correct fields', () => {
+    const template = createTemplateObject('Test', 'Hello {c1}', 0);
+    expect(template.name).toBe('Test');
+    expect(template.content).toBe('Hello {c1}');
+    expect(template.order).toBe(0);
+    expect(template.id).toMatch(/^template-/);
+    expect(typeof template.createdAt).toBe('number');
+    expect(typeof template.updatedAt).toBe('number');
+  });
+});
+
+describe('sortTemplatesByOrder', () => {
+  it('sorts templates by order ascending', () => {
+    const templates = [
+      { id: '1', name: 'B', content: '', createdAt: 0, updatedAt: 0, order: 2 },
+      { id: '2', name: 'A', content: '', createdAt: 0, updatedAt: 0, order: 0 },
+      { id: '3', name: 'C', content: '', createdAt: 0, updatedAt: 0, order: 1 },
+    ];
+    const sorted = sortTemplatesByOrder(templates);
+    expect(sorted.map((t) => t.name)).toEqual(['A', 'C', 'B']);
+  });
+
+  it('does not mutate the original array', () => {
+    const templates = [
+      { id: '1', name: 'B', content: '', createdAt: 0, updatedAt: 0, order: 2 },
+      { id: '2', name: 'A', content: '', createdAt: 0, updatedAt: 0, order: 0 },
+    ];
+    sortTemplatesByOrder(templates);
+    expect(templates[0].name).toBe('B');
+  });
+});
+
+describe('extractTemplateTokens', () => {
+  it('extracts positional tokens', () => {
+    const result = extractTemplateTokens('Hello {c1}, meet {c2}');
+    expect(result.positional).toEqual(['c1', 'c2']);
+    expect(result.named).toEqual([]);
+  });
+
+  it('extracts named tokens', () => {
+    const result = extractTemplateTokens('Dear {name}, your email is {email}');
+    expect(result.positional).toEqual([]);
+    expect(result.named).toEqual(['name', 'email']);
+  });
+
+  it('extracts both positional and named tokens', () => {
+    const result = extractTemplateTokens('{c1} by {author}');
+    expect(result.positional).toEqual(['c1']);
+    expect(result.named).toEqual(['author']);
+  });
+
+  it('deduplicates tokens', () => {
+    const result = extractTemplateTokens('{c1} and {c1} again');
+    expect(result.positional).toEqual(['c1']);
+  });
+
+  it('deduplicates named tokens', () => {
+    const result = extractTemplateTokens('{name} and {name} again');
+    expect(result.named).toEqual(['name']);
+  });
+
+  it('returns empty arrays for no tokens', () => {
+    const result = extractTemplateTokens('plain text');
+    expect(result.positional).toEqual([]);
+    expect(result.named).toEqual([]);
+  });
+});
+
+describe('generateTextFromTemplate', () => {
+  const makeTemplate = (content: string) => ({
+    id: '1',
+    name: 'Test',
+    content,
+    createdAt: 0,
+    updatedAt: 0,
+    order: 0,
+  });
+
+  it('replaces positional tokens with clip contents', () => {
+    const result = generateTextFromTemplate(makeTemplate('{c1} and {c2}'), ['hello', 'world']);
+    expect(result).toBe('hello and world');
+  });
+
+  it('replaces named tokens with captures', () => {
+    const result = generateTextFromTemplate(makeTemplate('Hi {name}'), [], { name: 'Alice' });
+    expect(result).toBe('Hi Alice');
+  });
+
+  it('replaces both positional and named tokens', () => {
+    const result = generateTextFromTemplate(makeTemplate('{c1} by {author}'), ['Book'], {
+      author: 'Bob',
+    });
+    expect(result).toBe('Book by Bob');
+  });
+
+  it('leaves unreplaced positional tokens intact', () => {
+    const result = generateTextFromTemplate(makeTemplate('{c1} and {c3}'), ['hello']);
+    expect(result).toBe('hello and {c3}');
+  });
+
+  it('leaves unreplaced named tokens intact', () => {
+    const result = generateTextFromTemplate(makeTemplate('Hi {name}'), []);
+    expect(result).toBe('Hi {name}');
+  });
+
+  it('uses 1-based indexing for clips', () => {
+    const result = generateTextFromTemplate(makeTemplate('{c1}'), ['first', 'second']);
+    expect(result).toBe('first');
+  });
+
+  it('handles no captures provided', () => {
+    const result = generateTextFromTemplate(makeTemplate('{c1} {name}'), ['hello']);
+    expect(result).toBe('hello {name}');
+  });
+
+  it('skips positional tokens during named capture replacement', () => {
+    const result = generateTextFromTemplate(makeTemplate('{c1} {name}'), ['clip1'], {
+      name: 'Alice',
+    });
+    expect(result).toBe('clip1 Alice');
+  });
+
+  it('leaves named token when capture key is missing', () => {
+    const result = generateTextFromTemplate(makeTemplate('{missing}'), [], { other: 'val' });
+    expect(result).toBe('{missing}');
+  });
+});
+
+describe('generateTemplateId', () => {
+  it('returns a string starting with template-', () => {
+    const id = generateTemplateId();
+    expect(id).toMatch(/^template-/);
+  });
+});
+
+describe('updateTemplateObject', () => {
+  it('updates fields and refreshes updatedAt', () => {
+    const original = {
+      id: '1',
+      name: 'Old',
+      content: 'test',
+      createdAt: 1000,
+      updatedAt: 1000,
+      order: 0,
+    };
+    const updated = updateTemplateObject(original, { name: 'New' });
+    expect(updated.name).toBe('New');
+    expect(updated.updatedAt).toBeGreaterThan(1000);
+    expect(updated.createdAt).toBe(1000);
+  });
+});
+
+describe('reorderTemplatesArray', () => {
+  it('assigns sequential order values', () => {
+    const templates = [
+      { id: '1', name: 'A', content: '', createdAt: 0, updatedAt: 0, order: 5 },
+      { id: '2', name: 'B', content: '', createdAt: 0, updatedAt: 0, order: 10 },
+    ];
+    const result = reorderTemplatesArray(templates);
+    expect(result[0].order).toBe(0);
+    expect(result[1].order).toBe(1);
+  });
+
+  it('handles empty array', () => {
+    expect(reorderTemplatesArray([])).toEqual([]);
+  });
+});
diff --git a/src/main/updater/index.ts b/src/main/updater/index.ts
index 625a071..2003e1e 100644
--- a/src/main/updater/index.ts
+++ b/src/main/updater/index.ts
@@ -1,18 +1,21 @@
-import { autoUpdater } from 'electron-updater';
+import { autoUpdater, type UpdateInfo } from 'electron-updater';
 import { is } from '@electron-toolkit/utils';
 
 // Helper function to check for updates with timeout and retry
-export async function checkForUpdatesWithRetry(retries = 2, timeout = 10000): Promise<any> {
+export async function checkForUpdatesWithRetry(
+  retries = 2,
+  timeout = 10000
+): Promise<UpdateInfo | null> {
   for (let attempt = 1; attempt <= retries; attempt++) {
     try {
       // Create a promise that resolves with auto-updater events
-      const updateCheckPromise = new Promise<any>((resolve, reject) => {
+      const updateCheckPromise = new Promise<UpdateInfo | null>((resolve, reject) => {
         const timeoutId = setTimeout(() => {
           reject(new Error('Update check timeout'));
         }, timeout);
 
         // Listen for update events
-        const onUpdateAvailable = (info: any) => {
+        const onUpdateAvailable = (info: UpdateInfo) => {
           clearTimeout(timeoutId);
           autoUpdater.off('update-available', onUpdateAvailable);
           autoUpdater.off('update-not-available', onUpdateNotAvailable);
@@ -20,7 +23,7 @@ export async function checkForUpdatesWithRetry(retries = 2, timeout = 10000): Pr
           resolve(info);
         };
 
-        const onUpdateNotAvailable = (_info: any) => {
+        const onUpdateNotAvailable = (_info: UpdateInfo) => {
           clearTimeout(timeoutId);
           autoUpdater.off('update-available', onUpdateAvailable);
           autoUpdater.off('update-not-available', onUpdateNotAvailable);
@@ -28,7 +31,7 @@ export async function checkForUpdatesWithRetry(retries = 2, timeout = 10000): Pr
           resolve(null); // No updates available
         };
 
-        const onError = (error: any) => {
+        const onError = (error: Error) => {
           clearTimeout(timeoutId);
           autoUpdater.off('update-available', onUpdateAvailable);
           autoUpdater.off('update-not-available', onUpdateNotAvailable);
diff --git a/src/main/window/creation.ts b/src/main/window/creation.ts
index c263a0b..12edfc8 100644
--- a/src/main/window/creation.ts
+++ b/src/main/window/creation.ts
@@ -1,4 +1,4 @@
-import { BrowserWindow, shell } from 'electron';
+import { BrowserWindow, shell, type BrowserWindowConstructorOptions } from 'electron';
 import { join } from 'path';
 import { is } from '@electron-toolkit/utils';
 import { createTray as createTrayIcon, getIsQuitting } from '../tray';
@@ -151,7 +151,7 @@ export function createToolsLauncherWindow(clipContent: string): void {
 
 export async function createWindow(): Promise<void> {
   // Create the browser window.
-  const windowOptions: any = {
+  const windowOptions: BrowserWindowConstructorOptions = {
     width: 900,
     height: 670,
     show: false,
diff --git a/src/preload/index.ts b/src/preload/index.ts
index 4ca1204..cf1c5f0 100644
--- a/src/preload/index.ts
+++ b/src/preload/index.ts
@@ -1,5 +1,16 @@
 import { contextBridge } from 'electron';
 import { electronAPI } from '@electron-toolkit/preload';
+import type {
+  BookmarkData,
+  ClipItem,
+  UserSettings,
+  StoredClip,
+  Template,
+  SearchTerm,
+  QuickTool,
+  PatternMatch,
+  QuickClipsConfig,
+} from '../shared/types';
 
 // Custom APIs for renderer
 const api = {
@@ -20,12 +31,12 @@ const api = {
   setClipboardRTF: (rtf: string) => electronAPI.ipcRenderer.invoke('set-clipboard-rtf', rtf),
   setClipboardImage: (imageData: string) =>
     electronAPI.ipcRenderer.invoke('set-clipboard-image', imageData),
-  setClipboardBookmark: (bookmarkData: any) =>
+  setClipboardBookmark: (bookmarkData: BookmarkData) =>
     electronAPI.ipcRenderer.invoke('set-clipboard-bookmark', bookmarkData),
   notifyClipCopied: (index: number) => electronAPI.ipcRenderer.invoke('notify-clip-copied', index),
   startClipboardMonitoring: () => electronAPI.ipcRenderer.invoke('start-clipboard-monitoring'),
   stopClipboardMonitoring: () => electronAPI.ipcRenderer.invoke('stop-clipboard-monitoring'),
-  onClipboardChanged: (callback: (clipData: any) => void) =>
+  onClipboardChanged: (callback: (clipData: ClipItem) => void) =>
     electronAPI.ipcRenderer.on('clipboard-changed', (_event, clipData) => callback(clipData)),
   removeClipboardListeners: () => electronAPI.ipcRenderer.removeAllListeners('clipboard-changed'),
   onHotkeyClipCopied: (callback: (clipIndex: number) => void) =>
@@ -36,9 +47,11 @@ const api = {
   openSettings: (tab?: string) => electronAPI.ipcRenderer.invoke('open-settings', tab),
   closeSettings: () => electronAPI.ipcRenderer.invoke('close-settings'),
   getSettings: () => electronAPI.ipcRenderer.invoke('get-settings'),
-  settingsChanged: (settings: any) => electronAPI.ipcRenderer.invoke('settings-changed', settings),
-  onSettingsUpdated: (callback: (settings: any) => void) => {
-    const listener = (_event: any, settings: any) => callback(settings);
+  settingsChanged: (settings: UserSettings) =>
+    electronAPI.ipcRenderer.invoke('settings-changed', settings),
+  onSettingsUpdated: (callback: (settings: UserSettings) => void) => {
+    const listener = (_event: Electron.IpcRendererEvent, settings: UserSettings) =>
+      callback(settings);
     electronAPI.ipcRenderer.on('settings-updated', listener);
     // Return a cleanup function that removes only this specific listener
     return () => electronAPI.ipcRenderer.removeListener('settings-updated', listener);
@@ -47,10 +60,10 @@ const api = {
 
   // Storage APIs
   storageGetClips: () => electronAPI.ipcRenderer.invoke('storage-get-clips'),
-  storageSaveClips: (clips: any[], lockedIndices: Record<number, boolean>) =>
+  storageSaveClips: (clips: StoredClip[], lockedIndices: Record<number, boolean>) =>
     electronAPI.ipcRenderer.invoke('storage-save-clips', clips, lockedIndices),
   storageGetSettings: () => electronAPI.ipcRenderer.invoke('storage-get-settings'),
-  storageSaveSettings: (settings: any) =>
+  storageSaveSettings: (settings: UserSettings) =>
     electronAPI.ipcRenderer.invoke('storage-save-settings', settings),
   storageGetStats: () => electronAPI.ipcRenderer.invoke('storage-get-stats'),
   storageExportData: () => electronAPI.ipcRenderer.invoke('storage-export-data'),
@@ -62,25 +75,26 @@ const api = {
   templatesGetAll: () => electronAPI.ipcRenderer.invoke('templates-get-all'),
   templatesCreate: (name: string, content: string) =>
     electronAPI.ipcRenderer.invoke('templates-create', name, content),
-  templatesUpdate: (id: string, updates: any) =>
+  templatesUpdate: (id: string, updates: Partial<Template>) =>
     electronAPI.ipcRenderer.invoke('templates-update', id, updates),
   templatesDelete: (id: string) => electronAPI.ipcRenderer.invoke('templates-delete', id),
-  templatesReorder: (templates: any[]) =>
+  templatesReorder: (templates: Template[]) =>
     electronAPI.ipcRenderer.invoke('templates-reorder', templates),
   templatesGenerateText: (
     templateId: string,
     clipContents: string[],
     captures?: Record<string, string>
-  ) => electronAPI.ipcRenderer.invoke('templates-generate-text', templateId, clipContents, captures),
+  ) =>
+    electronAPI.ipcRenderer.invoke('templates-generate-text', templateId, clipContents, captures),
 
   // Quick Clips - Search Terms APIs
   searchTermsGetAll: () => electronAPI.ipcRenderer.invoke('search-terms-get-all'),
   searchTermsCreate: (name: string, pattern: string) =>
     electronAPI.ipcRenderer.invoke('search-terms-create', name, pattern),
-  searchTermsUpdate: (id: string, updates: any) =>
+  searchTermsUpdate: (id: string, updates: Partial<SearchTerm>) =>
     electronAPI.ipcRenderer.invoke('search-terms-update', id, updates),
   searchTermsDelete: (id: string) => electronAPI.ipcRenderer.invoke('search-terms-delete', id),
-  searchTermsReorder: (searchTerms: any[]) =>
+  searchTermsReorder: (searchTerms: SearchTerm[]) =>
     electronAPI.ipcRenderer.invoke('search-terms-reorder', searchTerms),
   searchTermsTest: (pattern: string, testText: string) =>
     electronAPI.ipcRenderer.invoke('search-terms-test', pattern, testText),
@@ -89,20 +103,21 @@ const api = {
   quickToolsGetAll: () => electronAPI.ipcRenderer.invoke('quick-tools-get-all'),
   quickToolsCreate: (name: string, url: string, captureGroups: string[]) =>
     electronAPI.ipcRenderer.invoke('quick-tools-create', name, url, captureGroups),
-  quickToolsUpdate: (id: string, updates: any) =>
+  quickToolsUpdate: (id: string, updates: Partial<QuickTool>) =>
     electronAPI.ipcRenderer.invoke('quick-tools-update', id, updates),
   quickToolsDelete: (id: string) => electronAPI.ipcRenderer.invoke('quick-tools-delete', id),
-  quickToolsReorder: (tools: any[]) => electronAPI.ipcRenderer.invoke('quick-tools-reorder', tools),
+  quickToolsReorder: (tools: QuickTool[]) =>
+    electronAPI.ipcRenderer.invoke('quick-tools-reorder', tools),
   quickToolsValidateUrl: (url: string, captureGroups: string[]) =>
     electronAPI.ipcRenderer.invoke('quick-tools-validate-url', url, captureGroups),
 
   // Quick Clips - Scanning APIs
   quickClipsScanText: (text: string) =>
     electronAPI.ipcRenderer.invoke('quick-clips-scan-text', text),
-  quickClipsOpenTools: (matches: any[], toolIds: string[]) =>
+  quickClipsOpenTools: (matches: PatternMatch[], toolIds: string[]) =>
     electronAPI.ipcRenderer.invoke('quick-clips-open-tools', matches, toolIds),
   quickClipsExportConfig: () => electronAPI.ipcRenderer.invoke('quick-clips-export-config'),
-  quickClipsImportConfig: (config: any) =>
+  quickClipsImportConfig: (config: QuickClipsConfig) =>
     electronAPI.ipcRenderer.invoke('quick-clips-import-config', config),
   // Tools Launcher Window APIs
   openToolsLauncher: (clipContent: string) =>
diff --git a/src/renderer/src/ToolsLauncher.tsx b/src/renderer/src/ToolsLauncher.tsx
index a7543f4..2d86435 100644
--- a/src/renderer/src/ToolsLauncher.tsx
+++ b/src/renderer/src/ToolsLauncher.tsx
@@ -33,14 +33,16 @@ export default function ToolsLauncher(): React.JSX.Element {
   if (!isReady) {
     return (
       <ThemeProvider>
-        <div style={{ 
-          display: 'flex', 
-          justifyContent: 'center', 
-          alignItems: 'center', 
-          height: '100vh',
-          color: 'var(--text-color)',
-          backgroundColor: 'var(--background-color)'
-        }}>
+        <div
+          style={{
+            display: 'flex',
+            justifyContent: 'center',
+            alignItems: 'center',
+            height: '100vh',
+            color: 'var(--text-color)',
+            backgroundColor: 'var(--background-color)',
+          }}
+        >
           Loading...
         </div>
       </ThemeProvider>
@@ -50,11 +52,7 @@ export default function ToolsLauncher(): React.JSX.Element {
   return (
     <ThemeProvider>
       <div style={{ height: '100vh', overflow: 'hidden' }}>
-        <QuickClipsScanner
-          isOpen={true}
-          onClose={handleClose}
-          clipContent={clipContent}
-        />
+        <QuickClipsScanner isOpen={true} onClose={handleClose} clipContent={clipContent} />
       </div>
     </ThemeProvider>
   );
diff --git a/src/renderer/src/components/clips/QuickClipsScanner.tsx b/src/renderer/src/components/clips/QuickClipsScanner.tsx
index 73f6842..0a34df6 100644
--- a/src/renderer/src/components/clips/QuickClipsScanner.tsx
+++ b/src/renderer/src/components/clips/QuickClipsScanner.tsx
@@ -1,4 +1,4 @@
-import React, { useState, useEffect, useMemo } from 'react';
+import React, { useState, useEffect, useMemo, useCallback } from 'react';
 import classNames from 'classnames';
 import { PatternMatch, QuickTool, Template } from '../../../../shared/types';
 import { useTheme } from '../../providers/theme';
@@ -151,13 +151,13 @@ export function QuickClipsScanner({
     });
   };
 
-  const handleClose = () => {
+  const handleClose = useCallback(() => {
     if (onClose) {
       onClose();
     } else {
       window.api.closeToolsLauncher();
     }
-  };
+  }, [onClose]);
 
   // Add escape key listener
   useEffect(() => {
@@ -173,39 +173,9 @@ export function QuickClipsScanner({
     }
 
     return () => {};
-  }, [isOpen]);
-
-  // Scan the clip content when modal opens
-  useEffect(() => {
-    if (isOpen && clipContent) {
-      scanContent();
-    }
-  }, [isOpen, clipContent]);
-
-  // Load available tools and templates
-  useEffect(() => {
-    if (isOpen) {
-      loadTools();
-      loadTemplates();
-      setAccordionInitialized(false);
-    }
-  }, [isOpen]);
+  }, [isOpen, handleClose]);
 
-  // Update available tools when capture items change
-  useEffect(() => {
-    if (captureItems.length > 0 && tools.length > 0) {
-      updateAvailableTools();
-    }
-  }, [captureItems, tools, selectedCaptureItems]);
-
-  // Update matched templates when capture items change
-  useEffect(() => {
-    if (captureItems.length > 0 && templates.length > 0) {
-      updateMatchedTemplates();
-    }
-  }, [captureItems, templates, selectedCaptureItems]);
-
-  const scanContent = async () => {
+  const scanContent = useCallback(async () => {
     setLoading(true);
     try {
       const scanResults = await window.api.quickClipsScanText(clipContent);
@@ -237,9 +207,9 @@ export function QuickClipsScanner({
     } finally {
       setLoading(false);
     }
-  };
+  }, [clipContent]);
 
-  const loadTools = async () => {
+  const loadTools = useCallback(async () => {
     try {
       const loadedTools = await window.api.quickToolsGetAll();
       setTools(loadedTools);
@@ -247,9 +217,9 @@ export function QuickClipsScanner({
       console.error('Failed to load tools:', error);
       setTools([]);
     }
-  };
+  }, []);
 
-  const loadTemplates = async () => {
+  const loadTemplates = useCallback(async () => {
     try {
       const loadedTemplates = await window.api.templatesGetAll();
       setTemplates(loadedTemplates);
@@ -257,9 +227,9 @@ export function QuickClipsScanner({
       console.error('Failed to load templates:', error);
       setTemplates([]);
     }
-  };
+  }, []);
 
-  const updateAvailableTools = () => {
+  const updateAvailableTools = useCallback(() => {
     const selectedCaptureGroups = new Set<string>();
 
     captureItems.forEach((item) => {
@@ -276,9 +246,9 @@ export function QuickClipsScanner({
 
     const availableToolIds = new Set(compatibleTools.map((tool) => tool.id));
     setSelectedTools((prev) => new Set([...prev].filter((id) => availableToolIds.has(id))));
-  };
+  }, [captureItems, tools, selectedCaptureItems]);
 
-  const updateMatchedTemplates = () => {
+  const updateMatchedTemplates = useCallback(() => {
     const selectedCaptureGroups = new Set<string>();
 
     captureItems.forEach((item) => {
@@ -294,7 +264,37 @@ export function QuickClipsScanner({
     });
 
     setMatchedTemplates(compatible);
-  };
+  }, [captureItems, templates, selectedCaptureItems]);
+
+  // Scan the clip content when modal opens
+  useEffect(() => {
+    if (isOpen && clipContent) {
+      scanContent();
+    }
+  }, [isOpen, clipContent, scanContent]);
+
+  // Load available tools and templates
+  useEffect(() => {
+    if (isOpen) {
+      loadTools();
+      loadTemplates();
+      setAccordionInitialized(false);
+    }
+  }, [isOpen, loadTools, loadTemplates]);
+
+  // Update available tools when capture items change
+  useEffect(() => {
+    if (captureItems.length > 0 && tools.length > 0) {
+      updateAvailableTools();
+    }
+  }, [captureItems, tools, selectedCaptureItems, updateAvailableTools]);
+
+  // Update matched templates when capture items change
+  useEffect(() => {
+    if (captureItems.length > 0 && templates.length > 0) {
+      updateMatchedTemplates();
+    }
+  }, [captureItems, templates, selectedCaptureItems, updateMatchedTemplates]);
 
   const handleCaptureItemToggle = (uniqueKey: string) => {
     const newSelected = new Set(selectedCaptureItems);
@@ -327,7 +327,7 @@ export function QuickClipsScanner({
         });
 
       const storedClips = await window.api.storageGetClips();
-      const clipContents = storedClips.map((c: any) => c.clip?.content || '');
+      const clipContents = storedClips.map((c) => c.clip?.content || '');
 
       const generatedText = await window.api.templatesGenerateText(
         template.id,
@@ -396,12 +396,10 @@ export function QuickClipsScanner({
       <div
         className={classNames(styles.content, { [styles.light]: isLight })}
         style={{
-          flexDirection:
-            loading || (!showTwoColumns && !showClipTemplatesOnly) ? 'column' : 'row',
+          flexDirection: loading || (!showTwoColumns && !showClipTemplatesOnly) ? 'column' : 'row',
           justifyContent:
             loading || (!showTwoColumns && !showClipTemplatesOnly) ? 'center' : 'flex-start',
-          alignItems:
-            loading || (!showTwoColumns && !showClipTemplatesOnly) ? 'center' : 'stretch',
+          alignItems: loading || (!showTwoColumns && !showClipTemplatesOnly) ? 'center' : 'stretch',
         }}
       >
         {loading ? (
diff --git a/src/renderer/src/components/clips/clip/BookmarkClip.test.tsx b/src/renderer/src/components/clips/clip/BookmarkClip.test.tsx
new file mode 100644
index 0000000..15dad45
--- /dev/null
+++ b/src/renderer/src/components/clips/clip/BookmarkClip.test.tsx
@@ -0,0 +1,31 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import { BookmarkClip } from './BookmarkClip';
+
+vi.mock('../../../providers/theme', () => ({
+  useTheme: () => ({ isLight: false }),
+}));
+
+vi.mock('./Clip.module.css', () => ({
+  default: { typeLabel: 'typeLabel', light: 'light' },
+}));
+
+describe('BookmarkClip', () => {
+  it('renders bookmark label with title and url', () => {
+    const { container } = render(
+      <BookmarkClip
+        clip={{ type: 'bookmark', content: '', title: 'Example', url: 'https://example.com' }}
+      />
+    );
+    expect(screen.getByText('Bookmark:')).toBeInTheDocument();
+    expect(container.textContent).toContain('Example');
+    expect(container.textContent).toContain('https://example.com');
+  });
+
+  it('renders Untitled for missing title', () => {
+    const { container } = render(
+      <BookmarkClip clip={{ type: 'bookmark', content: '', url: 'https://example.com' }} />
+    );
+    expect(container.textContent).toContain('Untitled');
+  });
+});
diff --git a/src/renderer/src/components/clips/clip/HtmlClip.test.tsx b/src/renderer/src/components/clips/clip/HtmlClip.test.tsx
new file mode 100644
index 0000000..3ca3d03
--- /dev/null
+++ b/src/renderer/src/components/clips/clip/HtmlClip.test.tsx
@@ -0,0 +1,19 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import { HtmlClip } from './HtmlClip';
+
+vi.mock('../../../providers/theme', () => ({
+  useTheme: () => ({ isLight: false }),
+}));
+
+vi.mock('./Clip.module.css', () => ({
+  default: { typeLabel: 'typeLabel', light: 'light' },
+}));
+
+describe('HtmlClip', () => {
+  it('renders HTML label and content', () => {
+    render(<HtmlClip clip={{ type: 'html', content: '<p>Hello</p>' }} />);
+    expect(screen.getByText('HTML:')).toBeInTheDocument();
+    expect(screen.getByText('<p>Hello</p>')).toBeInTheDocument();
+  });
+});
diff --git a/src/renderer/src/components/clips/clip/ImageClip.test.tsx b/src/renderer/src/components/clips/clip/ImageClip.test.tsx
new file mode 100644
index 0000000..5d543f5
--- /dev/null
+++ b/src/renderer/src/components/clips/clip/ImageClip.test.tsx
@@ -0,0 +1,202 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { render, screen, fireEvent, cleanup } from '@testing-library/react';
+import { ImageClip } from './ImageClip';
+
+const { themeState } = vi.hoisted(() => ({
+  themeState: { isLight: false },
+}));
+
+vi.mock('../../../providers/theme', () => ({
+  useTheme: () => ({ isLight: themeState.isLight }),
+}));
+
+vi.mock('./Clip.module.css', () => ({
+  default: {
+    imagePreviewContainer: 'imagePreviewContainer',
+    imagePreview: 'imagePreview',
+    imagePopover: 'imagePopover',
+    popoverImage: 'popoverImage',
+    imageInfo: 'imageInfo',
+    imageFilename: 'imageFilename',
+    imageSize: 'imageSize',
+    light: 'light',
+  },
+}));
+
+describe('ImageClip', () => {
+  afterEach(() => {
+    cleanup();
+  });
+  it('renders image with correct src', () => {
+    render(<ImageClip clip={{ type: 'image', content: 'data:image/png;base64,abc123' }} />);
+    const images = screen.getAllByRole('img');
+    expect(images[0]).toHaveAttribute('src', 'data:image/png;base64,abc123');
+  });
+
+  it('displays image format', () => {
+    render(<ImageClip clip={{ type: 'image', content: 'data:image/png;base64,abc123' }} />);
+    const pngElements = screen.getAllByText(/PNG/);
+    expect(pngElements.length).toBeGreaterThan(0);
+  });
+
+  it('displays approximate file size', () => {
+    render(<ImageClip clip={{ type: 'image', content: 'data:image/png;base64,abc123' }} />);
+    const kbElements = screen.getAllByText(/KB/);
+    expect(kbElements.length).toBeGreaterThan(0);
+  });
+
+  it('displays Unknown format for non-data-url content', () => {
+    render(<ImageClip clip={{ type: 'image', content: 'not-a-data-url' }} />);
+    expect(screen.getByText(/Unknown format/)).toBeInTheDocument();
+  });
+
+  it('handles mouse enter and positions popover', () => {
+    const { container } = render(
+      <ImageClip clip={{ type: 'image', content: 'data:image/png;base64,abc123' }} />
+    );
+    const img = screen.getAllByRole('img')[0];
+
+    // Mock getBoundingClientRect
+    img.getBoundingClientRect = vi.fn().mockReturnValue({
+      top: 100,
+      left: 50,
+      right: 150,
+      bottom: 200,
+      width: 100,
+      height: 100,
+    });
+
+    // Mock viewport
+    Object.defineProperty(window, 'innerHeight', { value: 800, writable: true });
+    Object.defineProperty(window, 'innerWidth', { value: 1200, writable: true });
+
+    fireEvent.mouseEnter(img);
+
+    // Popover should have been positioned
+    const popover = container.querySelector('.imagePopover');
+    expect(popover).toBeTruthy();
+  });
+
+  it('positions popover to the left when right edge exceeded', () => {
+    const { container } = render(
+      <ImageClip clip={{ type: 'image', content: 'data:image/png;base64,abc123' }} />
+    );
+    const img = screen.getAllByRole('img')[0];
+
+    img.getBoundingClientRect = vi.fn().mockReturnValue({
+      top: 100,
+      left: 800,
+      right: 1180,
+      bottom: 200,
+      width: 100,
+      height: 100,
+    });
+
+    Object.defineProperty(window, 'innerHeight', { value: 800, writable: true });
+    Object.defineProperty(window, 'innerWidth', { value: 1200, writable: true });
+
+    fireEvent.mouseEnter(img);
+    const popover = container.querySelector('.imagePopover') as HTMLElement;
+    expect(popover?.style.left).toBeTruthy();
+  });
+
+  it('clamps popover to top edge', () => {
+    const { container } = render(
+      <ImageClip clip={{ type: 'image', content: 'data:image/png;base64,abc123' }} />
+    );
+    const img = screen.getAllByRole('img')[0];
+
+    img.getBoundingClientRect = vi.fn().mockReturnValue({
+      top: 10,
+      left: 50,
+      right: 150,
+      bottom: 110,
+      width: 100,
+      height: 100,
+    });
+
+    Object.defineProperty(window, 'innerHeight', { value: 800, writable: true });
+    Object.defineProperty(window, 'innerWidth', { value: 1200, writable: true });
+
+    fireEvent.mouseEnter(img);
+    const popover = container.querySelector('.imagePopover') as HTMLElement;
+    expect(popover?.style.top).toBe('16px');
+  });
+
+  it('clamps popover to bottom edge', () => {
+    const { container } = render(
+      <ImageClip clip={{ type: 'image', content: 'data:image/png;base64,abc123' }} />
+    );
+    const img = screen.getAllByRole('img')[0];
+
+    img.getBoundingClientRect = vi.fn().mockReturnValue({
+      top: 700,
+      left: 50,
+      right: 150,
+      bottom: 800,
+      width: 100,
+      height: 100,
+    });
+
+    Object.defineProperty(window, 'innerHeight', { value: 800, writable: true });
+    Object.defineProperty(window, 'innerWidth', { value: 1200, writable: true });
+
+    fireEvent.mouseEnter(img);
+    const popover = container.querySelector('.imagePopover') as HTMLElement;
+    // Should be clamped to viewport - popoverHeight - 16
+    expect(popover?.style.top).toBe(`${800 - 320 - 16}px`);
+  });
+
+  it('clamps popover to left edge when positioned left goes negative', () => {
+    const { container } = render(
+      <ImageClip clip={{ type: 'image', content: 'data:image/png;base64,abc123' }} />
+    );
+    const img = screen.getAllByRole('img')[0];
+
+    // right edge exceeds viewport width, left edge is very close to 0
+    img.getBoundingClientRect = vi.fn().mockReturnValue({
+      top: 100,
+      left: 5,
+      right: 1190,
+      bottom: 200,
+      width: 1185,
+      height: 100,
+    });
+
+    Object.defineProperty(window, 'innerHeight', { value: 800, writable: true });
+    Object.defineProperty(window, 'innerWidth', { value: 1200, writable: true });
+
+    fireEvent.mouseEnter(img);
+    const popover = container.querySelector('.imagePopover') as HTMLElement;
+    expect(popover?.style.left).toBe('16px');
+  });
+
+  it('handles image error and shows fallback text', () => {
+    themeState.isLight = false;
+    render(<ImageClip clip={{ type: 'image', content: 'data:image/png;base64,abc123' }} />);
+    const img = screen.getAllByRole('img')[0];
+
+    // Mock parentNode
+    const parent = document.createElement('div');
+    Object.defineProperty(img, 'parentNode', { value: parent, writable: true });
+
+    fireEvent.error(img);
+
+    expect(img.style.display).toBe('none');
+    expect(parent.querySelector('span')?.textContent).toBe('Invalid image data');
+  });
+
+  it('uses light theme color in error fallback', () => {
+    themeState.isLight = true;
+    render(<ImageClip clip={{ type: 'image', content: 'data:image/png;base64,abc123' }} />);
+    const img = screen.getAllByRole('img')[0];
+
+    const parent = document.createElement('div');
+    Object.defineProperty(img, 'parentNode', { value: parent, writable: true });
+
+    fireEvent.error(img);
+
+    const fallback = parent.querySelector('span');
+    expect(fallback?.style.color).toBe('rgb(102, 102, 102)');
+  });
+});
diff --git a/src/renderer/src/components/clips/clip/ImageClip.tsx b/src/renderer/src/components/clips/clip/ImageClip.tsx
index e528472..f8af930 100644
--- a/src/renderer/src/components/clips/clip/ImageClip.tsx
+++ b/src/renderer/src/components/clips/clip/ImageClip.tsx
@@ -14,6 +14,7 @@ export const ImageClip = ({ clip }: ImageClipProps) => {
 
   const handleImageMouseEnter = (e: React.MouseEvent<HTMLImageElement>) => {
     const popover = popoverRef.current;
+    /* istanbul ignore else -- @preserve */
     if (popover) {
       const rect = e.currentTarget.getBoundingClientRect();
       const viewportHeight = window.innerHeight;
diff --git a/src/renderer/src/components/clips/clip/TextClip.test.tsx b/src/renderer/src/components/clips/clip/TextClip.test.tsx
new file mode 100644
index 0000000..4377815
--- /dev/null
+++ b/src/renderer/src/components/clips/clip/TextClip.test.tsx
@@ -0,0 +1,385 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { render, screen, fireEvent, act, cleanup } from '@testing-library/react';
+import { TextClip } from './TextClip';
+
+let mockIsCodeDetectionEnabled = false;
+
+const { mockThemeState } = vi.hoisted(() => ({
+  mockThemeState: { isLight: false },
+}));
+
+// Mock providers
+vi.mock('../../../providers/theme', () => ({
+  useTheme: () => ({
+    isLight: mockThemeState.isLight,
+    isDark: !mockThemeState.isLight,
+    theme: mockThemeState.isLight ? 'light' : 'dark',
+    effectiveTheme: mockThemeState.isLight ? 'light' : 'dark',
+    setTheme: vi.fn(),
+  }),
+}));
+
+vi.mock('../../../providers/languageDetection', () => ({
+  useLanguageDetection: () => ({
+    isCodeDetectionEnabled: mockIsCodeDetectionEnabled,
+    settings: { codeDetectionEnabled: mockIsCodeDetectionEnabled },
+    updateSettings: vi.fn(),
+    detectTextLanguage: vi.fn(),
+  }),
+}));
+
+vi.mock('../../../utils/languageDetection', () => ({
+  mapToSyntaxHighlighterLanguage: vi.fn().mockReturnValue('javascript'),
+}));
+
+vi.mock('react-syntax-highlighter', () => ({
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Prism: ({ children, PreTag }: any) => {
+    const Tag = PreTag || 'pre';
+    return (
+      <Tag data-testid="syntax-highlighter" {...(typeof Tag !== 'string' ? {} : {})}>
+        {children}
+      </Tag>
+    );
+  },
+}));
+
+vi.mock('react-syntax-highlighter/dist/esm/styles/prism', () => ({
+  materialDark: {},
+  materialLight: {},
+}));
+
+vi.mock('./Clip.module.css', () => ({
+  default: {
+    editableText: 'editableText',
+    light: 'light',
+    emptyText: 'emptyText',
+    textEditorWrapper: 'textEditorWrapper',
+    textEditor: 'textEditor',
+    syntaxHighlightContainer: 'syntaxHighlightContainer',
+    syntaxOverlay: 'syntaxOverlay',
+  },
+}));
+
+describe('TextClip', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    mockIsCodeDetectionEnabled = false;
+    mockThemeState.isLight = false;
+  });
+
+  afterEach(() => {
+    cleanup();
+    vi.useRealTimers();
+  });
+
+  it('renders text content in display mode', () => {
+    render(<TextClip clip={{ type: 'text', content: 'Hello World' }} onUpdate={vi.fn()} />);
+    expect(screen.getByText('Hello World')).toBeInTheDocument();
+  });
+
+  it('renders (empty) for empty content', () => {
+    render(<TextClip clip={{ type: 'text', content: '' }} onUpdate={vi.fn()} />);
+    expect(screen.getByText('(empty)')).toBeInTheDocument();
+  });
+
+  it('does not enter edit mode for empty content', () => {
+    render(<TextClip clip={{ type: 'text', content: '' }} onUpdate={vi.fn()} />);
+    fireEvent.click(screen.getByText('(empty)'));
+    // Should still show (empty), not a textarea
+    expect(screen.getByText('(empty)')).toBeInTheDocument();
+  });
+
+  it('collapses multiline text to single line in display mode', () => {
+    render(<TextClip clip={{ type: 'text', content: 'line1\nline2\nline3' }} onUpdate={vi.fn()} />);
+    expect(screen.getByText('line1 line2 line3')).toBeInTheDocument();
+  });
+
+  it('enters edit mode on click and shows textarea', () => {
+    render(<TextClip clip={{ type: 'text', content: 'Hello World' }} onUpdate={vi.fn()} />);
+    fireEvent.click(screen.getByText('Hello World'));
+    expect(screen.getByRole('textbox')).toBeInTheDocument();
+  });
+
+  it('calls onEditingChange when entering and leaving edit mode', () => {
+    const onEditingChange = vi.fn();
+    render(
+      <TextClip
+        clip={{ type: 'text', content: 'Hello World' }}
+        onUpdate={vi.fn()}
+        onEditingChange={onEditingChange}
+      />
+    );
+    fireEvent.click(screen.getByText('Hello World'));
+    expect(onEditingChange).toHaveBeenCalledWith(true);
+
+    fireEvent.blur(screen.getByRole('textbox'));
+    expect(onEditingChange).toHaveBeenCalledWith(false);
+  });
+
+  it('calls onUpdate with debounce on text change', () => {
+    const onUpdate = vi.fn();
+    render(<TextClip clip={{ type: 'text', content: 'Hello' }} onUpdate={onUpdate} />);
+    fireEvent.click(screen.getByText('Hello'));
+
+    const textarea = screen.getByRole('textbox');
+    fireEvent.change(textarea, { target: { value: 'Hello World' } });
+
+    // Not called immediately
+    expect(onUpdate).not.toHaveBeenCalled();
+
+    // Called after debounce
+    act(() => {
+      vi.advanceTimersByTime(500);
+    });
+    expect(onUpdate).toHaveBeenCalledWith('Hello World');
+  });
+
+  it('clears previous debounce when typing rapidly', () => {
+    const onUpdate = vi.fn();
+    render(<TextClip clip={{ type: 'text', content: 'Hello' }} onUpdate={onUpdate} />);
+    fireEvent.click(screen.getByText('Hello'));
+
+    const textarea = screen.getByRole('textbox');
+    fireEvent.change(textarea, { target: { value: 'First' } });
+
+    // Advance partially
+    act(() => {
+      vi.advanceTimersByTime(200);
+    });
+
+    // Type again before debounce fires - this triggers clearTimeout branch
+    fireEvent.change(textarea, { target: { value: 'Second' } });
+
+    act(() => {
+      vi.advanceTimersByTime(500);
+    });
+
+    // Should only get the last value
+    expect(onUpdate).toHaveBeenCalledTimes(1);
+    expect(onUpdate).toHaveBeenCalledWith('Second');
+  });
+
+  it('does not call onUpdate when value unchanged', () => {
+    const onUpdate = vi.fn();
+    render(<TextClip clip={{ type: 'text', content: 'Hello' }} onUpdate={onUpdate} />);
+    fireEvent.click(screen.getByText('Hello'));
+
+    const textarea = screen.getByRole('textbox');
+    fireEvent.change(textarea, { target: { value: 'Hello' } });
+
+    act(() => {
+      vi.advanceTimersByTime(500);
+    });
+    expect(onUpdate).not.toHaveBeenCalled();
+  });
+
+  it('calls onUpdate immediately on blur with pending changes', () => {
+    const onUpdate = vi.fn();
+    render(<TextClip clip={{ type: 'text', content: 'Hello' }} onUpdate={onUpdate} />);
+    fireEvent.click(screen.getByText('Hello'));
+
+    const textarea = screen.getByRole('textbox');
+    fireEvent.change(textarea, { target: { value: 'Changed' } });
+    fireEvent.blur(textarea);
+
+    expect(onUpdate).toHaveBeenCalledWith('Changed');
+  });
+
+  it('handles Enter key to finish editing', () => {
+    const onUpdate = vi.fn();
+    render(<TextClip clip={{ type: 'text', content: 'Hello' }} onUpdate={onUpdate} />);
+    fireEvent.click(screen.getByText('Hello'));
+
+    const textarea = screen.getByRole('textbox');
+    fireEvent.change(textarea, { target: { value: 'Changed' } });
+    fireEvent.keyDown(textarea, { key: 'Enter', shiftKey: false });
+
+    expect(onUpdate).toHaveBeenCalledWith('Changed');
+  });
+
+  it('handles Escape key to cancel editing', () => {
+    const onUpdate = vi.fn();
+    const onEditingChange = vi.fn();
+    render(
+      <TextClip
+        clip={{ type: 'text', content: 'Hello' }}
+        onUpdate={onUpdate}
+        onEditingChange={onEditingChange}
+      />
+    );
+    fireEvent.click(screen.getByText('Hello'));
+
+    const textarea = screen.getByRole('textbox');
+    fireEvent.change(textarea, { target: { value: 'Changed' } });
+    fireEvent.keyDown(textarea, { key: 'Escape' });
+
+    // Should not call onUpdate (cancelled)
+    act(() => {
+      vi.advanceTimersByTime(500);
+    });
+    expect(onUpdate).not.toHaveBeenCalled();
+    expect(onEditingChange).toHaveBeenCalledWith(false);
+  });
+
+  it('renders syntax highlighter when code detection enabled and clip has language', () => {
+    mockIsCodeDetectionEnabled = true;
+    render(
+      <TextClip
+        clip={{ type: 'text', content: 'const x = 1;', isCode: true, language: 'javascript' }}
+        onUpdate={vi.fn()}
+      />
+    );
+    fireEvent.click(screen.getByText('const x = 1;'));
+
+    expect(screen.getByTestId('syntax-highlighter')).toBeInTheDocument();
+  });
+
+  it('updates syntax container height on text change', () => {
+    mockIsCodeDetectionEnabled = true;
+    render(
+      <TextClip
+        clip={{ type: 'text', content: 'const x = 1;', isCode: true, language: 'javascript' }}
+        onUpdate={vi.fn()}
+      />
+    );
+    fireEvent.click(screen.getByText('const x = 1;'));
+
+    const textarea = screen.getByRole('textbox');
+    fireEvent.change(textarea, { target: { value: 'const x = 2;\nconst y = 3;' } });
+
+    // The useEffect should have run and attempted to set height on syntax container
+    expect(screen.getByTestId('syntax-highlighter')).toBeInTheDocument();
+  });
+
+  it('renders plain textarea when code detection disabled', () => {
+    mockIsCodeDetectionEnabled = false;
+    render(
+      <TextClip
+        clip={{ type: 'text', content: 'const x = 1;', isCode: true, language: 'javascript' }}
+        onUpdate={vi.fn()}
+      />
+    );
+    fireEvent.click(screen.getByText('const x = 1;'));
+
+    expect(screen.queryByTestId('syntax-highlighter')).not.toBeInTheDocument();
+    expect(screen.getByRole('textbox')).toBeInTheDocument();
+  });
+
+  it('shows whitespace-only content as (empty)', () => {
+    render(<TextClip clip={{ type: 'text', content: '   ' }} onUpdate={vi.fn()} />);
+    expect(screen.getByText('(empty)')).toBeInTheDocument();
+  });
+
+  it('does not call onUpdate on blur when no pending changes', () => {
+    const onUpdate = vi.fn();
+    render(<TextClip clip={{ type: 'text', content: 'Hello' }} onUpdate={onUpdate} />);
+    fireEvent.click(screen.getByText('Hello'));
+
+    // Blur immediately without changing anything
+    fireEvent.blur(screen.getByRole('textbox'));
+
+    expect(onUpdate).not.toHaveBeenCalled();
+  });
+
+  it('does not call onUpdate on blur when pending change matches original', () => {
+    const onUpdate = vi.fn();
+    render(<TextClip clip={{ type: 'text', content: 'Hello' }} onUpdate={onUpdate} />);
+    fireEvent.click(screen.getByText('Hello'));
+
+    const textarea = screen.getByRole('textbox');
+    // Change then change back to original
+    fireEvent.change(textarea, { target: { value: 'Changed' } });
+    fireEvent.change(textarea, { target: { value: 'Hello' } });
+    // Blur with a pending debounce but editValue === clip.content
+    fireEvent.blur(textarea);
+
+    expect(onUpdate).not.toHaveBeenCalled();
+  });
+
+  it('handles Escape without onEditingChange callback', () => {
+    const onUpdate = vi.fn();
+    render(<TextClip clip={{ type: 'text', content: 'Hello' }} onUpdate={onUpdate} />);
+    fireEvent.click(screen.getByText('Hello'));
+
+    fireEvent.keyDown(screen.getByRole('textbox'), { key: 'Escape' });
+
+    // Should not throw, just exit edit mode
+    expect(screen.getByText('Hello')).toBeInTheDocument();
+  });
+
+  it('ignores non-special keys in keyDown handler', () => {
+    const onUpdate = vi.fn();
+    render(<TextClip clip={{ type: 'text', content: 'Hello' }} onUpdate={onUpdate} />);
+    fireEvent.click(screen.getByText('Hello'));
+
+    fireEvent.keyDown(screen.getByRole('textbox'), { key: 'a' });
+
+    // Should still be in edit mode, no update called
+    expect(screen.getByRole('textbox')).toBeInTheDocument();
+    expect(onUpdate).not.toHaveBeenCalled();
+  });
+
+  it('allows Shift+Enter without exiting edit mode', () => {
+    render(<TextClip clip={{ type: 'text', content: 'Hello' }} onUpdate={vi.fn()} />);
+    fireEvent.click(screen.getByText('Hello'));
+
+    fireEvent.keyDown(screen.getByRole('textbox'), { key: 'Enter', shiftKey: true });
+
+    // Should still be in edit mode
+    expect(screen.getByRole('textbox')).toBeInTheDocument();
+  });
+
+  it('handles Escape without pending debounce', () => {
+    const onUpdate = vi.fn();
+    render(<TextClip clip={{ type: 'text', content: 'Hello' }} onUpdate={onUpdate} />);
+    fireEvent.click(screen.getByText('Hello'));
+
+    // Press Escape without typing anything (no debounce pending)
+    fireEvent.keyDown(screen.getByRole('textbox'), { key: 'Escape' });
+
+    act(() => {
+      vi.advanceTimersByTime(500);
+    });
+    expect(onUpdate).not.toHaveBeenCalled();
+  });
+
+  describe('light theme', () => {
+    beforeEach(() => {
+      mockThemeState.isLight = true;
+    });
+
+    it('applies light class in display mode', () => {
+      render(<TextClip clip={{ type: 'text', content: 'Hello' }} onUpdate={vi.fn()} />);
+      expect(screen.getByText('Hello').className).toContain('light');
+    });
+
+    it('applies light class in plain edit mode', () => {
+      render(<TextClip clip={{ type: 'text', content: 'Hello' }} onUpdate={vi.fn()} />);
+      fireEvent.click(screen.getByText('Hello'));
+      expect(screen.getByRole('textbox').className).toContain('light');
+    });
+
+    it('applies light styles in syntax-highlighted edit mode', () => {
+      mockIsCodeDetectionEnabled = true;
+      render(
+        <TextClip
+          clip={{ type: 'text', content: 'const x = 1;', isCode: true, language: 'javascript' }}
+          onUpdate={vi.fn()}
+        />
+      );
+      fireEvent.click(screen.getByText('const x = 1;'));
+
+      const textarea = screen.getByRole('textbox');
+      expect(textarea.className).toContain('light');
+      expect(textarea.style.caretColor).toBe('#000');
+    });
+
+    it('applies light class to empty content display', () => {
+      render(<TextClip clip={{ type: 'text', content: '' }} onUpdate={vi.fn()} />);
+      const el = screen.getByText('(empty)');
+      expect(el.className).toContain('light');
+      expect(el.className).toContain('emptyText');
+    });
+  });
+});
diff --git a/src/renderer/src/components/clips/clip/TextClip.tsx b/src/renderer/src/components/clips/clip/TextClip.tsx
index 56498fa..3a981f6 100644
--- a/src/renderer/src/components/clips/clip/TextClip.tsx
+++ b/src/renderer/src/components/clips/clip/TextClip.tsx
@@ -33,7 +33,7 @@ export const TextClip = ({ clip, onUpdate, onEditingChange }: TextClipProps) =>
       textarea.style.height = newHeight;
 
       // Also update the syntax highlighter container if it exists
-      const container = textarea.parentElement?.querySelector('.syntaxHighlightContainer');
+      const container = textarea.closest(`.${styles.syntaxHighlightContainer}`);
       if (container) {
         (container as HTMLElement).style.height = newHeight;
       }
@@ -48,6 +48,7 @@ export const TextClip = ({ clip, onUpdate, onEditingChange }: TextClipProps) =>
       }
 
       debounceRef.current = setTimeout(() => {
+        /* istanbul ignore else -- @preserve */
         if (newContent !== clip.content) {
           onUpdate(newContent);
         }
diff --git a/src/renderer/src/components/settings/TemplateManager.tsx b/src/renderer/src/components/settings/TemplateManager.tsx
index ccdb818..6b07031 100644
--- a/src/renderer/src/components/settings/TemplateManager.tsx
+++ b/src/renderer/src/components/settings/TemplateManager.tsx
@@ -241,7 +241,7 @@ export function TemplateManager(): React.JSX.Element {
 
       {templates.length === 0 ? (
         <div className={classNames(styles.emptyState, { [styles.light]: isLight })}>
-          <p>No templates created yet. Click "Create Template" to get started.</p>
+          <p>No templates created yet. Click &quot;Create Template&quot; to get started.</p>
         </div>
       ) : (
         <div className={styles.templatesList}>
@@ -325,13 +325,17 @@ export function TemplateManager(): React.JSX.Element {
                   </div>
 
                   {expandedId === template.id && (
-                    <div className={classNames(styles.templateDetails, { [styles.light]: isLight })}>
+                    <div
+                      className={classNames(styles.templateDetails, { [styles.light]: isLight })}
+                    >
                       <pre
                         className={classNames(styles.templateContent, { [styles.light]: isLight })}
                       >
                         {template.content}
                       </pre>
-                      <div className={classNames(styles.templateFooter, { [styles.light]: isLight })}>
+                      <div
+                        className={classNames(styles.templateFooter, { [styles.light]: isLight })}
+                      >
                         <div className={styles.tokenPreview}>
                           <span
                             className={classNames(styles.tokenLabel, { [styles.light]: isLight })}
diff --git a/src/renderer/src/components/settings/UpdaterControl.tsx b/src/renderer/src/components/settings/UpdaterControl.tsx
index 6d9e84d..d9b92b3 100644
--- a/src/renderer/src/components/settings/UpdaterControl.tsx
+++ b/src/renderer/src/components/settings/UpdaterControl.tsx
@@ -114,7 +114,7 @@ function UpdaterControl(): React.JSX.Element {
 
       {/* Helper Text */}
       <p className={classNames(styles.helperText, { [styles.light]: isLight })}>
-        Updates are automatically downloaded. You'll be notified when a restart is required to
+        Updates are automatically downloaded. You&apos;ll be notified when a restart is required to
         complete the installation.
       </p>
     </div>
diff --git a/src/renderer/src/components/settings/hotkeys/HotkeyInstructions.tsx b/src/renderer/src/components/settings/hotkeys/HotkeyInstructions.tsx
index 735a5ea..3f18177 100644
--- a/src/renderer/src/components/settings/hotkeys/HotkeyInstructions.tsx
+++ b/src/renderer/src/components/settings/hotkeys/HotkeyInstructions.tsx
@@ -19,7 +19,7 @@ export const HotkeyInstructions: React.FC<HotkeyInstructionsProps> = ({ hotkeySe
     <div className={classNames(styles.instructions, { [styles.light]: isLight })}>
       <h3>Instructions:</h3>
       <ul>
-        <li>Click "Edit" next to any hotkey to change it</li>
+        <li>Click &quot;Edit&quot; next to any hotkey to change it</li>
         <li>Press the desired key combination (must include Ctrl/Cmd, Shift, or Alt)</li>
         <li>Press Escape to cancel editing</li>
         <li>Use the toggle switches to enable/disable individual hotkeys</li>
@@ -30,7 +30,7 @@ export const HotkeyInstructions: React.FC<HotkeyInstructionsProps> = ({ hotkeySe
       </p>
       <p className={styles.note}>
         <strong>Note:</strong> Hotkeys may conflict with other applications. Choose combinations
-        that aren't commonly used by your system or other software.
+        that aren&apos;t commonly used by your system or other software.
       </p>
     </div>
   );
diff --git a/src/renderer/src/components/settings/hotkeys/useHotkeyManager.ts b/src/renderer/src/components/settings/hotkeys/useHotkeyManager.ts
index 2403716..96f755d 100644
--- a/src/renderer/src/components/settings/hotkeys/useHotkeyManager.ts
+++ b/src/renderer/src/components/settings/hotkeys/useHotkeyManager.ts
@@ -1,4 +1,4 @@
-import { useState, useEffect } from 'react';
+import { useState, useEffect, useCallback } from 'react';
 import type { UserSettings, HotkeySettings } from '../../../../../shared/types';
 
 // Default hotkey configurations
@@ -86,32 +86,35 @@ export const useHotkeyManager = () => {
     loadSettings();
   }, []);
 
-  const saveSettings = async (newHotkeySettings: HotkeySettings) => {
-    if (!settings || !window.api) return false;
+  const saveSettings = useCallback(
+    async (newHotkeySettings: HotkeySettings) => {
+      if (!settings || !window.api) return false;
 
-    setSaving(true);
-    try {
-      const updatedSettings: UserSettings = {
-        ...settings,
-        hotkeys: newHotkeySettings,
-      };
-
-      // Use the settings-changed IPC to properly notify main process
-      const success = await window.api.settingsChanged(updatedSettings);
-
-      if (success) {
-        setSettings(updatedSettings);
-        setHotkeySettings(newHotkeySettings);
-        return true;
+      setSaving(true);
+      try {
+        const updatedSettings: UserSettings = {
+          ...settings,
+          hotkeys: newHotkeySettings,
+        };
+
+        // Use the settings-changed IPC to properly notify main process
+        const success = await window.api.settingsChanged(updatedSettings);
+
+        if (success) {
+          setSettings(updatedSettings);
+          setHotkeySettings(newHotkeySettings);
+          return true;
+        }
+        return false;
+      } catch (error) {
+        console.error('Failed to save hotkey settings:', error);
+        return false;
+      } finally {
+        setSaving(false);
       }
-      return false;
-    } catch (error) {
-      console.error('Failed to save hotkey settings:', error);
-      return false;
-    } finally {
-      setSaving(false);
-    }
-  };
+    },
+    [settings]
+  );
 
   const handleGlobalToggle = async (enabled: boolean) => {
     const updatedSettings = { ...hotkeySettings, enabled };
@@ -129,28 +132,28 @@ export const useHotkeyManager = () => {
     await saveSettings(updatedSettings);
   };
 
-  const handleHotkeyChange = async (
-    hotkeyKey: keyof Omit<HotkeySettings, 'enabled'>,
-    key: string
-  ) => {
-    const updatedSettings = {
-      ...hotkeySettings,
-      [hotkeyKey]: { ...hotkeySettings[hotkeyKey], key },
-    };
-    await saveSettings(updatedSettings);
-    setEditingHotkey(null);
-    setListeningForKey(false);
-  };
+  const handleHotkeyChange = useCallback(
+    async (hotkeyKey: keyof Omit<HotkeySettings, 'enabled'>, key: string) => {
+      const updatedSettings = {
+        ...hotkeySettings,
+        [hotkeyKey]: { ...hotkeySettings[hotkeyKey], key },
+      };
+      await saveSettings(updatedSettings);
+      setEditingHotkey(null);
+      setListeningForKey(false);
+    },
+    [hotkeySettings, saveSettings]
+  );
 
   const startKeyCapture = (hotkeyKey: string) => {
     setEditingHotkey(hotkeyKey);
     setListeningForKey(true);
   };
 
-  const cancelKeyCapture = () => {
+  const cancelKeyCapture = useCallback(() => {
     setEditingHotkey(null);
     setListeningForKey(false);
-  };
+  }, []);
 
   // Handle key capture
   useEffect(() => {
@@ -199,7 +202,7 @@ export const useHotkeyManager = () => {
     return () => {
       document.removeEventListener('keydown', handleKeyDown, true);
     };
-  }, [listeningForKey, editingHotkey]);
+  }, [listeningForKey, editingHotkey, handleHotkeyChange, cancelKeyCapture]);
 
   return {
     settings,
diff --git a/src/renderer/src/components/settings/quickclips/SearchTermsSection.tsx b/src/renderer/src/components/settings/quickclips/SearchTermsSection.tsx
index f615594..db4accd 100644
--- a/src/renderer/src/components/settings/quickclips/SearchTermsSection.tsx
+++ b/src/renderer/src/components/settings/quickclips/SearchTermsSection.tsx
@@ -65,8 +65,7 @@ interface SearchTermsSectionProps {
   onExpandedSearchTermIdChange: (id: string | null) => void;
 }
 
-const SAMPLE_TEXT =
-  'The quick brown fox jumps over the lazy dog. Hello world! Test 123 abc xyz.';
+const SAMPLE_TEXT = 'The quick brown fox jumps over the lazy dog. Hello world! Test 123 abc xyz.';
 
 function validatePattern(pattern: string): string | null {
   if (!pattern.trim()) {
diff --git a/src/renderer/src/components/settings/quickclips/ToolsSection.tsx b/src/renderer/src/components/settings/quickclips/ToolsSection.tsx
index aa5ee4a..360fb60 100644
--- a/src/renderer/src/components/settings/quickclips/ToolsSection.tsx
+++ b/src/renderer/src/components/settings/quickclips/ToolsSection.tsx
@@ -87,7 +87,7 @@ export function ToolsSection({
 
       {tools.length === 0 ? (
         <div className={classNames(styles.emptyState, { [styles.light]: isLight })}>
-          <p>No tools created yet. Click "Create Tool" to get started.</p>
+          <p>No tools created yet. Click &quot;Create Tool&quot; to get started.</p>
         </div>
       ) : (
         <div className={styles.itemsList}>
diff --git a/src/renderer/src/components/settings/quickclips/types.ts b/src/renderer/src/components/settings/quickclips/types.ts
index f82fb11..7f6fed5 100644
--- a/src/renderer/src/components/settings/quickclips/types.ts
+++ b/src/renderer/src/components/settings/quickclips/types.ts
@@ -1,4 +1,4 @@
-import { SearchTerm, QuickTool } from '../../../../../shared/types';
+import { SearchTerm, QuickTool, PatternMatch } from '../../../../../shared/types';
 
 export type TabType = 'searchTerms' | 'tools' | 'templates' | 'test';
 
@@ -28,7 +28,7 @@ export interface QuickClipsState {
 
   // Test state
   testText: string;
-  testResults: any[];
+  testResults: PatternMatch[];
 
   // Common state
   deleteConfirm: DeleteConfirmState;
@@ -41,7 +41,7 @@ export interface QuickClipsActions {
 
   // Search Terms actions
   handleCreateSearchTerm: () => Promise<void>;
-  handleCreateFromBuiltin: (builtin: any) => Promise<void>;
+  handleCreateFromBuiltin: (builtin: SearchTerm) => Promise<void>;
   handleSaveSearchTerm: () => Promise<void>;
   handleCancelSearchTermEdit: () => void;
   handleStartSearchTermEdit: (term: SearchTerm) => void;
diff --git a/src/renderer/src/components/settings/usersettings/ApplicationSettings.tsx b/src/renderer/src/components/settings/usersettings/ApplicationSettings.tsx
index 2621031..0580f38 100644
--- a/src/renderer/src/components/settings/usersettings/ApplicationSettings.tsx
+++ b/src/renderer/src/components/settings/usersettings/ApplicationSettings.tsx
@@ -8,7 +8,7 @@ import styles from '../StorageSettings.module.css';
 
 interface ApplicationSettingsProps {
   settings: UserSettingsType;
-  onSettingChange: (key: keyof UserSettingsType, value: any) => void;
+  onSettingChange: (key: keyof UserSettingsType, value: boolean | number | string) => void;
   onMaxClipsChange: (value: number) => void;
   saving: boolean;
   tempMaxClips: number | null;
diff --git a/src/renderer/src/components/settings/usersettings/WindowSettings.tsx b/src/renderer/src/components/settings/usersettings/WindowSettings.tsx
index a05047c..b50cbcb 100644
--- a/src/renderer/src/components/settings/usersettings/WindowSettings.tsx
+++ b/src/renderer/src/components/settings/usersettings/WindowSettings.tsx
@@ -8,7 +8,7 @@ import styles from '../StorageSettings.module.css';
 
 interface WindowSettingsProps {
   settings: UserSettingsType;
-  onSettingChange: (key: keyof UserSettingsType, value: any) => void;
+  onSettingChange: (key: keyof UserSettingsType, value: boolean | number | string) => void;
   saving: boolean;
 }
 
diff --git a/src/renderer/src/components/settings/usersettings/useUserSettings.ts b/src/renderer/src/components/settings/usersettings/useUserSettings.ts
index d891f1a..74edf2a 100644
--- a/src/renderer/src/components/settings/usersettings/useUserSettings.ts
+++ b/src/renderer/src/components/settings/usersettings/useUserSettings.ts
@@ -43,7 +43,10 @@ export const useUserSettings = () => {
     };
   }, [debounceTimeout]);
 
-  const handleSettingChange = async (key: keyof UserSettingsType, value: any) => {
+  const handleSettingChange = async (
+    key: keyof UserSettingsType,
+    value: boolean | number | string
+  ) => {
     if (!settings || !window.api) return;
 
     setSaving(true);
@@ -55,12 +58,12 @@ export const useUserSettings = () => {
         setSettings(updatedSettings);
 
         // Update temp value if maxClips was changed
-        if (key === 'maxClips') {
+        if (key === 'maxClips' && typeof value === 'number') {
           setTempMaxClips(value);
         }
 
         // Update language detection settings if code detection was changed
-        if (key === 'codeDetectionEnabled') {
+        if (key === 'codeDetectionEnabled' && typeof value === 'boolean') {
           updateLanguageSettings({ codeDetectionEnabled: value });
         }
 
diff --git a/src/renderer/src/hooks/useContextMenu.ts b/src/renderer/src/hooks/useContextMenu.ts
index 0b3497b..73911ae 100644
--- a/src/renderer/src/hooks/useContextMenu.ts
+++ b/src/renderer/src/hooks/useContextMenu.ts
@@ -17,7 +17,7 @@ export function useContextMenu() {
   const openContextMenu = useCallback((event: React.MouseEvent, targetIndex?: number) => {
     event.preventDefault();
     event.stopPropagation();
-    
+
     setContextMenu({
       isOpen: true,
       x: event.clientX,
diff --git a/src/renderer/src/hooks/usePatternDetection.test.ts b/src/renderer/src/hooks/usePatternDetection.test.ts
new file mode 100644
index 0000000..6be208f
--- /dev/null
+++ b/src/renderer/src/hooks/usePatternDetection.test.ts
@@ -0,0 +1,166 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { renderHook, waitFor } from '@testing-library/react';
+import { usePatternDetection } from './usePatternDetection';
+
+describe('usePatternDetection', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (window.api as any).quickClipsScanText = vi.fn().mockResolvedValue([]);
+  });
+
+  it('returns no patterns for empty content', () => {
+    const { result } = renderHook(() => usePatternDetection(''));
+    expect(result.current.hasPatterns).toBe(false);
+    expect(result.current.patterns).toEqual([]);
+  });
+
+  it('returns no patterns for whitespace-only content', () => {
+    const { result } = renderHook(() => usePatternDetection('   '));
+    expect(result.current.hasPatterns).toBe(false);
+  });
+
+  it('detects patterns from API', async () => {
+    const mockMatches = [
+      { searchTermId: '1', searchTermName: 'Email', captures: { email: 'test@example.com' } },
+    ];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (window.api as any).quickClipsScanText = vi.fn().mockResolvedValue(mockMatches);
+
+    const { result } = renderHook(() => usePatternDetection('test@example.com'));
+
+    await waitFor(() => {
+      expect(result.current.hasPatterns).toBe(true);
+    });
+
+    expect(result.current.patterns).toEqual(mockMatches);
+  });
+
+  it('handles API errors gracefully', async () => {
+    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (window.api as any).quickClipsScanText = vi.fn().mockRejectedValue(new Error('fail'));
+
+    const { result } = renderHook(() => usePatternDetection('some text'));
+
+    // Wait for debounce to fire and error to be processed
+    await waitFor(() => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      expect((window.api as any).quickClipsScanText).toHaveBeenCalled();
+    });
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(result.current.hasPatterns).toBe(false);
+    expect(result.current.patterns).toEqual([]);
+    consoleSpy.mockRestore();
+  });
+
+  it('cancels previous detection on content change', async () => {
+    const mockScan = vi.fn().mockResolvedValue([]);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (window.api as any).quickClipsScanText = mockScan;
+
+    const { rerender, result } = renderHook(({ content }) => usePatternDetection(content), {
+      initialProps: { content: 'first' },
+    });
+
+    // Change content before debounce fires
+    rerender({ content: 'second' });
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+  });
+
+  it('does not update state if cancelled during API call', async () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let resolveApi: (value: any) => void;
+    const apiPromise = new Promise((resolve) => {
+      resolveApi = resolve;
+    });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (window.api as any).quickClipsScanText = vi.fn().mockReturnValue(apiPromise);
+
+    const { unmount } = renderHook(() => usePatternDetection('test content'));
+
+    // Wait for the debounce
+    await new Promise((r) => setTimeout(r, 350));
+
+    // Unmount before the API resolves (triggers isCancelled)
+    unmount();
+
+    // Now resolve the API
+    resolveApi!([{ searchTermId: '1', searchTermName: 'Test', captures: { test: 'val' } }]);
+
+    // No error should occur - state updates are skipped
+  });
+
+  it('logs error and resets state on API failure', async () => {
+    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const mockScan = vi.fn().mockRejectedValue(new Error('scan error'));
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (window.api as any).quickClipsScanText = mockScan;
+
+    const { result } = renderHook(() => usePatternDetection('test content'));
+
+    await waitFor(() => {
+      expect(mockScan).toHaveBeenCalled();
+    });
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(result.current.hasPatterns).toBe(false);
+    expect(result.current.patterns).toEqual([]);
+    consoleSpy.mockRestore();
+  });
+
+  it('skips state update when error occurs after cancellation', async () => {
+    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    let rejectApi: (err: Error) => void;
+    const apiPromise = new Promise((_resolve, reject) => {
+      rejectApi = reject;
+    });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (window.api as any).quickClipsScanText = vi.fn().mockReturnValue(apiPromise);
+
+    const { unmount } = renderHook(() => usePatternDetection('error content'));
+
+    // Wait for debounce to fire
+    await new Promise((r) => setTimeout(r, 350));
+
+    // Unmount first (sets isCancelled = true), then reject
+    unmount();
+    rejectApi!(new Error('cancelled error'));
+
+    // Allow microtask to process
+    await new Promise((r) => setTimeout(r, 50));
+
+    consoleSpy.mockRestore();
+  });
+
+  it('clears patterns when content becomes empty', async () => {
+    const mockMatches = [
+      { searchTermId: '1', searchTermName: 'Email', captures: { email: 'test@example.com' } },
+    ];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (window.api as any).quickClipsScanText = vi.fn().mockResolvedValue(mockMatches);
+
+    const { rerender, result } = renderHook(({ content }) => usePatternDetection(content), {
+      initialProps: { content: 'test@example.com' },
+    });
+
+    await waitFor(() => {
+      expect(result.current.hasPatterns).toBe(true);
+    });
+
+    rerender({ content: '' });
+
+    expect(result.current.hasPatterns).toBe(false);
+    expect(result.current.patterns).toEqual([]);
+  });
+});
diff --git a/src/renderer/src/providers/clips/index.tsx b/src/renderer/src/providers/clips/index.tsx
index 4741b3e..da1d464 100644
--- a/src/renderer/src/providers/clips/index.tsx
+++ b/src/renderer/src/providers/clips/index.tsx
@@ -1,4 +1,12 @@
-import { createContext, useContext, useMemo, useState, useRef, useEffect, useCallback } from 'react';
+import {
+  createContext,
+  useContext,
+  useMemo,
+  useState,
+  useRef,
+  useEffect,
+  useCallback,
+} from 'react';
 import { DEFAULT_MAX_CLIPS } from '../constants';
 import { useLanguageDetection } from '../languageDetection';
 import { ClipItem, ClipsContextType, ClipboardState } from './types';
@@ -7,8 +15,10 @@ import { useClipsStorage } from './storage';
 import { useClipboardOperations } from './clipboard';
 import { useClipState } from './state';
 
+// eslint-disable-next-line react-refresh/only-export-components
 export const ClipsContext = createContext({});
 
+// eslint-disable-next-line react-refresh/only-export-components
 export const useClips = (): ClipsContextType => useContext(ClipsContext) as ClipsContextType;
 
 export function ClipsProvider({ children }: { children: React.ReactNode }) {
@@ -120,8 +130,8 @@ export function ClipsProvider({ children }: { children: React.ReactNode }) {
       if (clip.type === 'bookmark') {
         if (
           clip.content.toLowerCase().includes(term) ||
-          (clip.title && clip.title.toLowerCase().includes(term)) ||
-          (clip.url && clip.url.toLowerCase().includes(term))
+          clip.title?.toLowerCase().includes(term) ||
+          clip.url?.toLowerCase().includes(term)
         ) {
           acc.push({ clip, originalIndex: index });
         }
@@ -186,5 +196,7 @@ export function ClipsProvider({ children }: { children: React.ReactNode }) {
 }
 
 // Re-export all the types and utilities for consumers
+// eslint-disable-next-line react-refresh/only-export-components
 export * from './types';
+// eslint-disable-next-line react-refresh/only-export-components
 export * from './utils';
diff --git a/src/renderer/src/providers/clips/storage.ts b/src/renderer/src/providers/clips/storage.ts
index 58bc788..d19cb63 100644
--- a/src/renderer/src/providers/clips/storage.ts
+++ b/src/renderer/src/providers/clips/storage.ts
@@ -2,6 +2,7 @@ import { useEffect } from 'react';
 import { ClipItem } from './types';
 import { DEFAULT_MAX_CLIPS } from '../constants';
 import { updateClipsLength } from './utils';
+import { UserSettings, StoredClip } from '../../../../shared/types';
 
 /**
  * Hook for managing storage operations for clips and settings
@@ -41,7 +42,7 @@ export const useClipsStorage = (
 
           // Process stored clips and rebuild the array properly
           let clipIndex = 0;
-          storedClips.forEach((storedClip: any) => {
+          storedClips.forEach((storedClip: StoredClip) => {
             if (storedClip.clip?.content && storedClip.clip.content.trim() !== '') {
               loadedClips.push(storedClip.clip); // Use push instead of index assignment
               // Only allow locking for clips at index 1 and higher
@@ -77,13 +78,13 @@ export const useClipsStorage = (
     };
 
     loadStoredData();
-  }, []); // Empty dependency array - only run once on mount
+  }, [setClips, setLockedClips, setMaxClips, setIsInitiallyLoading]); // Dependencies are stable setter functions
 
   // Listen for settings updates from other windows (like settings window)
   useEffect(() => {
     if (!window.api?.onSettingsUpdated) return;
 
-    const handleSettingsUpdate = (updatedSettings: any) => {
+    const handleSettingsUpdate = (updatedSettings: UserSettings) => {
       console.log('Received settings update from other window:', updatedSettings);
       if (updatedSettings && typeof updatedSettings.maxClips === 'number') {
         setMaxClips(updatedSettings.maxClips);
@@ -161,7 +162,7 @@ export const useClipsStorage = (
   // Settings listener
   useEffect(() => {
     if (window.api) {
-      window.api.onSettingsUpdated((settings: any) => {
+      window.api.onSettingsUpdated((settings: UserSettings) => {
         console.log('Settings updated in main window:', settings);
         // Handle settings changes here if needed
       });
diff --git a/src/renderer/src/providers/languageDetection.tsx b/src/renderer/src/providers/languageDetection.tsx
index cf4e4cc..d2c5bda 100644
--- a/src/renderer/src/providers/languageDetection.tsx
+++ b/src/renderer/src/providers/languageDetection.tsx
@@ -29,6 +29,7 @@ const defaultSettings: LanguageDetectionSettings = {
   codeDetectionEnabled: true,
 };
 
+// eslint-disable-next-line react-refresh/only-export-components
 export const LanguageDetectionContext = createContext<LanguageDetectionContextType>({
   settings: defaultSettings,
   updateSettings: () => {},
@@ -36,6 +37,7 @@ export const LanguageDetectionContext = createContext<LanguageDetectionContextTy
   isCodeDetectionEnabled: true,
 });
 
+// eslint-disable-next-line react-refresh/only-export-components
 export const useLanguageDetection = (): LanguageDetectionContextType =>
   useContext(LanguageDetectionContext);
 
@@ -99,11 +101,12 @@ export function LanguageDetectionProvider({ children }: { children: React.ReactN
   useEffect(() => {
     if (!window.api?.onSettingsUpdated) return;
 
-    const handleSettingsUpdate = (updatedSettings: any) => {
+    const handleSettingsUpdate = (updatedSettings: Partial<LanguageDetectionSettings>) => {
       if (updatedSettings && typeof updatedSettings.codeDetectionEnabled === 'boolean') {
+        const enabled = updatedSettings.codeDetectionEnabled;
         setSettings((prevSettings) => ({
           ...prevSettings,
-          codeDetectionEnabled: updatedSettings.codeDetectionEnabled,
+          codeDetectionEnabled: enabled,
         }));
       }
     };
diff --git a/src/renderer/src/providers/theme.test.tsx b/src/renderer/src/providers/theme.test.tsx
new file mode 100644
index 0000000..8f93fce
--- /dev/null
+++ b/src/renderer/src/providers/theme.test.tsx
@@ -0,0 +1,324 @@
+import { describe, it, expect, vi, afterEach, beforeEach } from 'vitest';
+import { render, screen, act, cleanup } from '@testing-library/react';
+import { ThemeProvider, useTheme } from './theme';
+
+// Test component that displays theme info
+function ThemeDisplay() {
+  const { theme, effectiveTheme, isLight, isDark, setTheme } = useTheme();
+  return (
+    <div>
+      <span data-testid="theme">{theme}</span>
+      <span data-testid="effective">{effectiveTheme}</span>
+      <span data-testid="isLight">{String(isLight)}</span>
+      <span data-testid="isDark">{String(isDark)}</span>
+      <button onClick={() => setTheme('light')}>Set Light</button>
+      <button onClick={() => setTheme('dark')}>Set Dark</button>
+      <button onClick={() => setTheme('system')}>Set System</button>
+    </div>
+  );
+}
+
+describe('ThemeProvider', () => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let settingsCallback: ((settings: any) => void) | null = null;
+  let mediaChangeCallback: (() => void) | null = null;
+
+  beforeEach(() => {
+    settingsCallback = null;
+    mediaChangeCallback = null;
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (window as any).api = {
+      storageGetSettings: vi.fn().mockResolvedValue({ theme: 'system' }),
+      storageSaveSettings: vi.fn().mockResolvedValue(undefined),
+      onSettingsUpdated: vi.fn().mockImplementation((cb) => {
+        settingsCallback = cb;
+        return vi.fn(); // cleanup function
+      }),
+    };
+
+    // Mock matchMedia
+    Object.defineProperty(window, 'matchMedia', {
+      writable: true,
+      value: vi.fn().mockImplementation((query) => ({
+        matches: false,
+        media: query,
+        addEventListener: vi.fn().mockImplementation((_event, cb) => {
+          mediaChangeCallback = cb;
+        }),
+        removeEventListener: vi.fn(),
+      })),
+    });
+  });
+
+  afterEach(() => {
+    cleanup();
+  });
+
+  it('provides default theme values', () => {
+    render(
+      <ThemeProvider>
+        <ThemeDisplay />
+      </ThemeProvider>
+    );
+    expect(screen.getByTestId('theme').textContent).toBe('system');
+  });
+
+  it('allows setting theme to light', async () => {
+    render(
+      <ThemeProvider>
+        <ThemeDisplay />
+      </ThemeProvider>
+    );
+
+    await act(async () => {
+      screen.getByText('Set Light').click();
+    });
+
+    expect(screen.getByTestId('effective').textContent).toBe('light');
+    expect(screen.getByTestId('isLight').textContent).toBe('true');
+    expect(screen.getByTestId('isDark').textContent).toBe('false');
+  });
+
+  it('allows setting theme to dark', async () => {
+    await act(async () => {
+      render(
+        <ThemeProvider>
+          <ThemeDisplay />
+        </ThemeProvider>
+      );
+    });
+
+    await act(async () => {
+      screen.getByText('Set Dark').click();
+    });
+
+    expect(screen.getByTestId('effective').textContent).toBe('dark');
+  });
+
+  it('loads theme from settings on mount', async () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (window.api as any).storageGetSettings = vi.fn().mockResolvedValue({ theme: 'dark' });
+
+    await act(async () => {
+      render(
+        <ThemeProvider>
+          <ThemeDisplay />
+        </ThemeProvider>
+      );
+    });
+
+    expect(screen.getByTestId('theme').textContent).toBe('dark');
+    expect(screen.getByTestId('effective').textContent).toBe('dark');
+  });
+
+  it('handles theme loading error by defaulting to system', async () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (window.api as any).storageGetSettings = vi.fn().mockRejectedValue(new Error('fail'));
+    const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    await act(async () => {
+      render(
+        <ThemeProvider>
+          <ThemeDisplay />
+        </ThemeProvider>
+      );
+    });
+
+    expect(screen.getByTestId('theme').textContent).toBe('system');
+    spy.mockRestore();
+  });
+
+  it('handles missing api gracefully during load', async () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (window as any).api = undefined;
+
+    await act(async () => {
+      render(
+        <ThemeProvider>
+          <ThemeDisplay />
+        </ThemeProvider>
+      );
+    });
+
+    expect(screen.getByTestId('theme').textContent).toBe('system');
+  });
+
+  it('responds to settings updates from other windows', async () => {
+    await act(async () => {
+      render(
+        <ThemeProvider>
+          <ThemeDisplay />
+        </ThemeProvider>
+      );
+    });
+
+    expect(settingsCallback).toBeTruthy();
+
+    await act(async () => {
+      settingsCallback!({ theme: 'light' });
+    });
+
+    expect(screen.getByTestId('theme').textContent).toBe('light');
+    expect(screen.getByTestId('effective').textContent).toBe('light');
+  });
+
+  it('handles save error gracefully', async () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (window.api as any).storageSaveSettings = vi.fn().mockRejectedValue(new Error('save fail'));
+    const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    render(
+      <ThemeProvider>
+        <ThemeDisplay />
+      </ThemeProvider>
+    );
+
+    await act(async () => {
+      screen.getByText('Set Light').click();
+    });
+
+    // Should still update locally even if save fails
+    expect(screen.getByTestId('effective').textContent).toBe('light');
+    spy.mockRestore();
+  });
+
+  it('handles missing api during save', async () => {
+    render(
+      <ThemeProvider>
+        <ThemeDisplay />
+      </ThemeProvider>
+    );
+
+    // Remove api after mount
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (window as any).api = undefined;
+
+    await act(async () => {
+      screen.getByText('Set Light').click();
+    });
+
+    // Should still update locally
+    expect(screen.getByTestId('effective').textContent).toBe('light');
+  });
+
+  it('resolves system theme to light when matchMedia prefers light', () => {
+    render(
+      <ThemeProvider>
+        <ThemeDisplay />
+      </ThemeProvider>
+    );
+
+    expect(screen.getByTestId('theme').textContent).toBe('system');
+  });
+
+  it('throws when useTheme is used outside provider', () => {
+    const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    expect(() => render(<ThemeDisplay />)).toThrow('useTheme must be used within a ThemeProvider');
+    spy.mockRestore();
+  });
+
+  it('resolves system theme to dark when matchMedia prefers dark', async () => {
+    Object.defineProperty(window, 'matchMedia', {
+      writable: true,
+      value: vi.fn().mockImplementation((query: string) => ({
+        matches: true, // prefers dark
+        media: query,
+        addEventListener: vi.fn(),
+        removeEventListener: vi.fn(),
+      })),
+    });
+
+    await act(async () => {
+      render(
+        <ThemeProvider>
+          <ThemeDisplay />
+        </ThemeProvider>
+      );
+    });
+
+    expect(screen.getByTestId('effective').textContent).toBe('dark');
+  });
+
+  it('defaults to system when settings has no theme property', async () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (window.api as any).storageGetSettings = vi.fn().mockResolvedValue({});
+
+    await act(async () => {
+      render(
+        <ThemeProvider>
+          <ThemeDisplay />
+        </ThemeProvider>
+      );
+    });
+
+    expect(screen.getByTestId('theme').textContent).toBe('system');
+  });
+
+  it('ignores settings update without theme property', async () => {
+    await act(async () => {
+      render(
+        <ThemeProvider>
+          <ThemeDisplay />
+        </ThemeProvider>
+      );
+    });
+
+    await act(async () => {
+      settingsCallback!({ maxClips: 200 }); // no theme property
+    });
+
+    // Theme should remain unchanged (system)
+    expect(screen.getByTestId('theme').textContent).toBe('system');
+  });
+
+  it('responds to system theme media change', async () => {
+    // Theme defaults to 'system', so the media change listener should be active
+    await act(async () => {
+      render(
+        <ThemeProvider>
+          <ThemeDisplay />
+        </ThemeProvider>
+      );
+    });
+
+    expect(mediaChangeCallback).toBeTruthy();
+
+    // Simulate system theme change
+    // Change matchMedia to return dark
+    Object.defineProperty(window, 'matchMedia', {
+      writable: true,
+      value: vi.fn().mockImplementation((query: string) => ({
+        matches: true,
+        media: query,
+        addEventListener: vi.fn(),
+        removeEventListener: vi.fn(),
+      })),
+    });
+
+    await act(async () => {
+      mediaChangeCallback!();
+    });
+
+    expect(screen.getByTestId('effective').textContent).toBe('dark');
+  });
+
+  it('does not listen for settings updates when api.onSettingsUpdated is missing', async () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (window as any).api = {
+      storageGetSettings: vi.fn().mockResolvedValue({ theme: 'system' }),
+      storageSaveSettings: vi.fn(),
+    };
+
+    await act(async () => {
+      render(
+        <ThemeProvider>
+          <ThemeDisplay />
+        </ThemeProvider>
+      );
+    });
+
+    // Should not throw
+    expect(screen.getByTestId('theme').textContent).toBe('system');
+  });
+});
diff --git a/src/renderer/src/providers/theme.tsx b/src/renderer/src/providers/theme.tsx
index 85ce326..ca97ccd 100644
--- a/src/renderer/src/providers/theme.tsx
+++ b/src/renderer/src/providers/theme.tsx
@@ -68,7 +68,7 @@ export const ThemeProvider: React.FC<ThemeProviderProps> = ({ children }) => {
     };
 
     loadTheme();
-  }, []);
+  }, [updateEffectiveTheme]);
 
   // Listen for settings changes from other windows
   useEffect(() => {
@@ -86,7 +86,7 @@ export const ThemeProvider: React.FC<ThemeProviderProps> = ({ children }) => {
 
     // Return the cleanup function to remove only this specific listener
     return cleanup;
-  }, []); // Empty dependency array since we want this to run only once
+  }, [updateEffectiveTheme]); // Empty dependency array since we want this to run only once
 
   // Listen for system theme changes when using system theme
   useEffect(() => {
@@ -97,7 +97,7 @@ export const ThemeProvider: React.FC<ThemeProviderProps> = ({ children }) => {
 
     mediaQuery.addEventListener('change', handleChange);
     return () => mediaQuery.removeEventListener('change', handleChange);
-  }, [theme]);
+  }, [theme, updateEffectiveTheme]);
 
   const setTheme = async (newTheme: Theme) => {
     setThemeState(newTheme);
@@ -128,6 +128,7 @@ export const ThemeProvider: React.FC<ThemeProviderProps> = ({ children }) => {
   return <ThemeContext.Provider value={contextValue}>{children}</ThemeContext.Provider>;
 };
 
+// eslint-disable-next-line react-refresh/only-export-components
 export const useTheme = (): ThemeContextType => {
   const context = useContext(ThemeContext);
   if (context === undefined) {
diff --git a/src/renderer/src/test-setup.ts b/src/renderer/src/test-setup.ts
new file mode 100644
index 0000000..1467b8c
--- /dev/null
+++ b/src/renderer/src/test-setup.ts
@@ -0,0 +1,45 @@
+import '@testing-library/jest-dom/vitest';
+import { vi } from 'vitest';
+
+// Mock matchMedia for jsdom
+Object.defineProperty(window, 'matchMedia', {
+  writable: true,
+  value: vi.fn().mockImplementation((query: string) => ({
+    matches: false,
+    media: query,
+    onchange: null,
+    addListener: vi.fn(),
+    removeListener: vi.fn(),
+    addEventListener: vi.fn(),
+    removeEventListener: vi.fn(),
+    dispatchEvent: vi.fn(),
+  })),
+});
+
+// Mock window.api for renderer tests
+const createMockApi = () => ({
+  storageGetSettings: vi.fn().mockResolvedValue({
+    maxClips: 100,
+    startMinimized: false,
+    autoStart: false,
+    theme: 'system',
+    windowTransparency: 0,
+    transparencyEnabled: false,
+    opaqueWhenFocused: true,
+    alwaysOnTop: false,
+    rememberWindowPosition: true,
+    showNotifications: false,
+    codeDetectionEnabled: true,
+  }),
+  storageSaveSettings: vi.fn().mockResolvedValue(undefined),
+  onSettingsUpdated: vi.fn().mockReturnValue(() => {}),
+  removeSettingsListeners: vi.fn(),
+  quickClipsScanText: vi.fn().mockResolvedValue([]),
+  onToggleSearch: vi.fn(),
+  removeToggleSearchListeners: vi.fn(),
+});
+
+Object.defineProperty(window, 'api', {
+  value: createMockApi(),
+  writable: true,
+});
diff --git a/src/renderer/src/utils/languageDetection.test.ts b/src/renderer/src/utils/languageDetection.test.ts
new file mode 100644
index 0000000..622d10a
--- /dev/null
+++ b/src/renderer/src/utils/languageDetection.test.ts
@@ -0,0 +1,187 @@
+import { describe, it, expect } from 'vitest';
+import { detectLanguage, isCode, mapToSyntaxHighlighterLanguage } from './languageDetection';
+
+describe('detectLanguage', () => {
+  it('returns null for short text (< 5 chars)', () => {
+    expect(detectLanguage('hi')).toBeNull();
+    expect(detectLanguage('abcd')).toBeNull();
+  });
+
+  it('returns null for empty string', () => {
+    expect(detectLanguage('')).toBeNull();
+  });
+
+  it('detects JavaScript', () => {
+    const code = `
+      const foo = require('bar');
+      function hello() {
+        console.log("world");
+      }
+    `;
+    expect(detectLanguage(code)).toBe('javascript');
+  });
+
+  it('detects TypeScript', () => {
+    const code = `
+      interface User {
+        name: string;
+        age: number;
+      }
+      type Greeting = string;
+      enum Role { Admin, User }
+      const greet = (user: User): void => {};
+    `;
+    const result = detectLanguage(code);
+    // TypeScript and JavaScript are closely related; accept either
+    expect(['typescript', 'javascript']).toContain(result);
+  });
+
+  it('detects Python', () => {
+    const code = `
+      def hello():
+          print("hello world")
+      if __name__ == "__main__":
+          hello()
+    `;
+    expect(detectLanguage(code)).toBe('python');
+  });
+
+  it('detects HTML', () => {
+    const code = `<!DOCTYPE html><html><body><div>Hello</div></body></html>`;
+    expect(detectLanguage(code)).toBe('html');
+  });
+
+  it('detects SQL', () => {
+    const code = `SELECT name, email FROM users WHERE id = 1`;
+    expect(detectLanguage(code)).toBe('sql');
+  });
+
+  it('returns null for plain text', () => {
+    const text = 'The weather is nice today and the sun is shining brightly.';
+    expect(detectLanguage(text)).toBeNull();
+  });
+
+  it('returns null for null/undefined', () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    expect(detectLanguage(null as any)).toBeNull();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    expect(detectLanguage(undefined as any)).toBeNull();
+  });
+
+  it('detects JSON', () => {
+    const code = '{"name": "test", "value": 42, "active": true}';
+    expect(detectLanguage(code)).toBe('json');
+  });
+
+  it('detects CSS', () => {
+    const code = `.container { color: red; background: blue; margin: 10px; padding: 5px; }`;
+    expect(detectLanguage(code)).toBe('css');
+  });
+
+  it('detects bash', () => {
+    const code = `#!/bin/bash\necho "hello"\ncd /home\nls -la | grep test`;
+    expect(detectLanguage(code)).toBe('bash');
+  });
+
+  it('detects Java', () => {
+    const code = `public class Main {\n  public static void main(String[] args) {\n    System.out.println("Hello");\n  }\n}`;
+    expect(detectLanguage(code)).toBe('java');
+  });
+});
+
+describe('isCode', () => {
+  it('returns false for empty string', () => {
+    expect(isCode('')).toBe(false);
+  });
+
+  it('returns false for short non-code text', () => {
+    expect(isCode('hi')).toBe(false);
+  });
+
+  it('returns true for code with brackets and semicolons', () => {
+    expect(isCode('const x = 5; if (x > 3) { return true; }')).toBe(true);
+  });
+
+  it('returns true for arrow functions', () => {
+    expect(isCode('const fn = () => {')).toBe(true);
+  });
+
+  it('returns true for method calls', () => {
+    expect(isCode('object.method()')).toBe(true);
+  });
+
+  it('returns false for plain text', () => {
+    expect(isCode('Hello, this is a normal sentence.')).toBe(false);
+  });
+
+  it('returns false for null/undefined', () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    expect(isCode(null as any)).toBe(false);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    expect(isCode(undefined as any)).toBe(false);
+  });
+
+  it('returns true for strong code indicators', () => {
+    expect(isCode('const handleX = (')).toBe(true);
+    expect(isCode('obj.method()')).toBe(true);
+    expect(isCode('=> {')).toBe(true);
+  });
+
+  it('detects code in small snippets (< 20 chars)', () => {
+    expect(isCode('x = 5;')).toBe(true);
+  });
+
+  it('detects code in medium snippets (20-50 chars)', () => {
+    expect(isCode('const x = 5; let y = 10;')).toBe(true);
+  });
+
+  it('detects code in large snippets (> 50 chars)', () => {
+    const largeCode = 'const foo = "bar"; const baz = 42; if (foo) { console.log(baz); }';
+    expect(isCode(largeCode)).toBe(true);
+  });
+
+  it('returns false for text under 3 chars', () => {
+    expect(isCode('hi')).toBe(false);
+  });
+
+  it('returns false for large non-code text (> 50 chars)', () => {
+    const plainText =
+      'This is a perfectly normal sentence that has no code indicators whatsoever and is quite long.';
+    expect(isCode(plainText)).toBe(false);
+  });
+});
+
+describe('mapToSyntaxHighlighterLanguage', () => {
+  it('maps javascript correctly', () => {
+    expect(mapToSyntaxHighlighterLanguage('javascript')).toBe('javascript');
+  });
+
+  it('maps html to markup', () => {
+    expect(mapToSyntaxHighlighterLanguage('html')).toBe('markup');
+  });
+
+  it('returns text for unknown language', () => {
+    expect(mapToSyntaxHighlighterLanguage('unknown')).toBe('text');
+  });
+
+  it('maps all known languages', () => {
+    const known = [
+      'javascript',
+      'typescript',
+      'python',
+      'java',
+      'csharp',
+      'cpp',
+      'c',
+      'css',
+      'json',
+      'xml',
+      'sql',
+      'bash',
+      'powershell',
+    ];
+    for (const lang of known) {
+      expect(mapToSyntaxHighlighterLanguage(lang)).not.toBe('text');
+    }
+  });
+});
diff --git a/tsconfig.eslint.json b/tsconfig.eslint.json
index 741f723..7992a70 100644
--- a/tsconfig.eslint.json
+++ b/tsconfig.eslint.json
@@ -10,6 +10,7 @@
     "src/**/*.tsx",
     "src/**/*.js",
     "src/**/*.jsx",
+    "e2e/**/*.ts",
     "*.ts",
     "*.js",
     "*.mjs"
diff --git a/vitest.config.ts b/vitest.config.ts
new file mode 100644
index 0000000..c2175d8
--- /dev/null
+++ b/vitest.config.ts
@@ -0,0 +1,35 @@
+import { defineConfig } from 'vitest/config';
+import { resolve } from 'path';
+
+export default defineConfig({
+  test: {
+    projects: [
+      {
+        define: {
+          __APP_VERSION__: JSON.stringify('0.0.0-test'),
+        },
+        test: {
+          name: 'node',
+          include: ['src/main/**/*.test.ts', 'src/preload/**/*.test.ts'],
+          environment: 'node',
+        },
+      },
+      {
+        define: {
+          __APP_VERSION__: JSON.stringify('0.0.0-test'),
+        },
+        test: {
+          name: 'renderer',
+          include: ['src/renderer/**/*.test.ts', 'src/renderer/**/*.test.tsx'],
+          environment: 'jsdom',
+          setupFiles: ['src/renderer/src/test-setup.ts'],
+        },
+        resolve: {
+          alias: {
+            '@renderer': resolve(__dirname, 'src/renderer/src'),
+          },
+        },
+      },
+    ],
+  },
+});